From 107640348cc60f34f8102ec450dea3fba48cd634 Mon Sep 17 00:00:00 2001
From: nlupugla <lupu.gladstein@gmail.com>
Date: Sat, 21 Sep 2024 11:38:25 -0400
Subject: [PATCH 1/2] Added Structs to core.

---
 SConstruct                             |   2 +
 core/core_bind.cpp                     |  77 +++++
 core/core_bind.h                       |   8 +
 core/object/class_db.cpp               |  73 +++++
 core/object/class_db.h                 |  10 +
 core/object/method_info.cpp            |  99 +++++++
 core/object/method_info.h              | 137 +++++++++
 core/object/object.cpp                 | 143 +++------
 core/object/object.h                   | 260 ++--------------
 core/object/property_info.cpp          |  90 ++++++
 core/object/property_info.h            | 176 +++++++++++
 core/string/ustring.cpp                |   6 +-
 core/variant/array.cpp                 | 324 ++++++++++++++++----
 core/variant/array.h                   |  28 ++
 core/variant/container_type_validate.h | 152 +++++++---
 core/variant/dictionary.cpp            | 123 ++++----
 core/variant/dictionary.h              |   1 +
 core/variant/struct.h                  | 146 +++++++++
 core/variant/struct_generator.cpp      |  65 ++++
 core/variant/struct_generator.h        | 303 +++++++++++++++++++
 core/variant/typed_array.h             |  51 +++-
 core/variant/variant.cpp               |  17 +-
 core/variant/variant.h                 |   3 +
 core/variant/variant_construct.cpp     |   1 +
 core/variant/variant_construct.h       |  87 ++++++
 core/variant/variant_setget.cpp        |  78 +++--
 scene/resources/2d/tile_set.h          |   4 +-
 tests/core/variant/test_struct.h       | 395 +++++++++++++++++++++++++
 tests/test_main.cpp                    |   1 +
 29 files changed, 2343 insertions(+), 517 deletions(-)
 create mode 100644 core/object/method_info.cpp
 create mode 100644 core/object/method_info.h
 create mode 100644 core/object/property_info.cpp
 create mode 100644 core/object/property_info.h
 create mode 100644 core/variant/struct.h
 create mode 100644 core/variant/struct_generator.cpp
 create mode 100644 core/variant/struct_generator.h
 create mode 100644 tests/core/variant/test_struct.h

diff --git a/SConstruct b/SConstruct
index 63cff4fe1672..1ac598fc0b37 100644
--- a/SConstruct
+++ b/SConstruct
@@ -856,6 +856,8 @@ if env.msvc and not methods.using_clang(env):  # MSVC
             ]
         )
 
+        env.Append(CCFLAGS=["/permissive-"])
+
     if env["werror"]:
         env.Append(CCFLAGS=["/WX"])
         env.Append(LINKFLAGS=["/WX"])
diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index 891e3a28c9ed..a49d8aa44751 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -42,6 +42,7 @@
 #include "core/math/geometry_3d.h"
 #include "core/os/keyboard.h"
 #include "core/os/thread_safe.h"
+#include "core/variant/struct.h"
 #include "core/variant/typed_array.h"
 
 namespace core_bind {
@@ -1442,6 +1443,15 @@ Dictionary ClassDB::class_get_signal(const StringName &p_class, const StringName
 	}
 }
 
+//Struct<MethodInfo> ClassDB::class_get_signal_as_struct(const StringName &p_class, const StringName &p_signal) const {
+//	MethodInfo signal;
+//	if (::ClassDB::get_signal(p_class, p_signal, &signal)) {
+//		return Struct<MethodInfo>(signal);
+//	} else {
+//		return Struct<MethodInfo>();
+//	}
+//}
+
 TypedArray<Dictionary> ClassDB::class_get_signal_list(const StringName &p_class, bool p_no_inheritance) const {
 	List<MethodInfo> signals;
 	::ClassDB::get_signal_list(p_class, &signals, p_no_inheritance);
@@ -1454,6 +1464,12 @@ TypedArray<Dictionary> ClassDB::class_get_signal_list(const StringName &p_class,
 	return ret;
 }
 
+//TypedArray<Struct<MethodInfo>> ClassDB::class_get_signal_list_as_structs(const StringName &p_class, bool p_no_inheritance) const {
+//	List<MethodInfo> signals;
+//	::ClassDB::get_signal_list(p_class, &signals, p_no_inheritance);
+//	return TypedArray<Struct<MethodInfo>>(&signals);
+//}
+
 TypedArray<Dictionary> ClassDB::class_get_property_list(const StringName &p_class, bool p_no_inheritance) const {
 	List<PropertyInfo> plist;
 	::ClassDB::get_property_list(p_class, &plist, p_no_inheritance);
@@ -1465,6 +1481,12 @@ TypedArray<Dictionary> ClassDB::class_get_property_list(const StringName &p_clas
 	return ret;
 }
 
+//TypedArray<Struct<PropertyInfo>> ClassDB::class_get_property_list_as_structs(const StringName &p_class, bool p_no_inheritance) const {
+//	List<PropertyInfo> plist;
+//	::ClassDB::get_property_list(p_class, &plist, p_no_inheritance);
+//	return TypedArray<Struct<PropertyInfo>>(&plist);
+//}
+
 StringName ClassDB::class_get_property_getter(const StringName &p_class, const StringName &p_property) {
 	return ::ClassDB::get_property_getter(p_class, p_property);
 }
@@ -1525,6 +1547,12 @@ TypedArray<Dictionary> ClassDB::class_get_method_list(const StringName &p_class,
 	return ret;
 }
 
+//TypedArray<Struct<MethodInfo>> ClassDB::class_get_method_list_as_structs(const StringName &p_class, bool p_no_inheritance) const {
+//	List<MethodInfo> methods;
+//	::ClassDB::get_method_list(p_class, &methods, p_no_inheritance);
+//	return TypedArray<Struct<MethodInfo>>(&methods);
+//}
+
 Variant ClassDB::class_call_static_method(const Variant **p_arguments, int p_argcount, Callable::CallError &r_call_error) {
 	if (p_argcount < 2) {
 		r_call_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
@@ -1609,6 +1637,47 @@ bool ClassDB::is_class_enum_bitfield(const StringName &p_class, const StringName
 	return ::ClassDB::is_enum_bitfield(p_class, p_enum, p_no_inheritance);
 }
 
+bool ClassDB::class_has_struct(const StringName &p_class, const StringName &p_struct, bool p_no_inheritance) const {
+	return ::ClassDB::get_struct_info(p_class, p_struct, p_no_inheritance) != nullptr;
+}
+
+TypedArray<Dictionary> ClassDB::class_get_struct_list(const StringName &p_class, bool p_no_inheritance) const {
+	List<StructInfo> structs;
+	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);
+	}
+	return ret;
+}
+
+TypedArray<Dictionary> ClassDB::class_get_struct_members(const StringName &p_class, const StringName &p_struct) const {
+	// TODO: this should return an array of structs if possible without circular reference
+	TypedArray<Dictionary> ret;
+	const StructInfo *struct_info = ::ClassDB::get_struct_info(p_class, p_struct);
+	if (!struct_info) {
+		return ret; // TODO: should this be an error?
+	}
+	for (int i = 0; i < struct_info->count; i++) {
+		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("default_value")] = struct_info->default_values[i];
+		ret.push_back(dict);
+	}
+	return ret;
+}
+
 bool ClassDB::is_class_enabled(const StringName &p_class) const {
 	return ::ClassDB::is_class_enabled(p_class);
 }
@@ -1650,9 +1719,12 @@ void ClassDB::_bind_methods() {
 
 	::ClassDB::bind_method(D_METHOD("class_has_signal", "class", "signal"), &ClassDB::class_has_signal);
 	::ClassDB::bind_method(D_METHOD("class_get_signal", "class", "signal"), &ClassDB::class_get_signal);
+	//::ClassDB::bind_method(D_METHOD("class_get_signal_as_struct", "class", "signal"), &ClassDB::class_get_signal_as_struct);
 	::ClassDB::bind_method(D_METHOD("class_get_signal_list", "class", "no_inheritance"), &ClassDB::class_get_signal_list, DEFVAL(false));
+	//::ClassDB::bind_method(D_METHOD("class_get_signal_list_as_structs", "class", "no_inheritance"), &ClassDB::class_get_signal_list_as_structs, DEFVAL(false));
 
 	::ClassDB::bind_method(D_METHOD("class_get_property_list", "class", "no_inheritance"), &ClassDB::class_get_property_list, DEFVAL(false));
+	//::ClassDB::bind_method(D_METHOD("class_get_property_list_as_structs", "class", "no_inheritance"), &ClassDB::class_get_property_list_as_structs, DEFVAL(false));
 	::ClassDB::bind_method(D_METHOD("class_get_property_getter", "class", "property"), &ClassDB::class_get_property_getter);
 	::ClassDB::bind_method(D_METHOD("class_get_property_setter", "class", "property"), &ClassDB::class_get_property_setter);
 	::ClassDB::bind_method(D_METHOD("class_get_property", "object", "property"), &ClassDB::class_get_property);
@@ -1665,6 +1737,7 @@ void ClassDB::_bind_methods() {
 	::ClassDB::bind_method(D_METHOD("class_get_method_argument_count", "class", "method", "no_inheritance"), &ClassDB::class_get_method_argument_count, DEFVAL(false));
 
 	::ClassDB::bind_method(D_METHOD("class_get_method_list", "class", "no_inheritance"), &ClassDB::class_get_method_list, DEFVAL(false));
+	//::ClassDB::bind_method(D_METHOD("class_get_method_list_as_structs", "class", "no_inheritance"), &ClassDB::class_get_method_list_as_structs, DEFVAL(false));
 
 	::ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "class_call_static_method", &ClassDB::class_call_static_method, MethodInfo("class_call_static_method", PropertyInfo(Variant::STRING_NAME, "class"), PropertyInfo(Variant::STRING_NAME, "method")));
 
@@ -1680,6 +1753,10 @@ void ClassDB::_bind_methods() {
 
 	::ClassDB::bind_method(D_METHOD("is_class_enum_bitfield", "class", "enum", "no_inheritance"), &ClassDB::is_class_enum_bitfield, DEFVAL(false));
 
+	//	::ClassDB::bind_method(D_METHOD("class_has_struct", "class", "struct", "no_inheritance"), &ClassDB::class_has_struct, DEFVAL(false));
+	//	::ClassDB::bind_method(D_METHOD("class_get_struct_list", "class", "no_inheritance"), &ClassDB::class_get_struct_list, DEFVAL(false));
+	//	::ClassDB::bind_method(D_METHOD("class_get_struct_members", "class", "struct"), &ClassDB::class_get_struct_members);
+
 	::ClassDB::bind_method(D_METHOD("is_class_enabled", "class"), &ClassDB::is_class_enabled);
 
 	BIND_ENUM_CONSTANT(API_CORE);
diff --git a/core/core_bind.h b/core/core_bind.h
index ce0bde3c05b8..a21f04e3a23d 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -468,9 +468,12 @@ class ClassDB : public Object {
 	APIType class_get_api_type(const StringName &p_class) const;
 	bool class_has_signal(const StringName &p_class, const StringName &p_signal) const;
 	Dictionary class_get_signal(const StringName &p_class, const StringName &p_signal) const;
+	//Struct<MethodInfo> class_get_signal_as_struct(const StringName &p_class, const StringName &p_signal) const;
 	TypedArray<Dictionary> class_get_signal_list(const StringName &p_class, bool p_no_inheritance = false) const;
+	//TypedArray<Struct<MethodInfo>> class_get_signal_list_as_structs(const StringName &p_class, bool p_no_inheritance = false) const;
 
 	TypedArray<Dictionary> class_get_property_list(const StringName &p_class, bool p_no_inheritance = false) const;
+	//TypedArray<Struct<PropertyInfo>> class_get_property_list_as_structs(const StringName &p_class, bool p_no_inheritance = false) const;
 	StringName class_get_property_getter(const StringName &p_class, const StringName &p_property);
 	StringName class_get_property_setter(const StringName &p_class, const StringName &p_property);
 	Variant class_get_property(Object *p_object, const StringName &p_property) const;
@@ -483,6 +486,7 @@ class ClassDB : public Object {
 	int class_get_method_argument_count(const StringName &p_class, const StringName &p_method, bool p_no_inheritance = false) const;
 
 	TypedArray<Dictionary> class_get_method_list(const StringName &p_class, bool p_no_inheritance = false) const;
+	//TypedArray<Struct<MethodInfo>> class_get_method_list_as_structs(const StringName &p_class, bool p_no_inheritance = false) const;
 	Variant class_call_static_method(const Variant **p_arguments, int p_argcount, Callable::CallError &r_call_error);
 
 	PackedStringArray class_get_integer_constant_list(const StringName &p_class, bool p_no_inheritance = false) const;
@@ -498,6 +502,10 @@ class ClassDB : public Object {
 
 	bool is_class_enabled(const StringName &p_class) const;
 
+	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;
+	TypedArray<Dictionary> class_get_struct_members(const StringName &p_class, const StringName &p_struct) const;
+
 #ifdef TOOLS_ENABLED
 	virtual void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const override;
 #endif
diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp
index 9826d73a9dda..82713cd97c0a 100644
--- a/core/object/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -34,6 +34,7 @@
 #include "core/io/resource_loader.h"
 #include "core/object/script_language.h"
 #include "core/os/mutex.h"
+#include "core/variant/struct.h"
 #include "core/version.h"
 
 #define OBJTYPE_RLOCK RWLockRead _rw_lockr_(lock);
@@ -505,6 +506,8 @@ uint32_t ClassDB::get_api_hash(APIType p_api) {
 			hash = hash_murmur3_one_64(F.hint_string.hash(), hash);
 			hash = hash_murmur3_one_64(F.usage, hash);
 		}
+
+		// TODO: do I need to incorporate the structs into the hash?
 	}
 
 	hash = hash_fmix32(hash);
@@ -1317,6 +1320,67 @@ bool ClassDB::is_enum_bitfield(const StringName &p_class, const StringName &p_na
 	return false;
 }
 
+void ClassDB::bind_struct(const StringName &p_class_name, const StructInfo &p_struct_info) {
+	OBJTYPE_WLOCK;
+
+	ClassInfo *type = classes.getptr(p_class_name);
+
+	ERR_FAIL_NULL(type);
+
+	if (type->struct_map.has(p_struct_info.name)) {
+		ERR_FAIL();
+	}
+
+	String struct_name = p_struct_info.name;
+	if (struct_name.contains(".")) {
+		struct_name = struct_name.get_slicec('.', 1);
+	}
+
+	type->struct_map.insert(struct_name, p_struct_info);
+}
+
+void ClassDB::get_struct_list(const StringName &p_class, List<StructInfo> *r_structs, bool p_no_inheritance) {
+	OBJTYPE_RLOCK;
+
+	ClassInfo *type = classes.getptr(p_class);
+
+	while (type) {
+		for (const KeyValue<StringName, StructInfo> &E : type->struct_map) {
+			r_structs->push_back(E.value);
+		}
+
+		if (p_no_inheritance) {
+			break;
+		}
+
+		type = type->inherits_ptr;
+	}
+}
+
+const StructInfo *ClassDB::get_struct_info(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) {
+	OBJTYPE_RLOCK;
+
+	ClassInfo *type = classes.getptr(p_class);
+	while (type) {
+		if (const StructInfo *info = type->struct_map.getptr(p_name)) {
+			return info;
+		}
+		if (p_no_inheritance) {
+			return nullptr;
+		}
+		type = type->inherits_ptr;
+	}
+	return nullptr;
+}
+
+const StructInfo *ClassDB::get_struct_info(const String &p_qualified_name, bool p_no_inheritance) {
+	Vector<String> names = String(p_qualified_name).split("."); // TODO: what about cases other than size == 2?
+	if (names.size() == 2) {
+		return ClassDB::get_struct_info(names[0], names[1]);
+	}
+	return nullptr;
+}
+
 void ClassDB::add_signal(const StringName &p_class, const MethodInfo &p_signal) {
 	OBJTYPE_WLOCK;
 
@@ -1429,6 +1493,15 @@ void ClassDB::add_property_array(const StringName &p_class, const StringName &p_
 	type->property_list.push_back(PropertyInfo(Variant::NIL, p_path, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ARRAY, p_array_element_prefix));
 }
 
+// TODO: This probably isn't right, I just copied the function above.
+void ClassDB::add_property_struct(const StringName &p_class, const StringName &p_path, const String &p_array_element_prefix) {
+	OBJTYPE_WLOCK; // TODO: I'm not sure what this does but it's in the one above so I figure I need it
+	ClassInfo *type = classes.getptr(p_class);
+	ERR_FAIL_NULL(type);
+
+	type->property_list.push_back(PropertyInfo(Variant::NIL, p_path, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ARRAY, p_array_element_prefix));
+}
+
 // NOTE: For implementation simplicity reasons, this method doesn't allow setters to have optional arguments at the end.
 void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinfo, const StringName &p_setter, const StringName &p_getter, int p_index) {
 	lock.read_lock();
diff --git a/core/object/class_db.h b/core/object/class_db.h
index 81100d7586b8..22515125de19 100644
--- a/core/object/class_db.h
+++ b/core/object/class_db.h
@@ -114,6 +114,7 @@ class ClassDB {
 		};
 
 		HashMap<StringName, EnumInfo> enum_map;
+		HashMap<StringName, StructInfo> struct_map;
 		HashMap<StringName, MethodInfo> signal_map;
 		List<PropertyInfo> property_list;
 		HashMap<StringName, PropertyInfo> property_map;
@@ -426,6 +427,7 @@ class ClassDB {
 	static void add_property_subgroup(const StringName &p_class, const String &p_name, const String &p_prefix = "", int p_indent_depth = 0);
 	static void add_property_array_count(const StringName &p_class, const String &p_label, const StringName &p_count_property, const StringName &p_count_setter, const StringName &p_count_getter, const String &p_array_element_prefix, uint32_t p_count_usage = PROPERTY_USAGE_DEFAULT);
 	static void add_property_array(const StringName &p_class, const StringName &p_path, const String &p_array_element_prefix);
+	static void add_property_struct(const StringName &p_class, const StringName &p_path, const String &p_array_element_prefix);
 	static void add_property(const StringName &p_class, const PropertyInfo &p_pinfo, const StringName &p_setter, const StringName &p_getter, int p_index = -1);
 	static void set_property_default_value(const StringName &p_class, const StringName &p_name, const Variant &p_default);
 	static void add_linked_property(const StringName &p_class, const String &p_property, const String &p_linked_property);
@@ -467,6 +469,11 @@ class ClassDB {
 	static bool has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 	static bool is_enum_bitfield(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 
+	static void bind_struct(const StringName &p_class, const StructInfo &p_struct_info);
+	static void get_struct_list(const StringName &p_class, List<StructInfo> *r_structs, bool p_no_inheritance = false);
+	static const StructInfo *get_struct_info(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
+	static const StructInfo *get_struct_info(const String &p_qualified_name, bool p_no_inheritance = false);
+
 	static void set_method_error_return_values(const StringName &p_class, const StringName &p_method, const Vector<Error> &p_values);
 	static Vector<Error> get_method_error_return_values(const StringName &p_class, const StringName &p_method);
 	static Variant class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid = nullptr);
@@ -506,6 +513,9 @@ class ClassDB {
 #define BIND_CONSTANT(m_constant) \
 	::ClassDB::bind_integer_constant(get_class_static(), StringName(), #m_constant, m_constant);
 
+#define BIND_STRUCT(m_struct) \
+	::ClassDB::bind_struct(get_class_static(), m_struct::Layout::get_struct_info());
+
 #ifdef DEBUG_METHODS_ENABLED
 
 _FORCE_INLINE_ void errarray_add_str(Vector<Error> &arr) {
diff --git a/core/object/method_info.cpp b/core/object/method_info.cpp
new file mode 100644
index 000000000000..e79f937ea868
--- /dev/null
+++ b/core/object/method_info.cpp
@@ -0,0 +1,99 @@
+/**************************************************************************/
+/*  method_info.cpp                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "method_info.h"
+#include "core/variant/struct.h"
+#include "core/variant/typed_array.h"
+
+PropertyInfo MethodInfo::return_val::from_variant(const Variant &p_variant) {
+	return PropertyInfo(Struct<PropertyInfo>(p_variant));
+}
+
+Variant MethodInfo::return_val::to_variant(const PropertyInfo &p_value) {
+	return Struct<PropertyInfo>(p_value);
+}
+
+List<PropertyInfo> MethodInfo::arguments::from_variant(const Variant &p_variant) {
+	return (List<PropertyInfo>)TypedArray<Struct<PropertyInfo>>(p_variant);
+}
+
+Variant MethodInfo::arguments::to_variant(const List<PropertyInfo> &p_value) {
+	return TypedArray<Struct<PropertyInfo>>(&p_value);
+}
+
+MethodInfo::operator Dictionary() const {
+	Dictionary d;
+	d["name"] = name;
+	d["args"] = convert_property_list(&arguments);
+	Array da;
+	for (int i = 0; i < default_arguments.size(); i++) {
+		da.push_back(default_arguments[i]);
+	}
+	d["default_args"] = da;
+	d["flags"] = flags;
+	d["id"] = id;
+	Dictionary r = return_val;
+	d["return"] = r;
+	return d;
+}
+
+MethodInfo MethodInfo::from_dict(const Dictionary &p_dict) {
+	MethodInfo mi;
+
+	if (p_dict.has("name")) {
+		mi.name = p_dict["name"];
+	}
+	Array args;
+	if (p_dict.has("args")) {
+		args = p_dict["args"];
+	}
+
+	for (const Variant &arg : args) {
+		Dictionary d = arg;
+		mi.arguments.push_back(PropertyInfo::from_dict(d));
+	}
+	Array defargs;
+	if (p_dict.has("default_args")) {
+		defargs = p_dict["default_args"];
+	}
+	for (const Variant &defarg : defargs) {
+		mi.default_arguments.push_back(defarg);
+	}
+
+	if (p_dict.has("return")) {
+		mi.return_val = PropertyInfo::from_dict(p_dict["return"]);
+	}
+
+	if (p_dict.has("flags")) {
+		mi.flags = p_dict["flags"];
+	}
+
+	return mi;
+}
diff --git a/core/object/method_info.h b/core/object/method_info.h
new file mode 100644
index 000000000000..d2b2668d1c61
--- /dev/null
+++ b/core/object/method_info.h
@@ -0,0 +1,137 @@
+/**************************************************************************/
+/*  method_info.h                                                         */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef METHOD_INFO_H
+#define METHOD_INFO_H
+
+#include "core/object/property_info.h"
+#include "core/variant/variant.h"
+
+enum MethodFlags {
+	METHOD_FLAG_NORMAL = 1,
+	METHOD_FLAG_EDITOR = 2,
+	METHOD_FLAG_CONST = 4,
+	METHOD_FLAG_VIRTUAL = 8,
+	METHOD_FLAG_VARARG = 16,
+	METHOD_FLAG_STATIC = 32,
+	METHOD_FLAG_OBJECT_CORE = 64,
+	METHOD_FLAG_VIRTUAL_REQUIRED = 128,
+	METHOD_FLAGS_DEFAULT = METHOD_FLAG_NORMAL,
+};
+
+struct MethodInfo {
+	STRUCT_DECLARE(MethodInfo);
+	STRUCT_MEMBER_PRIMITIVE(String, name, String());
+	STRUCT_MEMBER_PRIMITIVE_FROM_TO_ALIAS(List<PropertyInfo>, arguments, "args", List<PropertyInfo>());
+	STRUCT_MEMBER_PRIMITIVE_ALIAS(Vector<Variant>, default_arguments, "default_args", Vector<Variant>());
+	STRUCT_MEMBER_PRIMITIVE(uint32_t, flags, METHOD_FLAGS_DEFAULT);
+	STRUCT_MEMBER_PRIMITIVE(int, id, 0);
+	STRUCT_MEMBER_STRUCT_FROM_TO_ALIAS(PropertyInfo, return_val, "return", PropertyInfo());
+
+	STRUCT_MEMBER_PRIMITIVE(int, return_val_metadata, 0);
+	STRUCT_MEMBER_PRIMITIVE(Vector<int>, arguments_metadata, Vector<int>());
+	STRUCT_LAYOUT_OWNER(Object, MethodInfo, struct name, struct arguments, struct default_arguments, struct flags, struct id, struct return_val, struct return_val_metadata, struct arguments_metadata);
+
+	int get_argument_meta(int p_arg) const {
+		ERR_FAIL_COND_V(p_arg < -1 || p_arg > arguments.size(), 0);
+		if (p_arg == -1) {
+			return return_val_metadata;
+		}
+		return arguments_metadata.size() > p_arg ? arguments_metadata[p_arg] : 0;
+	}
+
+	inline bool operator==(const MethodInfo &p_method) const { return id == p_method.id; }
+	inline bool operator<(const MethodInfo &p_method) const { return id == p_method.id ? (name < p_method.name) : (id < p_method.id); }
+
+	operator Dictionary() const;
+
+	static MethodInfo from_dict(const Dictionary &p_dict);
+
+	MethodInfo() {}
+
+	explicit MethodInfo(const GDExtensionMethodInfo &pinfo) :
+			name(*reinterpret_cast<StringName *>(pinfo.name)) {
+		for (uint32_t j = 0; j < pinfo.argument_count; j++) {
+			arguments.push_back(PropertyInfo(pinfo.arguments[j]));
+		}
+		const Variant *def_values = (const Variant *)pinfo.default_arguments;
+		for (uint32_t j = 0; j < pinfo.default_argument_count; j++) {
+			default_arguments.push_back(def_values[j]);
+		}
+		flags = pinfo.flags;
+		id = pinfo.id;
+		return_val = PropertyInfo(pinfo.return_value);
+	}
+
+	void _push_params(const PropertyInfo &p_param) {
+		arguments.push_back(p_param);
+	}
+
+	template <typename... VarArgs>
+	void _push_params(const PropertyInfo &p_param, VarArgs... p_params) {
+		arguments.push_back(p_param);
+		_push_params(p_params...);
+	}
+
+	MethodInfo(const String &p_name) { name = p_name; }
+
+	template <typename... VarArgs>
+	MethodInfo(const String &p_name, VarArgs... p_params) {
+		name = p_name;
+		_push_params(p_params...);
+	}
+
+	MethodInfo(Variant::Type ret) { return_val.type = ret; }
+	MethodInfo(Variant::Type ret, const String &p_name) {
+		return_val.type = ret;
+		name = p_name;
+	}
+
+	template <typename... VarArgs>
+	MethodInfo(Variant::Type ret, const String &p_name, VarArgs... p_params) {
+		name = p_name;
+		return_val.type = ret;
+		_push_params(p_params...);
+	}
+
+	MethodInfo(const PropertyInfo &p_ret, const String &p_name) {
+		return_val = p_ret;
+		name = p_name;
+	}
+
+	template <typename... VarArgs>
+	MethodInfo(const PropertyInfo &p_ret, const String &p_name, VarArgs... p_params) {
+		return_val = p_ret;
+		name = p_name;
+		_push_params(p_params...);
+	}
+};
+
+#endif // METHOD_INFO_H
diff --git a/core/object/object.cpp b/core/object/object.cpp
index b3a4ec6e2ed6..63231daa241e 100644
--- a/core/object/object.cpp
+++ b/core/object/object.cpp
@@ -39,6 +39,7 @@
 #include "core/string/print_string.h"
 #include "core/string/translation_server.h"
 #include "core/templates/local_vector.h"
+#include "core/variant/struct.h"
 #include "core/variant/typed_array.h"
 
 #ifdef DEBUG_ENABLED
@@ -66,106 +67,6 @@ struct _ObjectDebugLock {
 
 #endif
 
-PropertyInfo::operator Dictionary() const {
-	Dictionary d;
-	d["name"] = name;
-	d["class_name"] = class_name;
-	d["type"] = type;
-	d["hint"] = hint;
-	d["hint_string"] = hint_string;
-	d["usage"] = usage;
-	return d;
-}
-
-PropertyInfo PropertyInfo::from_dict(const Dictionary &p_dict) {
-	PropertyInfo pi;
-
-	if (p_dict.has("type")) {
-		pi.type = Variant::Type(int(p_dict["type"]));
-	}
-
-	if (p_dict.has("name")) {
-		pi.name = p_dict["name"];
-	}
-
-	if (p_dict.has("class_name")) {
-		pi.class_name = p_dict["class_name"];
-	}
-
-	if (p_dict.has("hint")) {
-		pi.hint = PropertyHint(int(p_dict["hint"]));
-	}
-
-	if (p_dict.has("hint_string")) {
-		pi.hint_string = p_dict["hint_string"];
-	}
-
-	if (p_dict.has("usage")) {
-		pi.usage = p_dict["usage"];
-	}
-
-	return pi;
-}
-
-TypedArray<Dictionary> convert_property_list(const List<PropertyInfo> *p_list) {
-	TypedArray<Dictionary> va;
-	for (const List<PropertyInfo>::Element *E = p_list->front(); E; E = E->next()) {
-		va.push_back(Dictionary(E->get()));
-	}
-
-	return va;
-}
-
-MethodInfo::operator Dictionary() const {
-	Dictionary d;
-	d["name"] = name;
-	d["args"] = convert_property_list(&arguments);
-	Array da;
-	for (int i = 0; i < default_arguments.size(); i++) {
-		da.push_back(default_arguments[i]);
-	}
-	d["default_args"] = da;
-	d["flags"] = flags;
-	d["id"] = id;
-	Dictionary r = return_val;
-	d["return"] = r;
-	return d;
-}
-
-MethodInfo MethodInfo::from_dict(const Dictionary &p_dict) {
-	MethodInfo mi;
-
-	if (p_dict.has("name")) {
-		mi.name = p_dict["name"];
-	}
-	Array args;
-	if (p_dict.has("args")) {
-		args = p_dict["args"];
-	}
-
-	for (const Variant &arg : args) {
-		Dictionary d = arg;
-		mi.arguments.push_back(PropertyInfo::from_dict(d));
-	}
-	Array defargs;
-	if (p_dict.has("default_args")) {
-		defargs = p_dict["default_args"];
-	}
-	for (const Variant &defarg : defargs) {
-		mi.default_arguments.push_back(defarg);
-	}
-
-	if (p_dict.has("return")) {
-		mi.return_val = PropertyInfo::from_dict(p_dict["return"]);
-	}
-
-	if (p_dict.has("flags")) {
-		mi.flags = p_dict["flags"];
-	}
-
-	return mi;
-}
-
 Object::Connection::operator Variant() const {
 	Dictionary d;
 	d["signal"] = signal;
@@ -1039,6 +940,12 @@ TypedArray<Dictionary> Object::_get_property_list_bind() const {
 	return convert_property_list(&lpi);
 }
 
+//TypedArray<Struct<PropertyInfo>> Object::_get_property_list_as_structs_bind() const {
+//	List<PropertyInfo> lpi;
+//	get_property_list(&lpi);
+//	return TypedArray<Struct<PropertyInfo>>(&lpi);
+//}
+
 TypedArray<Dictionary> Object::_get_method_list_bind() const {
 	List<MethodInfo> ml;
 	get_method_list(&ml);
@@ -1053,6 +960,12 @@ TypedArray<Dictionary> Object::_get_method_list_bind() const {
 	return ret;
 }
 
+//TypedArray<Struct<MethodInfo>> Object::_get_method_list_as_structs_bind() const {
+//	List<MethodInfo> ml;
+//	get_method_list(&ml);
+//	return TypedArray<Struct<MethodInfo>>(&ml);
+//}
+
 TypedArray<StringName> Object::_get_meta_list_bind() const {
 	TypedArray<StringName> _metaret;
 
@@ -1253,6 +1166,10 @@ void Object::_add_user_signal(const String &p_name, const Array &p_args) {
 	}
 }
 
+//void Object::_add_user_signal_as_struct(const Struct<MethodInfo> &p_signal) {
+//	add_user_signal(MethodInfo(p_signal));
+//}
+
 TypedArray<Dictionary> Object::_get_signal_list() const {
 	List<MethodInfo> signal_list;
 	get_signal_list(&signal_list);
@@ -1265,6 +1182,12 @@ TypedArray<Dictionary> Object::_get_signal_list() const {
 	return ret;
 }
 
+//TypedArray<Struct<MethodInfo>> Object::_get_signal_list_as_structs() const {
+//	List<MethodInfo> signal_list;
+//	get_signal_list(&signal_list);
+//	return TypedArray<Struct<MethodInfo>>(&signal_list);
+//}
+
 TypedArray<Dictionary> Object::_get_signal_connection_list(const StringName &p_signal) const {
 	List<Connection> conns;
 	get_all_signal_connections(&conns);
@@ -1280,6 +1203,12 @@ TypedArray<Dictionary> Object::_get_signal_connection_list(const StringName &p_s
 	return ret;
 }
 
+//TypedArray<Struct<Object::Connection>> Object::_get_signal_connection_list_as_structs(const StringName &p_signal) const {
+//	List<Connection> conns;
+//	get_all_signal_connections(&conns);
+//	return TypedArray<Struct<Connection>>(&conns);
+//}
+
 TypedArray<Dictionary> Object::_get_incoming_connections() const {
 	TypedArray<Dictionary> ret;
 	for (const Object::Connection &connection : connections) {
@@ -1289,6 +1218,10 @@ TypedArray<Dictionary> Object::_get_incoming_connections() const {
 	return ret;
 }
 
+//TypedArray<Struct<Object::Connection>> Object::_get_incoming_connections_as_structs() const {
+//	return TypedArray<Struct<Connection>>(&connections);
+//}
+
 bool Object::has_signal(const StringName &p_name) const {
 	if (!script.is_null()) {
 		Ref<Script> scr = script;
@@ -1655,7 +1588,9 @@ void Object::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_indexed", "property_path", "value"), &Object::_set_indexed_bind);
 	ClassDB::bind_method(D_METHOD("get_indexed", "property_path"), &Object::_get_indexed_bind);
 	ClassDB::bind_method(D_METHOD("get_property_list"), &Object::_get_property_list_bind);
+	//ClassDB::bind_method(D_METHOD("get_property_list_as_structs"), &Object::_get_property_list_as_structs_bind);
 	ClassDB::bind_method(D_METHOD("get_method_list"), &Object::_get_method_list_bind);
+	//ClassDB::bind_method(D_METHOD("get_method_list_as_structs"), &Object::_get_method_list_as_structs_bind);
 	ClassDB::bind_method(D_METHOD("property_can_revert", "property"), &Object::property_can_revert);
 	ClassDB::bind_method(D_METHOD("property_get_revert", "property"), &Object::property_get_revert);
 	ClassDB::bind_method(D_METHOD("notification", "what", "reversed"), &Object::notification, DEFVAL(false));
@@ -1672,6 +1607,7 @@ void Object::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_meta_list"), &Object::_get_meta_list_bind);
 
 	ClassDB::bind_method(D_METHOD("add_user_signal", "signal", "arguments"), &Object::_add_user_signal, DEFVAL(Array()));
+	//ClassDB::bind_method(D_METHOD("add_user_signal_as_struct", "signal"), &Object::_add_user_signal_as_struct);
 	ClassDB::bind_method(D_METHOD("has_user_signal", "signal"), &Object::_has_user_signal);
 	ClassDB::bind_method(D_METHOD("remove_user_signal", "signal"), &Object::_remove_user_signal);
 
@@ -1709,8 +1645,11 @@ void Object::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("has_signal", "signal"), &Object::has_signal);
 	ClassDB::bind_method(D_METHOD("get_signal_list"), &Object::_get_signal_list);
+	//ClassDB::bind_method(D_METHOD("get_signal_list_as_structs"), &Object::_get_signal_list_as_structs);
 	ClassDB::bind_method(D_METHOD("get_signal_connection_list", "signal"), &Object::_get_signal_connection_list);
+	//ClassDB::bind_method(D_METHOD("get_signal_connection_list_as_structs", "signal"), &Object::_get_signal_connection_list_as_structs);
 	ClassDB::bind_method(D_METHOD("get_incoming_connections"), &Object::_get_incoming_connections);
+	//ClassDB::bind_method(D_METHOD("get_incoming_connections_as_structs"), &Object::_get_incoming_connections_as_structs);
 
 	ClassDB::bind_method(D_METHOD("connect", "signal", "callable", "flags"), &Object::connect, DEFVAL(0));
 	ClassDB::bind_method(D_METHOD("disconnect", "signal", "callable"), &Object::disconnect);
@@ -1807,6 +1746,10 @@ void Object::_bind_methods() {
 	BIND_ENUM_CONSTANT(CONNECT_PERSIST);
 	BIND_ENUM_CONSTANT(CONNECT_ONE_SHOT);
 	BIND_ENUM_CONSTANT(CONNECT_REFERENCE_COUNTED);
+
+	BIND_STRUCT(PropertyInfo);
+	BIND_STRUCT(MethodInfo);
+	BIND_STRUCT(Connection);
 }
 
 void Object::set_deferred(const StringName &p_property, const Variant &p_value) {
diff --git a/core/object/object.h b/core/object/object.h
index 110d2790c58e..a215c8e88bdc 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -33,7 +33,9 @@
 
 #include "core/extension/gdextension_interface.h"
 #include "core/object/message_queue.h"
+#include "core/object/method_info.h"
 #include "core/object/object_id.h"
+#include "core/object/property_info.h"
 #include "core/os/rw_lock.h"
 #include "core/os/spin_lock.h"
 #include "core/templates/hash_map.h"
@@ -42,90 +44,14 @@
 #include "core/templates/rb_map.h"
 #include "core/templates/safe_refcount.h"
 #include "core/variant/callable_bind.h"
+#include "core/variant/struct_generator.h"
 #include "core/variant/variant.h"
 
 template <typename T>
 class TypedArray;
 
-enum PropertyHint {
-	PROPERTY_HINT_NONE, ///< no hint provided.
-	PROPERTY_HINT_RANGE, ///< hint_text = "min,max[,step][,or_greater][,or_less][,hide_slider][,radians_as_degrees][,degrees][,exp][,suffix:<keyword>] range.
-	PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc"
-	PROPERTY_HINT_ENUM_SUGGESTION, ///< hint_text= "val1,val2,val3,etc"
-	PROPERTY_HINT_EXP_EASING, /// exponential easing function (Math::ease) use "attenuation" hint string to revert (flip h), "positive_only" to exclude in-out and out-in. (ie: "attenuation,positive_only")
-	PROPERTY_HINT_LINK,
-	PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags)
-	PROPERTY_HINT_LAYERS_2D_RENDER,
-	PROPERTY_HINT_LAYERS_2D_PHYSICS,
-	PROPERTY_HINT_LAYERS_2D_NAVIGATION,
-	PROPERTY_HINT_LAYERS_3D_RENDER,
-	PROPERTY_HINT_LAYERS_3D_PHYSICS,
-	PROPERTY_HINT_LAYERS_3D_NAVIGATION,
-	PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
-	PROPERTY_HINT_DIR, ///< a directory path must be passed
-	PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
-	PROPERTY_HINT_GLOBAL_DIR, ///< a directory path must be passed
-	PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type
-	PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines
-	PROPERTY_HINT_EXPRESSION, ///< used for string properties that can contain multiple lines
-	PROPERTY_HINT_PLACEHOLDER_TEXT, ///< used to set a placeholder text for string properties
-	PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color
-	PROPERTY_HINT_OBJECT_ID,
-	PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose
-	PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, // Deprecated.
-	PROPERTY_HINT_OBJECT_TOO_BIG, ///< object is too big to send
-	PROPERTY_HINT_NODE_PATH_VALID_TYPES,
-	PROPERTY_HINT_SAVE_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,". This opens a save dialog
-	PROPERTY_HINT_GLOBAL_SAVE_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,". This opens a save dialog
-	PROPERTY_HINT_INT_IS_OBJECTID, // Deprecated.
-	PROPERTY_HINT_INT_IS_POINTER,
-	PROPERTY_HINT_ARRAY_TYPE,
-	PROPERTY_HINT_LOCALE_ID,
-	PROPERTY_HINT_LOCALIZABLE_STRING,
-	PROPERTY_HINT_NODE_TYPE, ///< a node object type
-	PROPERTY_HINT_HIDE_QUATERNION_EDIT, /// Only Node3D::transform should hide the quaternion editor.
-	PROPERTY_HINT_PASSWORD,
-	PROPERTY_HINT_LAYERS_AVOIDANCE,
-	PROPERTY_HINT_DICTIONARY_TYPE,
-	PROPERTY_HINT_TOOL_BUTTON,
-	PROPERTY_HINT_MAX,
-};
-
-enum PropertyUsageFlags {
-	PROPERTY_USAGE_NONE = 0,
-	PROPERTY_USAGE_STORAGE = 1 << 1,
-	PROPERTY_USAGE_EDITOR = 1 << 2,
-	PROPERTY_USAGE_INTERNAL = 1 << 3,
-	PROPERTY_USAGE_CHECKABLE = 1 << 4, // Used for editing global variables.
-	PROPERTY_USAGE_CHECKED = 1 << 5, // Used for editing global variables.
-	PROPERTY_USAGE_GROUP = 1 << 6, // Used for grouping props in the editor.
-	PROPERTY_USAGE_CATEGORY = 1 << 7,
-	PROPERTY_USAGE_SUBGROUP = 1 << 8,
-	PROPERTY_USAGE_CLASS_IS_BITFIELD = 1 << 9,
-	PROPERTY_USAGE_NO_INSTANCE_STATE = 1 << 10,
-	PROPERTY_USAGE_RESTART_IF_CHANGED = 1 << 11,
-	PROPERTY_USAGE_SCRIPT_VARIABLE = 1 << 12,
-	PROPERTY_USAGE_STORE_IF_NULL = 1 << 13,
-	PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 1 << 14,
-	PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE = 1 << 15, // Deprecated.
-	PROPERTY_USAGE_CLASS_IS_ENUM = 1 << 16,
-	PROPERTY_USAGE_NIL_IS_VARIANT = 1 << 17,
-	PROPERTY_USAGE_ARRAY = 1 << 18, // Used in the inspector to group properties as elements of an array.
-	PROPERTY_USAGE_ALWAYS_DUPLICATE = 1 << 19, // When duplicating a resource, always duplicate, even with subresource duplication disabled.
-	PROPERTY_USAGE_NEVER_DUPLICATE = 1 << 20, // When duplicating a resource, never duplicate, even with subresource duplication enabled.
-	PROPERTY_USAGE_HIGH_END_GFX = 1 << 21,
-	PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT = 1 << 22,
-	PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT = 1 << 23,
-	PROPERTY_USAGE_KEYING_INCREMENTS = 1 << 24, // Used in inspector to increment property when keyed in animation player.
-	PROPERTY_USAGE_DEFERRED_SET_RESOURCE = 1 << 25, // Deprecated.
-	PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT = 1 << 26, // For Object properties, instantiate them when creating in editor.
-	PROPERTY_USAGE_EDITOR_BASIC_SETTING = 1 << 27, //for project or editor settings, show when basic settings are selected.
-	PROPERTY_USAGE_READ_ONLY = 1 << 28, // Mark a property as read-only in the inspector.
-	PROPERTY_USAGE_SECRET = 1 << 29, // Export preset credentials that should be stored separately from the rest of the export config.
-
-	PROPERTY_USAGE_DEFAULT = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR,
-	PROPERTY_USAGE_NO_EDITOR = PROPERTY_USAGE_STORAGE,
-};
+template <typename T>
+class Struct;
 
 #define ADD_SIGNAL(m_signal) ::ClassDB::add_signal(get_class_static(), m_signal)
 #define ADD_PROPERTY(m_property, m_setter, m_getter) ::ClassDB::add_property(get_class_static(), m_property, _scs_create(m_setter), _scs_create(m_getter))
@@ -140,171 +66,13 @@ enum PropertyUsageFlags {
 #define ADD_ARRAY_COUNT(m_label, m_count_property, m_count_property_setter, m_count_property_getter, m_prefix) ClassDB::add_property_array_count(get_class_static(), m_label, m_count_property, _scs_create(m_count_property_setter), _scs_create(m_count_property_getter), m_prefix)
 #define ADD_ARRAY_COUNT_WITH_USAGE_FLAGS(m_label, m_count_property, m_count_property_setter, m_count_property_getter, m_prefix, m_property_usage_flags) ClassDB::add_property_array_count(get_class_static(), m_label, m_count_property, _scs_create(m_count_property_setter), _scs_create(m_count_property_getter), m_prefix, m_property_usage_flags)
 #define ADD_ARRAY(m_array_path, m_prefix) ClassDB::add_property_array(get_class_static(), m_array_path, m_prefix)
+// TODO: This probably doesn't work yet as is.
+#define ADD_STRUCT(m_array_path, m_prefix) ClassDB::add_property_struct(get_class_static(), m_array_path, m_prefix)
 
 // Helper macro to use with PROPERTY_HINT_ARRAY_TYPE for arrays of specific resources:
 // PropertyInfo(Variant::ARRAY, "fallbacks", PROPERTY_HINT_ARRAY_TYPE, MAKE_RESOURCE_TYPE_HINT("Font")
 #define MAKE_RESOURCE_TYPE_HINT(m_type) vformat("%s/%s:%s", Variant::OBJECT, PROPERTY_HINT_RESOURCE_TYPE, m_type)
 
-struct PropertyInfo {
-	Variant::Type type = Variant::NIL;
-	String name;
-	StringName class_name; // For classes
-	PropertyHint hint = PROPERTY_HINT_NONE;
-	String hint_string;
-	uint32_t usage = PROPERTY_USAGE_DEFAULT;
-
-	// If you are thinking about adding another member to this class, ask the maintainer (Juan) first.
-
-	_FORCE_INLINE_ PropertyInfo added_usage(uint32_t p_fl) const {
-		PropertyInfo pi = *this;
-		pi.usage |= p_fl;
-		return pi;
-	}
-
-	operator Dictionary() const;
-
-	static PropertyInfo from_dict(const Dictionary &p_dict);
-
-	PropertyInfo() {}
-
-	PropertyInfo(const Variant::Type p_type, const String &p_name, const PropertyHint p_hint = PROPERTY_HINT_NONE, const String &p_hint_string = "", const uint32_t p_usage = PROPERTY_USAGE_DEFAULT, const StringName &p_class_name = StringName()) :
-			type(p_type),
-			name(p_name),
-			hint(p_hint),
-			hint_string(p_hint_string),
-			usage(p_usage) {
-		if (hint == PROPERTY_HINT_RESOURCE_TYPE) {
-			class_name = hint_string;
-		} else {
-			class_name = p_class_name;
-		}
-	}
-
-	PropertyInfo(const StringName &p_class_name) :
-			type(Variant::OBJECT),
-			class_name(p_class_name) {}
-
-	explicit PropertyInfo(const GDExtensionPropertyInfo &pinfo) :
-			type((Variant::Type)pinfo.type),
-			name(*reinterpret_cast<StringName *>(pinfo.name)),
-			class_name(*reinterpret_cast<StringName *>(pinfo.class_name)),
-			hint((PropertyHint)pinfo.hint),
-			hint_string(*reinterpret_cast<String *>(pinfo.hint_string)),
-			usage(pinfo.usage) {}
-
-	bool operator==(const PropertyInfo &p_info) const {
-		return ((type == p_info.type) &&
-				(name == p_info.name) &&
-				(class_name == p_info.class_name) &&
-				(hint == p_info.hint) &&
-				(hint_string == p_info.hint_string) &&
-				(usage == p_info.usage));
-	}
-
-	bool operator<(const PropertyInfo &p_info) const {
-		return name < p_info.name;
-	}
-};
-
-TypedArray<Dictionary> convert_property_list(const List<PropertyInfo> *p_list);
-
-enum MethodFlags {
-	METHOD_FLAG_NORMAL = 1,
-	METHOD_FLAG_EDITOR = 2,
-	METHOD_FLAG_CONST = 4,
-	METHOD_FLAG_VIRTUAL = 8,
-	METHOD_FLAG_VARARG = 16,
-	METHOD_FLAG_STATIC = 32,
-	METHOD_FLAG_OBJECT_CORE = 64,
-	METHOD_FLAG_VIRTUAL_REQUIRED = 128,
-	METHOD_FLAGS_DEFAULT = METHOD_FLAG_NORMAL,
-};
-
-struct MethodInfo {
-	String name;
-	PropertyInfo return_val;
-	uint32_t flags = METHOD_FLAGS_DEFAULT;
-	int id = 0;
-	List<PropertyInfo> arguments;
-	Vector<Variant> default_arguments;
-	int return_val_metadata = 0;
-	Vector<int> arguments_metadata;
-
-	int get_argument_meta(int p_arg) const {
-		ERR_FAIL_COND_V(p_arg < -1 || p_arg > arguments.size(), 0);
-		if (p_arg == -1) {
-			return return_val_metadata;
-		}
-		return arguments_metadata.size() > p_arg ? arguments_metadata[p_arg] : 0;
-	}
-
-	inline bool operator==(const MethodInfo &p_method) const { return id == p_method.id && name == p_method.name; }
-	inline bool operator<(const MethodInfo &p_method) const { return id == p_method.id ? (name < p_method.name) : (id < p_method.id); }
-
-	operator Dictionary() const;
-
-	static MethodInfo from_dict(const Dictionary &p_dict);
-
-	MethodInfo() {}
-
-	explicit MethodInfo(const GDExtensionMethodInfo &pinfo) :
-			name(*reinterpret_cast<StringName *>(pinfo.name)),
-			return_val(PropertyInfo(pinfo.return_value)),
-			flags(pinfo.flags),
-			id(pinfo.id) {
-		for (uint32_t j = 0; j < pinfo.argument_count; j++) {
-			arguments.push_back(PropertyInfo(pinfo.arguments[j]));
-		}
-		const Variant *def_values = (const Variant *)pinfo.default_arguments;
-		for (uint32_t j = 0; j < pinfo.default_argument_count; j++) {
-			default_arguments.push_back(def_values[j]);
-		}
-	}
-
-	void _push_params(const PropertyInfo &p_param) {
-		arguments.push_back(p_param);
-	}
-
-	template <typename... VarArgs>
-	void _push_params(const PropertyInfo &p_param, VarArgs... p_params) {
-		arguments.push_back(p_param);
-		_push_params(p_params...);
-	}
-
-	MethodInfo(const String &p_name) { name = p_name; }
-
-	template <typename... VarArgs>
-	MethodInfo(const String &p_name, VarArgs... p_params) {
-		name = p_name;
-		_push_params(p_params...);
-	}
-
-	MethodInfo(Variant::Type ret) { return_val.type = ret; }
-	MethodInfo(Variant::Type ret, const String &p_name) {
-		return_val.type = ret;
-		name = p_name;
-	}
-
-	template <typename... VarArgs>
-	MethodInfo(Variant::Type ret, const String &p_name, VarArgs... p_params) {
-		name = p_name;
-		return_val.type = ret;
-		_push_params(p_params...);
-	}
-
-	MethodInfo(const PropertyInfo &p_ret, const String &p_name) {
-		return_val = p_ret;
-		name = p_name;
-	}
-
-	template <typename... VarArgs>
-	MethodInfo(const PropertyInfo &p_ret, const String &p_name, VarArgs... p_params) {
-		return_val = p_ret;
-		name = p_name;
-		_push_params(p_params...);
-	}
-};
-
 // API used to extend in GDExtension and other C compatible compiled languages.
 class MethodBind;
 class GDExtension;
@@ -575,10 +343,12 @@ class Object {
 	};
 
 	struct Connection {
-		::Signal signal;
-		Callable callable;
+		STRUCT_DECLARE(Connection);
+		STRUCT_MEMBER_PRIMITIVE(::Signal, signal, ::Signal());
+		STRUCT_MEMBER_PRIMITIVE(Callable, callable, Callable());
+		STRUCT_MEMBER_PRIMITIVE(uint32_t, flags, 0);
+		STRUCT_LAYOUT_OWNER(Object, Connection, struct signal, struct callable, struct flags);
 
-		uint32_t flags = 0;
 		bool operator<(const Connection &p_conn) const;
 
 		operator Variant() const;
@@ -634,12 +404,16 @@ class Object {
 	mutable const StringName *_class_name_ptr = nullptr;
 
 	void _add_user_signal(const String &p_name, const Array &p_args = Array());
+	//void _add_user_signal_as_struct(const Struct<MethodInfo> &p_signal);
 	bool _has_user_signal(const StringName &p_name) const;
 	void _remove_user_signal(const StringName &p_name);
 	Error _emit_signal(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
 	TypedArray<Dictionary> _get_signal_list() const;
 	TypedArray<Dictionary> _get_signal_connection_list(const StringName &p_signal) const;
 	TypedArray<Dictionary> _get_incoming_connections() const;
+	//TypedArray<Struct<MethodInfo>> _get_signal_list_as_structs() const;
+	//TypedArray<Struct<Connection>> _get_signal_connection_list_as_structs(const StringName &p_signal) const;
+	//TypedArray<Struct<Connection>> _get_incoming_connections_as_structs() const;
 	void _set_bind(const StringName &p_set, const Variant &p_value);
 	Variant _get_bind(const StringName &p_name) const;
 	void _set_indexed_bind(const NodePath &p_name, const Variant &p_value);
@@ -746,7 +520,9 @@ class Object {
 
 	TypedArray<StringName> _get_meta_list_bind() const;
 	TypedArray<Dictionary> _get_property_list_bind() const;
+	//TypedArray<Struct<PropertyInfo>> _get_property_list_as_structs_bind() const;
 	TypedArray<Dictionary> _get_method_list_bind() const;
+	//TypedArray<Struct<MethodInfo>> _get_method_list_as_structs_bind() const;
 
 	void _clear_internal_resource_paths(const Variant &p_var);
 
diff --git a/core/object/property_info.cpp b/core/object/property_info.cpp
new file mode 100644
index 000000000000..5a29da897773
--- /dev/null
+++ b/core/object/property_info.cpp
@@ -0,0 +1,90 @@
+/**************************************************************************/
+/*  property_info.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "property_info.h"
+#include "core/variant/typed_array.h"
+
+Variant::Type PropertyInfo::type::from_variant(const Variant &p_variant) {
+	return (Variant::Type)(int)p_variant;
+}
+
+PropertyHint PropertyInfo::hint::from_variant(const Variant &p_variant) {
+	return (PropertyHint)(int)p_variant;
+}
+
+PropertyInfo::operator Dictionary() const {
+	Dictionary d;
+	d["name"] = name;
+	d["class_name"] = class_name;
+	d["type"] = type;
+	d["hint"] = hint;
+	d["hint_string"] = hint_string;
+	d["usage"] = usage;
+	return d;
+}
+
+PropertyInfo PropertyInfo::from_dict(const Dictionary &p_dict) {
+	PropertyInfo pi;
+
+	if (p_dict.has("type")) {
+		pi.type = Variant::Type(int(p_dict["type"]));
+	}
+
+	if (p_dict.has("name")) {
+		pi.name = p_dict["name"];
+	}
+
+	if (p_dict.has("class_name")) {
+		pi.class_name = p_dict["class_name"];
+	}
+
+	if (p_dict.has("hint")) {
+		pi.hint = PropertyHint(int(p_dict["hint"]));
+	}
+
+	if (p_dict.has("hint_string")) {
+		pi.hint_string = p_dict["hint_string"];
+	}
+
+	if (p_dict.has("usage")) {
+		pi.usage = p_dict["usage"];
+	}
+
+	return pi;
+}
+
+TypedArray<Dictionary> convert_property_list(const List<PropertyInfo> *p_list) {
+	TypedArray<Dictionary> va;
+	for (const List<PropertyInfo>::Element *E = p_list->front(); E; E = E->next()) {
+		va.push_back(Dictionary(E->get()));
+	}
+
+	return va;
+}
diff --git a/core/object/property_info.h b/core/object/property_info.h
new file mode 100644
index 000000000000..a6c014673fdb
--- /dev/null
+++ b/core/object/property_info.h
@@ -0,0 +1,176 @@
+/**************************************************************************/
+/*  property_info.h                                                       */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef PROPERTY_INFO_H
+#define PROPERTY_INFO_H
+
+#include "core/extension/gdextension_interface.h"
+#include "core/variant/struct_generator.h"
+#include "core/variant/variant.h"
+
+enum PropertyHint {
+	PROPERTY_HINT_NONE, ///< no hint provided.
+	PROPERTY_HINT_RANGE, ///< hint_text = "min,max[,step][,or_greater][,or_less][,hide_slider][,radians_as_degrees][,degrees][,exp][,suffix:<keyword>] range.
+	PROPERTY_HINT_ENUM, ///< hint_text= "val1,val2,val3,etc"
+	PROPERTY_HINT_ENUM_SUGGESTION, ///< hint_text= "val1,val2,val3,etc"
+	PROPERTY_HINT_EXP_EASING, /// exponential easing function (Math::ease) use "attenuation" hint string to revert (flip h), "positive_only" to exclude in-out and out-in. (ie: "attenuation,positive_only")
+	PROPERTY_HINT_LINK,
+	PROPERTY_HINT_FLAGS, ///< hint_text= "flag1,flag2,etc" (as bit flags)
+	PROPERTY_HINT_LAYERS_2D_RENDER,
+	PROPERTY_HINT_LAYERS_2D_PHYSICS,
+	PROPERTY_HINT_LAYERS_2D_NAVIGATION,
+	PROPERTY_HINT_LAYERS_3D_RENDER,
+	PROPERTY_HINT_LAYERS_3D_PHYSICS,
+	PROPERTY_HINT_LAYERS_3D_NAVIGATION,
+	PROPERTY_HINT_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	PROPERTY_HINT_DIR, ///< a directory path must be passed
+	PROPERTY_HINT_GLOBAL_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+	PROPERTY_HINT_GLOBAL_DIR, ///< a directory path must be passed
+	PROPERTY_HINT_RESOURCE_TYPE, ///< a resource object type
+	PROPERTY_HINT_MULTILINE_TEXT, ///< used for string properties that can contain multiple lines
+	PROPERTY_HINT_EXPRESSION, ///< used for string properties that can contain multiple lines
+	PROPERTY_HINT_PLACEHOLDER_TEXT, ///< used to set a placeholder text for string properties
+	PROPERTY_HINT_COLOR_NO_ALPHA, ///< used for ignoring alpha component when editing a color
+	PROPERTY_HINT_OBJECT_ID,
+	PROPERTY_HINT_TYPE_STRING, ///< a type string, the hint is the base type to choose
+	PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE, // Deprecated.
+	PROPERTY_HINT_OBJECT_TOO_BIG, ///< object is too big to send
+	PROPERTY_HINT_NODE_PATH_VALID_TYPES,
+	PROPERTY_HINT_SAVE_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,". This opens a save dialog
+	PROPERTY_HINT_GLOBAL_SAVE_FILE, ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,". This opens a save dialog
+	PROPERTY_HINT_INT_IS_OBJECTID, // Deprecated.
+	PROPERTY_HINT_INT_IS_POINTER,
+	PROPERTY_HINT_ARRAY_TYPE,
+	PROPERTY_HINT_LOCALE_ID,
+	PROPERTY_HINT_LOCALIZABLE_STRING,
+	PROPERTY_HINT_NODE_TYPE, ///< a node object type
+	PROPERTY_HINT_HIDE_QUATERNION_EDIT, /// Only Node3D::transform should hide the quaternion editor.
+	PROPERTY_HINT_PASSWORD,
+	PROPERTY_HINT_LAYERS_AVOIDANCE,
+	PROPERTY_HINT_DICTIONARY_TYPE,
+	PROPERTY_HINT_TOOL_BUTTON,
+	PROPERTY_HINT_MAX,
+};
+
+enum PropertyUsageFlags {
+	PROPERTY_USAGE_NONE = 0,
+	PROPERTY_USAGE_STORAGE = 1 << 1,
+	PROPERTY_USAGE_EDITOR = 1 << 2,
+	PROPERTY_USAGE_INTERNAL = 1 << 3,
+	PROPERTY_USAGE_CHECKABLE = 1 << 4, // Used for editing global variables.
+	PROPERTY_USAGE_CHECKED = 1 << 5, // Used for editing global variables.
+	PROPERTY_USAGE_GROUP = 1 << 6, // Used for grouping props in the editor.
+	PROPERTY_USAGE_CATEGORY = 1 << 7,
+	PROPERTY_USAGE_SUBGROUP = 1 << 8,
+	PROPERTY_USAGE_CLASS_IS_BITFIELD = 1 << 9,
+	PROPERTY_USAGE_NO_INSTANCE_STATE = 1 << 10,
+	PROPERTY_USAGE_RESTART_IF_CHANGED = 1 << 11,
+	PROPERTY_USAGE_SCRIPT_VARIABLE = 1 << 12,
+	PROPERTY_USAGE_STORE_IF_NULL = 1 << 13,
+	PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 1 << 14,
+	PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE = 1 << 15, // Deprecated.
+	PROPERTY_USAGE_CLASS_IS_ENUM = 1 << 16,
+	PROPERTY_USAGE_NIL_IS_VARIANT = 1 << 17,
+	PROPERTY_USAGE_ARRAY = 1 << 18, // Used in the inspector to group properties as elements of an array.
+	PROPERTY_USAGE_ALWAYS_DUPLICATE = 1 << 19, // When duplicating a resource, always duplicate, even with subresource duplication disabled.
+	PROPERTY_USAGE_NEVER_DUPLICATE = 1 << 20, // When duplicating a resource, never duplicate, even with subresource duplication enabled.
+	PROPERTY_USAGE_HIGH_END_GFX = 1 << 21,
+	PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT = 1 << 22,
+	PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT = 1 << 23,
+	PROPERTY_USAGE_KEYING_INCREMENTS = 1 << 24, // Used in inspector to increment property when keyed in animation player.
+	PROPERTY_USAGE_DEFERRED_SET_RESOURCE = 1 << 25, // Deprecated.
+	PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT = 1 << 26, // For Object properties, instantiate them when creating in editor.
+	PROPERTY_USAGE_EDITOR_BASIC_SETTING = 1 << 27, //for project or editor settings, show when basic settings are selected.
+	PROPERTY_USAGE_READ_ONLY = 1 << 28, // Mark a property as read-only in the inspector.
+	PROPERTY_USAGE_SECRET = 1 << 29, // Export preset credentials that should be stored separately from the rest of the export config.
+
+	PROPERTY_USAGE_DEFAULT = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR,
+	PROPERTY_USAGE_NO_EDITOR = PROPERTY_USAGE_STORAGE,
+};
+
+struct PropertyInfo {
+	STRUCT_DECLARE(PropertyInfo);
+	STRUCT_MEMBER_PRIMITIVE(String, name, String());
+	STRUCT_MEMBER_PRIMITIVE(StringName, class_name, StringName());
+	STRUCT_MEMBER_PRIMITIVE_FROM(Variant::Type, type, Variant::NIL);
+	STRUCT_MEMBER_PRIMITIVE_FROM(PropertyHint, hint, PROPERTY_HINT_NONE);
+	STRUCT_MEMBER_PRIMITIVE(String, hint_string, String());
+	STRUCT_MEMBER_PRIMITIVE(uint32_t, usage, PROPERTY_USAGE_DEFAULT);
+	STRUCT_LAYOUT_OWNER(Object, PropertyInfo, struct name, struct class_name, struct type, struct hint, struct hint_string, struct usage);
+
+	_FORCE_INLINE_ PropertyInfo added_usage(uint32_t p_fl) const {
+		PropertyInfo pi = *this;
+		pi.usage |= p_fl;
+		return pi;
+	}
+
+	operator Dictionary() const;
+
+	static PropertyInfo from_dict(const Dictionary &p_dict);
+
+	PropertyInfo() {}
+
+	PropertyInfo(const Variant::Type p_type, const String p_name, const PropertyHint p_hint = PROPERTY_HINT_NONE, const String &p_hint_string = "", const uint32_t p_usage = PROPERTY_USAGE_DEFAULT, const StringName &p_class_name = StringName()) :
+			name(p_name),
+			class_name(p_hint == PROPERTY_HINT_RESOURCE_TYPE ? StringName(p_hint_string) : p_class_name),
+			type(p_type),
+			hint(p_hint),
+			hint_string(p_hint_string),
+			usage(p_usage) {}
+
+	PropertyInfo(const StringName &p_class_name) :
+			class_name(p_class_name),
+			type(Variant::OBJECT) {}
+
+	explicit PropertyInfo(const GDExtensionPropertyInfo &pinfo) :
+			name(*reinterpret_cast<StringName *>(pinfo.name)),
+			class_name(*reinterpret_cast<StringName *>(pinfo.class_name)),
+			type((Variant::Type)pinfo.type),
+			hint((PropertyHint)pinfo.hint),
+			hint_string(*reinterpret_cast<String *>(pinfo.hint_string)),
+			usage(pinfo.usage) {}
+
+	bool operator==(const PropertyInfo &p_info) const {
+		return ((type == p_info.type) &&
+				(name == p_info.name) &&
+				(class_name == p_info.class_name) &&
+				(hint == p_info.hint) &&
+				(hint_string == p_info.hint_string) &&
+				(usage == p_info.usage));
+	}
+
+	bool operator<(const PropertyInfo &p_info) const {
+		return name < p_info.name;
+	}
+};
+
+TypedArray<Dictionary> convert_property_list(const List<PropertyInfo> *p_list);
+
+#endif // PROPERTY_INFO_H
diff --git a/core/string/ustring.cpp b/core/string/ustring.cpp
index 391a203d5b59..7044a74c6c41 100644
--- a/core/string/ustring.cpp
+++ b/core/string/ustring.cpp
@@ -4006,7 +4006,11 @@ String String::format(const Variant &values, const String &placeholder) const {
 
 	if (values.get_type() == Variant::ARRAY) {
 		Array values_arr = values;
-
+		if (const StructInfo *struct_info = values_arr.get_struct_info()) {
+			for (int32_t i = 0; i < struct_info->count; i++) {
+				new_string = new_string.replace(placeholder.replace("_", struct_info->names[i]), values_arr[(int)i]);
+			}
+		}
 		for (int i = 0; i < values_arr.size(); i++) {
 			String i_as_str = String::num_int64(i);
 
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index 3e62d3dffa87..5a6a27b2d105 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -39,7 +39,9 @@
 #include "core/templates/vector.h"
 #include "core/variant/callable.h"
 #include "core/variant/dictionary.h"
+#include "core/variant/struct.h"
 #include "core/variant/variant.h"
+#include "struct_generator.h"
 
 class ArrayPrivate {
 public:
@@ -47,6 +49,40 @@ class ArrayPrivate {
 	Vector<Variant> array;
 	Variant *read_only = nullptr; // If enabled, a pointer is used to a temporary value that is used to return read-only values.
 	ContainerTypeValidate typed;
+
+	_FORCE_INLINE_ bool is_struct() const {
+		return !typed.is_array_of_structs && typed.struct_info != nullptr;
+	}
+
+	_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
+	}
+
+	_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]) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	_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]) {
+				return i;
+			}
+		}
+		return -1;
+	}
 };
 
 void Array::_ref(const Array &p_from) const {
@@ -218,7 +254,7 @@ void Array::assign(const Array &p_array) {
 	const ContainerTypeValidate &typed = _p->typed;
 	const ContainerTypeValidate &source_typed = p_array._p->typed;
 
-	if (typed == source_typed || typed.type == Variant::NIL || (source_typed.type == Variant::OBJECT && typed.can_reference(source_typed))) {
+	if (typed.can_reference(source_typed)) {
 		// from same to same or
 		// from anything to variants or
 		// from subclasses to base classes
@@ -234,8 +270,9 @@ void Array::assign(const Array &p_array) {
 		// from base classes to subclasses
 		for (int i = 0; i < size; i++) {
 			const Variant &element = source[i];
-			if (element.get_type() != Variant::NIL && (element.get_type() != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
-				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(element.get_type()), Variant::get_type_name(typed.type)));
+			const Variant::Type type = source[i].get_type();
+			if (type != Variant::NIL && (type != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
+				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(type), Variant::get_type_name(typed.type)));
 			}
 		}
 		_p->array = p_array._p->array;
@@ -249,6 +286,21 @@ void Array::assign(const Array &p_array) {
 	array.resize(size);
 	Variant *data = array.ptrw();
 
+	if (is_struct()) {
+		if (source_typed.type != Variant::NIL) {
+			ERR_FAIL_COND_MSG(typed != source_typed, "Attempted to assign a typed array to a struct.");
+			_p->array = p_array._p->array;
+			return;
+		}
+		for (int i = 0; i < size; i++) {
+			ValidatedVariant validated = typed.validate_struct_member(source[i], i, "assign");
+			ERR_FAIL_COND_MSG(!validated.valid, vformat(R"(Unable to convert array index %i from "%s" to "%s".)", i, Variant::get_type_name(source[i].get_type()), Variant::get_type_name(typed.type)));
+			array.write[i] = validated.value;
+		}
+		_p->array = array;
+		return;
+	}
+
 	if (source_typed.type == Variant::NIL && typed.type != Variant::OBJECT) {
 		// from variants to primitives
 		for (int i = 0; i < size; i++) {
@@ -281,17 +333,21 @@ void Array::assign(const Array &p_array) {
 
 void Array::push_back(const Variant &p_value) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND(!_p->typed.validate(value, "push_back"));
-	_p->array.push_back(value);
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->typed.validate(p_value, "push_back");
+	ERR_FAIL_COND(!validated.valid);
+	_p->array.push_back(validated.value);
 }
 
 void Array::append_array(const Array &p_array) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 
 	Vector<Variant> validated_array = p_array._p->array;
 	for (int i = 0; i < validated_array.size(); ++i) {
-		ERR_FAIL_COND(!_p->typed.validate(validated_array.write[i], "append_array"));
+		ValidatedVariant validated = _p->typed.validate(validated_array[i], "append_array");
+		validated_array.write[i] = validated.value;
+		ERR_FAIL_COND(!validated.valid);
 	}
 
 	_p->array.append_array(validated_array);
@@ -299,36 +355,48 @@ void Array::append_array(const Array &p_array) {
 
 Error Array::resize(int p_new_size) {
 	ERR_FAIL_COND_V_MSG(_p->read_only, ERR_LOCKED, "Array is in read-only state.");
-	Variant::Type &variant_type = _p->typed.type;
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), ERR_LOCKED, "Array is a struct."); // TODO: better error message
+
 	int old_size = _p->array.size();
+	Variant::Type &variant_type = _p->typed.type;
 	Error err = _p->array.resize_zeroed(p_new_size);
-	if (!err && variant_type != Variant::NIL && variant_type != Variant::OBJECT) {
+	if (err || variant_type == Variant::NIL || variant_type == Variant::OBJECT) {
+		return err;
+	}
+	if (const StructInfo *info = _p->typed.struct_info) { // Typed array of structs
 		for (int i = old_size; i < p_new_size; i++) {
-			VariantInternal::initialize(&_p->array.write[i], variant_type);
+			_p->array.write[i] = Array(*info);
 		}
+		return err;
+	}
+	for (int i = old_size; i < p_new_size; i++) {
+		VariantInternal::initialize(&_p->array.write[i], variant_type);
 	}
 	return err;
 }
 
 Error Array::insert(int p_pos, const Variant &p_value) {
 	ERR_FAIL_COND_V_MSG(_p->read_only, ERR_LOCKED, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "insert"), ERR_INVALID_PARAMETER);
-	return _p->array.insert(p_pos, value);
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), ERR_LOCKED, "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->typed.validate(p_value, "insert");
+	ERR_FAIL_COND_V(!validated.valid, ERR_INVALID_PARAMETER);
+	return _p->array.insert(p_pos, validated.value);
 }
 
 void Array::fill(const Variant &p_value) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND(!_p->typed.validate(value, "fill"));
-	_p->array.fill(value);
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->typed.validate(p_value, "fill");
+	ERR_FAIL_COND(!validated.valid);
+	_p->array.fill(validated.value);
 }
 
 void Array::erase(const Variant &p_value) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND(!_p->typed.validate(value, "erase"));
-	_p->array.erase(value);
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->typed.validate(p_value, "erase");
+	ERR_FAIL_COND(!validated.valid);
+	_p->array.erase(validated.value);
 }
 
 Variant Array::front() const {
@@ -350,8 +418,15 @@ int Array::find(const Variant &p_value, int p_from) const {
 	if (_p->array.size() == 0) {
 		return -1;
 	}
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "find"), -1);
+	if (is_struct()) {
+		ERR_FAIL_COND_V_MSG(!p_value.is_string(), -1, "Can only find a String or StringName in a Struct.");
+		StringName member = p_value;
+		return find_member(member);
+	}
+
+	ValidatedVariant validated = _p->typed.validate(p_value, "find");
+
+	ERR_FAIL_COND_V(!validated.valid, -1);
 
 	int ret = -1;
 
@@ -360,7 +435,7 @@ int Array::find(const Variant &p_value, int p_from) const {
 	}
 
 	for (int i = p_from; i < size(); i++) {
-		if (StringLikeVariantComparator::compare(_p->array[i], value)) {
+		if (StringLikeVariantComparator::compare(_p->array[i], validated.value)) {
 			ret = i;
 			break;
 		}
@@ -401,8 +476,14 @@ int Array::rfind(const Variant &p_value, int p_from) const {
 	if (_p->array.size() == 0) {
 		return -1;
 	}
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "rfind"), -1);
+	if (is_struct()) {
+		ERR_FAIL_COND_V_MSG(!p_value.is_string(), -1, "Can only find a String or StringName in a Struct.");
+		StringName member = p_value;
+		return rfind_member(member);
+	}
+
+	ValidatedVariant validated = _p->typed.validate(p_value, "rfind");
+	ERR_FAIL_COND_V(!validated.valid, -1);
 
 	if (p_from < 0) {
 		// Relative offset from the end
@@ -414,7 +495,7 @@ int Array::rfind(const Variant &p_value, int p_from) const {
 	}
 
 	for (int i = p_from; i >= 0; i--) {
-		if (StringLikeVariantComparator::compare(_p->array[i], value)) {
+		if (StringLikeVariantComparator::compare(_p->array[i], validated.value)) {
 			return i;
 		}
 	}
@@ -458,15 +539,15 @@ int Array::rfind_custom(const Callable &p_callable, int p_from) const {
 }
 
 int Array::count(const Variant &p_value) const {
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "count"), 0);
+	ValidatedVariant validated = _p->typed.validate(p_value, "count");
+	ERR_FAIL_COND_V(!validated.valid, 0);
 	if (_p->array.size() == 0) {
 		return 0;
 	}
 
 	int amount = 0;
 	for (int i = 0; i < _p->array.size(); i++) {
-		if (StringLikeVariantComparator::compare(_p->array[i], value)) {
+		if (StringLikeVariantComparator::compare(_p->array[i], validated.value)) {
 			amount++;
 		}
 	}
@@ -475,36 +556,86 @@ int Array::count(const Variant &p_value) const {
 }
 
 bool Array::has(const Variant &p_value) const {
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "use 'has'"), false);
+	ValidatedVariant validated = _p->typed.validate(p_value, "use 'has'");
+	ERR_FAIL_COND_V(!validated.valid, false);
 
-	return find(value) != -1;
+	return find(validated.value) != -1;
 }
 
 void Array::remove_at(int p_pos) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 	_p->array.remove_at(p_pos);
 }
 
 void Array::set(int p_idx, const Variant &p_value) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND(!_p->typed.validate(value, "set"));
-
-	operator[](p_idx) = value;
+	ERR_FAIL_COND_MSG(_p->is_struct() && (p_idx >= size()), "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->is_struct() ? _p->typed.validate_struct_member(p_value, p_idx, "set") : _p->typed.validate(p_value, "set");
+	ERR_FAIL_COND(!validated.valid); // TODO: wrong error message
+	operator[](p_idx) = validated.value;
 }
 
 const Variant &Array::get(int p_idx) const {
 	return operator[](p_idx);
 }
 
+void Array::set_named(const StringName &p_member, const Variant &p_value) {
+	CRASH_COND_MSG(!_p->is_struct(), "Array is not a struct"); // TODO: should this crash?
+	int32_t index = _p->find_member_index(p_member);
+	CRASH_COND_MSG(index < 0, vformat("member '%s' not found", p_member));
+	set(index, p_value);
+}
+
+Variant &Array::get_named(const StringName &p_member) {
+	CRASH_COND_MSG(!_p->is_struct(), "Array is not a struct"); // TODO: should this crash?
+	int32_t index = _p->find_member_index(p_member);
+	CRASH_COND_MSG(index < 0, vformat("member '%s' not found", p_member));
+	return operator[](index);
+}
+
+const Variant &Array::get_named(const StringName &p_member) const {
+	CRASH_COND_MSG(!_p->is_struct(), "Array is not a struct"); // TODO: should this crash?
+	int32_t index = _p->find_member_index(p_member);
+	CRASH_COND_MSG(index < 0, vformat("member '%s' not found", p_member));
+	return get(index);
+}
+
+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];
+}
+
+int Array::find_member(const StringName &p_member) const {
+	return _p->find_member_index(p_member);
+}
+
+int Array::rfind_member(const StringName &p_member) const {
+	return _p->rfind_member_index(p_member);
+}
+
+const Variant *Array::getptr(const StringName &p_member) const {
+	int index = _p->find_member_index(p_member);
+	if (index < 0) {
+		return nullptr;
+	}
+	return &get(index);
+}
+
 Array Array::duplicate(bool p_deep) const {
 	return recursive_duplicate(p_deep, 0);
 }
 
 Array Array::recursive_duplicate(bool p_deep, int recursion_count) const {
 	Array new_arr;
-	new_arr._p->typed = _p->typed;
+	if (const StructInfo *struct_info = get_struct_info()) {
+		new_arr.set_struct(*struct_info, is_array_of_structs());
+	} else {
+		new_arr._p->typed = _p->typed;
+		if (p_deep) {
+			new_arr.resize(size());
+		}
+	}
 
 	if (recursion_count > MAX_RECURSION) {
 		ERR_PRINT("Max recursion reached");
@@ -514,7 +645,6 @@ Array Array::recursive_duplicate(bool p_deep, int recursion_count) const {
 	if (p_deep) {
 		recursion_count++;
 		int element_count = size();
-		new_arr.resize(element_count);
 		for (int i = 0; i < element_count; i++) {
 			new_arr[i] = get(i).recursive_duplicate(true, recursion_count);
 		}
@@ -692,16 +822,19 @@ struct _ArrayVariantSort {
 
 void Array::sort() {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 	_p->array.sort_custom<_ArrayVariantSort>();
 }
 
 void Array::sort_custom(const Callable &p_callable) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 	_p->array.sort_custom<CallableComparator, true>(p_callable);
 }
 
 void Array::shuffle() {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 	const int n = _p->array.size();
 	if (n < 2) {
 		return;
@@ -716,33 +849,36 @@ void Array::shuffle() {
 }
 
 int Array::bsearch(const Variant &p_value, bool p_before) const {
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "binary search"), -1);
+	ValidatedVariant validated = _p->typed.validate(p_value, "binary search");
+	ERR_FAIL_COND_V(!validated.valid, -1);
 	SearchArray<Variant, _ArrayVariantSort> avs;
-	return avs.bisect(_p->array.ptrw(), _p->array.size(), value, p_before);
+	return avs.bisect(_p->array.ptrw(), _p->array.size(), validated.value, p_before);
 }
 
 int Array::bsearch_custom(const Variant &p_value, const Callable &p_callable, bool p_before) const {
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed.validate(value, "custom binary search"), -1);
+	ValidatedVariant validated = _p->typed.validate(p_value, "custom binary search");
+	ERR_FAIL_COND_V(!validated.valid, -1);
 
-	return _p->array.bsearch_custom<CallableComparator>(value, p_before, p_callable);
+	return _p->array.bsearch_custom<CallableComparator>(validated.value, p_before, p_callable);
 }
 
 void Array::reverse() {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
 	_p->array.reverse();
 }
 
 void Array::push_front(const Variant &p_value) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	Variant value = p_value;
-	ERR_FAIL_COND(!_p->typed.validate(value, "push_front"));
-	_p->array.insert(0, value);
+	ERR_FAIL_COND_MSG(_p->is_struct(), "Array is a struct."); // TODO: better error message
+	ValidatedVariant validated = _p->typed.validate(p_value, "push_front");
+	ERR_FAIL_COND(!validated.valid);
+	_p->array.insert(0, validated.value);
 }
 
 Variant Array::pop_back() {
 	ERR_FAIL_COND_V_MSG(_p->read_only, Variant(), "Array is in read-only state.");
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), Variant(), "Array is a struct."); // TODO: better error message
 	if (!_p->array.is_empty()) {
 		const int n = _p->array.size() - 1;
 		const Variant ret = _p->array.get(n);
@@ -754,6 +890,7 @@ Variant Array::pop_back() {
 
 Variant Array::pop_front() {
 	ERR_FAIL_COND_V_MSG(_p->read_only, Variant(), "Array is in read-only state.");
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), Variant(), "Array is a struct."); // TODO: better error message
 	if (!_p->array.is_empty()) {
 		const Variant ret = _p->array.get(0);
 		_p->array.remove_at(0);
@@ -764,6 +901,7 @@ Variant Array::pop_front() {
 
 Variant Array::pop_at(int p_pos) {
 	ERR_FAIL_COND_V_MSG(_p->read_only, Variant(), "Array is in read-only state.");
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), Variant(), "Array is a struct."); // TODO: better error message
 	if (_p->array.is_empty()) {
 		// Return `null` without printing an error to mimic `pop_back()` and `pop_front()` behavior.
 		return Variant();
@@ -839,29 +977,67 @@ const void *Array::id() const {
 Array::Array(const Array &p_from, uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init();
-	set_typed(p_type, p_class_name, p_script);
+	initialize_typed(p_type, p_class_name, p_script);
 	assign(p_from);
 }
 
+Error Array::validate_set_type() {
+	// TODO: better return values?
+	ERR_FAIL_COND_V_MSG(_p->read_only, ERR_LOCKED, "Array is in read-only state.");
+	ERR_FAIL_COND_V_MSG(_p->is_struct(), ERR_LOCKED, "Array is a struct."); // TODO: better error message
+	ERR_FAIL_COND_V_MSG(_p->array.size() > 0, ERR_LOCKED, "Type can only be set when array is empty.");
+	ERR_FAIL_COND_V_MSG(_p->refcount.get() > 1, ERR_LOCKED, "Type can only be set when array has no more than one user.");
+	ERR_FAIL_COND_V_MSG(_p->typed.type != Variant::NIL, ERR_LOCKED, "Type can only be set once.");
+	return OK;
+}
+
 void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
-	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
-	ERR_FAIL_COND_MSG(_p->array.size() > 0, "Type can only be set when array is empty.");
-	ERR_FAIL_COND_MSG(_p->refcount.get() > 1, "Type can only be set when array has no more than one user.");
-	ERR_FAIL_COND_MSG(_p->typed.type != Variant::NIL, "Type can only be set once.");
-	ERR_FAIL_COND_MSG(p_class_name != StringName() && p_type != Variant::OBJECT, "Class names can only be set for type OBJECT");
+	if (validate_set_type() != OK) {
+		return;
+	}
+	ERR_FAIL_COND_MSG(p_class_name != StringName() && !(p_type == Variant::OBJECT || p_type == Variant::ARRAY), "Class names can only be set for type OBJECT or ARRAY");
 	Ref<Script> script = p_script;
 	ERR_FAIL_COND_MSG(script.is_valid() && p_class_name == StringName(), "Script class can only be set together with base class name");
 
-	_p->typed.type = Variant::Type(p_type);
-	_p->typed.class_name = p_class_name;
-	_p->typed.script = script;
-	_p->typed.where = "TypedArray";
+	_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) {
+	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);
+}
+
+void Array::initialize_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
+	ERR_FAIL_COND_MSG(p_class_name != StringName() && !(p_type == Variant::OBJECT || p_type == Variant::ARRAY), "Class names can only be set for type OBJECT or ARRAY");
+	Ref<Script> script = p_script;
+	ERR_FAIL_COND_MSG(script.is_valid() && p_class_name == StringName(), "Script class can only be set together with base class name");
+
+	_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) {
+		_p->array.resize(p_struct_info.count);
+	}
+	_p->typed = ContainerTypeValidate(p_struct_info, is_array_of_structs);
 }
 
 bool Array::is_typed() const {
 	return _p->typed.type != Variant::NIL;
 }
 
+bool Array::is_struct() const {
+	return _p->is_struct();
+}
+
+bool Array::is_array_of_structs() const {
+	return _p->is_array_of_structs();
+}
+
 bool Array::is_same_typed(const Array &p_other) const {
 	return _p->typed == p_other._p->typed;
 }
@@ -882,6 +1058,10 @@ Variant Array::get_typed_script() const {
 	return _p->typed.script;
 }
 
+const StructInfo *Array::get_struct_info() const {
+	return _p->typed.struct_info;
+}
+
 Array Array::create_read_only() {
 	Array array;
 	array.make_read_only();
@@ -903,6 +1083,38 @@ Array::Array(const Array &p_from) {
 	_ref(p_from);
 }
 
+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());
+	assign(p_from);
+}
+
+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);
+	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) {
+	_p = memnew(ArrayPrivate);
+	_p->refcount.init();
+
+	initialize_struct_type(p_struct_info, is_array_of_structs);
+	if (!is_array_of_structs) {
+		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);
+		}
+	}
+}
+
 Array::Array() {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init();
diff --git a/core/variant/array.h b/core/variant/array.h
index 6c3bae6ccb35..40f05abe2546 100644
--- a/core/variant/array.h
+++ b/core/variant/array.h
@@ -40,6 +40,12 @@ class ArrayPrivate;
 class Object;
 class StringName;
 class Callable;
+template <typename T>
+class Vector;
+struct StructMember;
+struct ContainerTypeValidate;
+struct StructInfo;
+class Dictionary;
 
 class Array {
 	mutable ArrayPrivate *_p;
@@ -118,6 +124,14 @@ class Array {
 	void set(int p_idx, const Variant &p_value);
 	const Variant &get(int p_idx) const;
 
+	void set_named(const StringName &p_member, const Variant &p_value);
+	Variant &get_named(const StringName &p_member);
+	const Variant &get_named(const StringName &p_member) const; // TODO: should be & return?
+	const StringName get_member_name(int p_idx) const;
+	int find_member(const StringName &p_member) const;
+	int rfind_member(const StringName &p_member) const;
+	const Variant *getptr(const StringName &p_member) const;
+
 	int size() const;
 	bool is_empty() const;
 	void clear();
@@ -185,13 +199,24 @@ class Array {
 
 	const void *id() const;
 
+	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);
+
+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);
+
+public:
 	bool is_typed() const;
+	bool is_struct() const;
+	bool is_array_of_structs() const;
 	bool is_same_typed(const Array &p_other) const;
 	bool is_same_instance(const Array &p_other) const;
 	uint32_t get_typed_builtin() const;
 	StringName get_typed_class_name() const;
 	Variant get_typed_script() const;
+	const StructInfo *get_struct_info() const;
 
 	void make_read_only();
 	bool is_read_only() const;
@@ -199,6 +224,9 @@ class Array {
 
 	Array(const Array &p_base, uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
 	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();
 	~Array();
 };
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index 0a23c69cb4bd..30417da435f0 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -32,18 +32,59 @@
 #define CONTAINER_TYPE_VALIDATE_H
 
 #include "core/object/script_language.h"
+#include "core/variant/struct_generator.h"
 #include "core/variant/variant.h"
 
+struct ValidatedVariant {
+	Variant value;
+	bool valid;
+
+	ValidatedVariant(const Variant &p_value, const bool p_valid) {
+		value = p_value;
+		valid = p_valid;
+	}
+};
+
 struct ContainerTypeValidate {
 	Variant::Type type = Variant::NIL;
 	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";
 
+	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 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 can_reference(const ContainerTypeValidate &p_type) const {
+		if (type == Variant::NIL) {
+			return true;
+		}
 		if (type != p_type.type) {
 			return false;
-		} else if (type != Variant::OBJECT) {
+		}
+		if (is_array_of_structs != p_type.is_array_of_structs) {
+			return false;
+		}
+		if (!StructInfo::is_compatible(struct_info, p_type.struct_info)) {
+			return false;
+		}
+		if (type != Variant::OBJECT) {
 			return true;
 		}
 
@@ -62,49 +103,43 @@ struct ContainerTypeValidate {
 		} else if (script != p_type.script && !p_type.script->inherits_script(script)) {
 			return false;
 		}
-
 		return true;
 	}
 
 	_FORCE_INLINE_ bool operator==(const ContainerTypeValidate &p_type) const {
-		return type == p_type.type && class_name == p_type.class_name && script == p_type.script;
+		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);
 	}
 	_FORCE_INLINE_ bool operator!=(const ContainerTypeValidate &p_type) const {
-		return type != p_type.type || class_name != p_type.class_name || script != p_type.script;
+		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);
 	}
 
-	// Coerces String and StringName into each other and int into float when needed.
-	_FORCE_INLINE_ bool validate(Variant &inout_variant, const char *p_operation = "use") const {
-		if (type == Variant::NIL) {
-			return true;
+	_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") {
+		if (p_type == Variant::NIL) {
+			return ValidatedVariant(p_variant, true);
 		}
-
-		if (type != inout_variant.get_type()) {
-			if (inout_variant.get_type() == Variant::NIL && type == Variant::OBJECT) {
-				return true;
-			}
-			if (type == Variant::STRING && inout_variant.get_type() == Variant::STRING_NAME) {
-				inout_variant = String(inout_variant);
-				return true;
-			} else if (type == Variant::STRING_NAME && inout_variant.get_type() == Variant::STRING) {
-				inout_variant = StringName(inout_variant);
-				return true;
-			} else if (type == Variant::FLOAT && inout_variant.get_type() == Variant::INT) {
-				inout_variant = (float)inout_variant;
-				return true;
-			}
-
-			ERR_FAIL_V_MSG(false, "Attempted to " + String(p_operation) + " a variable of type '" + Variant::get_type_name(inout_variant.get_type()) + "' into a " + where + " of type '" + Variant::get_type_name(type) + "'.");
+		if (p_type == p_variant.get_type()) {
+			return ValidatedVariant(p_variant, true);
 		}
-
-		if (type != Variant::OBJECT) {
-			return true;
+		if (p_type == Variant::OBJECT && p_variant.get_type() == Variant::NIL) {
+			return ValidatedVariant(p_variant, true);
 		}
-
-		return validate_object(inout_variant, p_operation);
+		if (p_type == Variant::STRING && p_variant.get_type() == Variant::STRING_NAME) {
+			return ValidatedVariant(String(p_variant), true);
+		}
+		if (p_type == Variant::STRING_NAME && p_variant.get_type() == Variant::STRING) {
+			return ValidatedVariant(StringName(p_variant), true);
+		}
+		if (p_type == Variant::FLOAT && p_variant.get_type() == Variant::INT) {
+			return ValidatedVariant((float)p_variant, true);
+		}
+		ERR_FAIL_V_MSG(ValidatedVariant(p_variant, false), "Attempted to " + String(p_operation) + " a variable of type '" + Variant::get_type_name(p_variant.get_type()) + "' into a " + p_where + " of type '" + Variant::get_type_name(p_type) + "'.");
 	}
 
 	_FORCE_INLINE_ bool validate_object(const Variant &p_variant, const char *p_operation = "use") const {
+		return validate_object(class_name, script, p_variant, where, p_operation);
+	}
+
+	_FORCE_INLINE_ static bool validate_object(const StringName &p_class_name, const Ref<Script> &p_script, const Variant &p_variant, const char *p_where, const char *p_operation = "use") {
 		ERR_FAIL_COND_V(p_variant.get_type() != Variant::OBJECT, false);
 
 #ifdef DEBUG_ENABLED
@@ -113,34 +148,77 @@ struct ContainerTypeValidate {
 			return true; // This is fine, it's null.
 		}
 		Object *object = ObjectDB::get_instance(object_id);
-		ERR_FAIL_NULL_V_MSG(object, false, "Attempted to " + String(p_operation) + " an invalid (previously freed?) object instance into a '" + String(where) + ".");
+		ERR_FAIL_NULL_V_MSG(object, false, "Attempted to " + String(p_operation) + " an invalid (previously freed?) object instance into a '" + String(p_where) + ".");
 #else
 		Object *object = p_variant;
 		if (object == nullptr) {
 			return true; //fine
 		}
 #endif
-		if (class_name == StringName()) {
+		if (p_class_name == StringName()) {
 			return true; // All good, no class type requested.
 		}
 
 		StringName obj_class = object->get_class_name();
-		if (obj_class != class_name) {
-			ERR_FAIL_COND_V_MSG(!ClassDB::is_parent_class(object->get_class_name(), class_name), false, "Attempted to " + String(p_operation) + " an object of type '" + object->get_class() + "' into a " + where + ", which does not inherit from '" + String(class_name) + "'.");
+		if (obj_class != p_class_name) {
+			ERR_FAIL_COND_V_MSG(!ClassDB::is_parent_class(object->get_class_name(), p_class_name), false, "Attempted to " + String(p_operation) + " an object of type '" + object->get_class() + "' into a " + p_where + ", which does not inherit from '" + String(p_class_name) + "'.");
 		}
 
-		if (script.is_null()) {
+		if (p_script.is_null()) {
 			return true; // All good, no script requested.
 		}
 
 		Ref<Script> other_script = object->get_script();
 
 		// Check base script..
-		ERR_FAIL_COND_V_MSG(other_script.is_null(), false, "Attempted to " + String(p_operation) + " an object into a " + String(where) + ", that does not inherit from '" + String(script->get_class_name()) + "'.");
-		ERR_FAIL_COND_V_MSG(!other_script->inherits_script(script), false, "Attempted to " + String(p_operation) + " an object into a " + String(where) + ", that does not inherit from '" + String(script->get_class_name()) + "'.");
+		ERR_FAIL_COND_V_MSG(other_script.is_null(), false, "Attempted to " + String(p_operation) + " an object into a " + String(p_where) + ", that does not inherit from '" + String(p_script->get_class_name()) + "'.");
+		ERR_FAIL_COND_V_MSG(!other_script->inherits_script(p_script), false, "Attempted to " + String(p_operation) + " an object into a " + String(p_where) + ", that does not inherit from '" + String(p_script->get_class_name()) + "'.");
 
 		return true;
 	}
+
+	_FORCE_INLINE_ ValidatedVariant validate(const Variant &p_variant, const char *p_operation = "use") const {
+		// TODO: Ensure !is_struct ?
+		// Coerces String and StringName into each other and int into float when needed.
+		ValidatedVariant ret = ContainerTypeValidate::validate_variant_type(type, p_variant, where, p_operation);
+		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
+				ret.valid = StructInfo::is_compatible(struct_info, array.get_struct_info());
+			} else { // validating a typed array into a typed array of typed arrays (which is currently not supported)
+				ret.valid = class_name == array.get_typed_class_name();
+			}
+		} else if (type == Variant::OBJECT) {
+			ret.valid = validate_object(p_variant, p_operation);
+		}
+		return ret;
+	}
+
+	_FORCE_INLINE_ ValidatedVariant validate_struct_member(const Variant &p_variant, const int p_struct_index, const char *p_operation = "use") const {
+		// TODO: Ensure is_struct and struct_info != nullptr ?
+		CRASH_BAD_INDEX_MSG(p_struct_index, struct_info->count, "Struct tried validation for a non-existent member");
+		const Variant::Type variant_type = struct_info->types[p_struct_index];
+		// Coerces String and StringName into each other and int into float when needed.
+		ValidatedVariant ret = ContainerTypeValidate::validate_variant_type(variant_type, p_variant, where, p_operation);
+		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);
+		}
+		return ret;
+	}
 };
 
 #endif // CONTAINER_TYPE_VALIDATE_H
diff --git a/core/variant/dictionary.cpp b/core/variant/dictionary.cpp
index 2db754438ff1..cffef3c97aed 100644
--- a/core/variant/dictionary.cpp
+++ b/core/variant/dictionary.cpp
@@ -86,31 +86,31 @@ Variant Dictionary::get_value_at_index(int p_index) const {
 // WARNING: This operator does not validate the value type. For scripting/extensions this is
 // done in `variant_setget.cpp`. Consider using `set()` if the data might be invalid.
 Variant &Dictionary::operator[](const Variant &p_key) {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "use `operator[]`"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "use `operator[]`");
+	if (unlikely(!validated_key.valid)) {
 		if (unlikely(!_p->typed_fallback)) {
 			_p->typed_fallback = memnew(Variant);
 		}
 		VariantInternal::initialize(_p->typed_fallback, _p->typed_value.type);
 		return *_p->typed_fallback;
 	} else if (unlikely(_p->read_only)) {
-		if (likely(_p->variant_map.has(key))) {
-			*_p->read_only = _p->variant_map[key];
+		if (likely(_p->variant_map.has(validated_key.value))) {
+			*_p->read_only = _p->variant_map[validated_key.value];
 		} else {
 			VariantInternal::initialize(_p->read_only, _p->typed_value.type);
 		}
 		return *_p->read_only;
 	} else {
-		if (unlikely(!_p->variant_map.has(key))) {
-			VariantInternal::initialize(&_p->variant_map[key], _p->typed_value.type);
+		if (unlikely(!_p->variant_map.has(validated_key.value))) {
+			VariantInternal::initialize(&_p->variant_map[validated_key.value], _p->typed_value.type);
 		}
-		return _p->variant_map[key];
+		return _p->variant_map[validated_key.value];
 	}
 }
 
 const Variant &Dictionary::operator[](const Variant &p_key) const {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "use `operator[]`"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "use `operator[]`");
+	if (unlikely(!validated_key.valid)) {
 		if (unlikely(!_p->typed_fallback)) {
 			_p->typed_fallback = memnew(Variant);
 		}
@@ -118,16 +118,16 @@ const Variant &Dictionary::operator[](const Variant &p_key) const {
 		return *_p->typed_fallback;
 	} else {
 		// Will not insert key, so no initialization is necessary.
-		return _p->variant_map[key];
+		return _p->variant_map[validated_key.value];
 	}
 }
 
 const Variant *Dictionary::getptr(const Variant &p_key) const {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "getptr"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "getptr");
+	if (unlikely(!validated_key.valid)) {
 		return nullptr;
 	}
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(key));
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(validated_key.value));
 	if (!E) {
 		return nullptr;
 	}
@@ -136,11 +136,11 @@ const Variant *Dictionary::getptr(const Variant &p_key) const {
 
 // WARNING: This method does not validate the value type.
 Variant *Dictionary::getptr(const Variant &p_key) {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "getptr"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "getptr");
+	if (unlikely(!validated_key.valid)) {
 		return nullptr;
 	}
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E(_p->variant_map.find(key));
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E(_p->variant_map.find(validated_key.value));
 	if (!E) {
 		return nullptr;
 	}
@@ -153,9 +153,9 @@ Variant *Dictionary::getptr(const Variant &p_key) {
 }
 
 Variant Dictionary::get_valid(const Variant &p_key) const {
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get_valid"), Variant());
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(key));
+	ValidatedVariant validated = _p->typed_key.validate(p_key, "get_valid");
+	ERR_FAIL_COND_V(!validated.valid, Variant());
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(validated.value));
 
 	if (!E) {
 		return Variant();
@@ -164,9 +164,9 @@ Variant Dictionary::get_valid(const Variant &p_key) const {
 }
 
 Variant Dictionary::get(const Variant &p_key, const Variant &p_default) const {
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get"), p_default);
-	const Variant *result = getptr(key);
+	ValidatedVariant validated = _p->typed_key.validate(p_key, "get");
+	ERR_FAIL_COND_V(!validated.valid, p_default);
+	const Variant *result = getptr(validated.value);
 	if (!result) {
 		return p_default;
 	}
@@ -175,25 +175,27 @@ Variant Dictionary::get(const Variant &p_key, const Variant &p_default) const {
 }
 
 Variant Dictionary::get_or_add(const Variant &p_key, const Variant &p_default) {
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get"), p_default);
-	const Variant *result = getptr(key);
-	if (!result) {
-		Variant value = p_default;
-		ERR_FAIL_COND_V(!_p->typed_value.validate(value, "add"), value);
-		operator[](key) = value;
-		return value;
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "get");
+	ERR_FAIL_COND_V(!validated_key.valid, p_default);
+	const Variant *result = getptr(validated_key.value);
+
+	if (result) {
+		return *result;
 	}
-	return *result;
+
+	ValidatedVariant validated_default = _p->typed_key.validate(p_default, "add");
+	ERR_FAIL_COND_V(!validated_default.valid, validated_default.value);
+	operator[](validated_key.value) = validated_default.value;
+	return validated_default.value;
 }
 
 bool Dictionary::set(const Variant &p_key, const Variant &p_value) {
 	ERR_FAIL_COND_V_MSG(_p->read_only, false, "Dictionary is in read-only state.");
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "set"), false);
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed_value.validate(value, "set"), false);
-	_p->variant_map[key] = value;
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "set");
+	ERR_FAIL_COND_V(!validated_key.valid, false);
+	ValidatedVariant validated_value = _p->typed_value.validate(p_value, "set");
+	ERR_FAIL_COND_V(!validated_value.valid, false);
+	_p->variant_map[validated_key.value] = validated_value.value;
 	return true;
 }
 
@@ -206,16 +208,16 @@ bool Dictionary::is_empty() const {
 }
 
 bool Dictionary::has(const Variant &p_key) const {
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "use 'has'"), false);
+	ValidatedVariant validated = _p->typed_key.validate(p_key, "use 'has'");
+	ERR_FAIL_COND_V(!validated.valid, false);
 	return _p->variant_map.has(p_key);
 }
 
 bool Dictionary::has_all(const Array &p_keys) const {
 	for (int i = 0; i < p_keys.size(); i++) {
-		Variant key = p_keys[i];
-		ERR_FAIL_COND_V(!_p->typed_key.validate(key, "use 'has_all'"), false);
-		if (!has(key)) {
+		ValidatedVariant validated = _p->typed_key.validate(p_keys[i], "use 'has_all'");
+		ERR_FAIL_COND_V(!validated.valid, false);
+		if (!has(validated.value)) {
 			return false;
 		}
 	}
@@ -223,10 +225,10 @@ bool Dictionary::has_all(const Array &p_keys) const {
 }
 
 Variant Dictionary::find_key(const Variant &p_value) const {
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed_value.validate(value, "find_key"), Variant());
+	ValidatedVariant validated = _p->typed_key.validate(p_value, "find_key");
+	ERR_FAIL_COND_V(!validated.valid, Variant());
 	for (const KeyValue<Variant, Variant> &E : _p->variant_map) {
-		if (E.value == value) {
+		if (E.value == validated.value) {
 			return E.key;
 		}
 	}
@@ -234,10 +236,10 @@ Variant Dictionary::find_key(const Variant &p_value) const {
 }
 
 bool Dictionary::erase(const Variant &p_key) {
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "erase"), false);
+	ValidatedVariant validated = _p->typed_key.validate(p_key, "erase");
+	ERR_FAIL_COND_V(!validated.valid, false);
 	ERR_FAIL_COND_V_MSG(_p->read_only, false, "Dictionary is in read-only state.");
-	return _p->variant_map.erase(key);
+	return _p->variant_map.erase(validated.value);
 }
 
 bool Dictionary::operator==(const Dictionary &p_dictionary) const {
@@ -297,12 +299,12 @@ void Dictionary::clear() {
 void Dictionary::merge(const Dictionary &p_dictionary, bool p_overwrite) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Dictionary is in read-only state.");
 	for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
-		Variant key = E.key;
-		Variant value = E.value;
-		ERR_FAIL_COND(!_p->typed_key.validate(key, "merge"));
-		ERR_FAIL_COND(!_p->typed_value.validate(value, "merge"));
-		if (p_overwrite || !has(key)) {
-			operator[](key) = value;
+		ValidatedVariant validated_key = _p->typed_key.validate(E.key, "merge");
+		ERR_FAIL_COND(!validated_key.valid);
+		ValidatedVariant validated_value = _p->typed_key.validate(E.value, "merge");
+		ERR_FAIL_COND(!validated_value.valid);
+		if (p_overwrite || !has(validated_key.value)) {
+			operator[](validated_key.value) = validated_value.value;
 		}
 	}
 }
@@ -536,9 +538,9 @@ const Variant *Dictionary::next(const Variant *p_key) const {
 		}
 		return nullptr;
 	}
-	Variant key = *p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "next"), nullptr);
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E = _p->variant_map.find(key);
+	ValidatedVariant validated = _p->typed_key.validate(*p_key, "next");
+	ERR_FAIL_COND_V(!validated.valid, nullptr);
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E = _p->variant_map.find(validated.value);
 
 	if (!E) {
 		return nullptr;
@@ -683,6 +685,15 @@ Dictionary::Dictionary(const Dictionary &p_from) {
 	_ref(p_from);
 }
 
+Dictionary::Dictionary(const Array &p_from, const StructInfo &p_struct_info) {
+	_p = memnew(DictionaryPrivate);
+	_p->refcount.init();
+	for (int i = 0; i < p_struct_info.count; i++) { // TODO: is there a more efficient way to do this?
+		Variant value = (0 <= i && i < p_from.size()) ? p_from[i] : p_struct_info.default_values[i];
+		_p->variant_map.insert(p_struct_info.names[i], value);
+	}
+}
+
 Dictionary::Dictionary() {
 	_p = memnew(DictionaryPrivate);
 	_p->refcount.init();
diff --git a/core/variant/dictionary.h b/core/variant/dictionary.h
index 5f3ce40219bd..bd724fbc601a 100644
--- a/core/variant/dictionary.h
+++ b/core/variant/dictionary.h
@@ -111,6 +111,7 @@ class Dictionary {
 
 	Dictionary(const Dictionary &p_base, uint32_t p_key_type, const StringName &p_key_class_name, const Variant &p_key_script, uint32_t p_value_type, const StringName &p_value_class_name, const Variant &p_value_script);
 	Dictionary(const Dictionary &p_from);
+	Dictionary(const Array &p_from, const StructInfo &p_struct_info);
 	Dictionary();
 	~Dictionary();
 };
diff --git a/core/variant/struct.h b/core/variant/struct.h
new file mode 100644
index 000000000000..7c4c8c6fc83c
--- /dev/null
+++ b/core/variant/struct.h
@@ -0,0 +1,146 @@
+/**************************************************************************/
+/*  struct.h                                                              */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef STRUCT_H
+#define STRUCT_H
+
+#include "core/object/object.h"
+#include "core/variant/array.h"
+#include "core/variant/binder_common.h"
+#include "core/variant/method_ptrcall.h"
+#include "core/variant/type_info.h"
+#include "core/variant/variant.h"
+
+class Array;
+
+template <class T>
+class Struct : public Array {
+public:
+	_FORCE_INLINE_ void operator=(const Array &p_array) {
+		ERR_FAIL_COND_MSG(!is_same_typed(p_array), "Cannot assign a Struct from array with a different format.");
+		_ref(p_array);
+	}
+	_FORCE_INLINE_ Variant &operator[](const StringName &p_struct_member) {
+		return get_named(p_struct_member);
+	}
+	_FORCE_INLINE_ const Variant &operator[](const StringName &p_struct_member) const {
+		return get_named(p_struct_member);
+	}
+	template <typename StructMember>
+	_FORCE_INLINE_ int get_member_index() const {
+		return T::Layout::template get_member_index<StructMember>();
+	}
+	template <typename StructMember>
+	_FORCE_INLINE_ Variant get_member_value() const {
+		return get(get_member_index<StructMember>());
+	}
+	template <typename StructMember>
+	_FORCE_INLINE_ void set_member_value(const typename StructMember::Type &p_value) {
+		set(get_member_index<StructMember>(), p_value);
+	}
+	template <typename StructMember>
+	_FORCE_INLINE_ typename StructMember::Type get_member() const {
+		return StructMember::from_variant(get(get_member_index<StructMember>()));
+	}
+	template <typename StructMember>
+	_FORCE_INLINE_ void set_member(const typename StructMember::Type &p_struct_member) {
+		set(get_member_index<StructMember>(), StructMember::to_variant(p_struct_member));
+	}
+	_FORCE_INLINE_ Struct(const T &p_struct) :
+			Array(T::Layout::to_array(p_struct), T::get_struct_info()) {
+	}
+	_FORCE_INLINE_ Struct(const Variant &p_variant) :
+			Array(Array(p_variant), T::get_struct_info()) {
+	}
+	_FORCE_INLINE_ Struct(const Array &p_array) :
+			Array(p_array, T::get_struct_info()) {
+	}
+	_FORCE_INLINE_ Struct() :
+			Array(T::get_struct_info()) {
+	}
+	_FORCE_INLINE_ operator Dictionary() {
+		Dictionary dict;
+		for (int i = 0; i < size(); i++) {
+			dict[get_member_name(i)] = get(i);
+		}
+		return dict;
+	}
+};
+
+template <class T>
+struct VariantInternalAccessor<Struct<T>> {
+	_FORCE_INLINE_ static Struct<T> get(const Variant *v) { return *VariantInternal::get_array(v); }
+	_FORCE_INLINE_ static void set(Variant *v, const Struct<T> &p_array) { *VariantInternal::get_array(v) = p_array; }
+};
+
+template <class T>
+struct VariantInternalAccessor<const Struct<T> &> {
+	_FORCE_INLINE_ static Struct<T> get(const Variant *v) { return *VariantInternal::get_array(v); }
+	_FORCE_INLINE_ static void set(Variant *v, const Struct<T> &p_array) { *VariantInternal::get_array(v) = p_array; }
+};
+
+template <class T>
+struct PtrToArg<Struct<T>> {
+	_FORCE_INLINE_ static Struct<T> convert(const void *p_ptr) {
+		return Struct<T>(*reinterpret_cast<const Array *>(p_ptr));
+	}
+	typedef Array EncodeT;
+	_FORCE_INLINE_ static void encode(Struct<T> p_val, void *p_ptr) {
+		*(Array *)p_ptr = p_val;
+	}
+};
+
+template <class T>
+struct PtrToArg<const Struct<T> &> {
+	typedef Array EncodeT;
+	_FORCE_INLINE_ static Struct<T> convert(const void *p_ptr) {
+		return Struct<T>(*reinterpret_cast<const Array *>(p_ptr));
+	}
+};
+
+template <class T>
+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());
+	}
+};
+
+template <class T>
+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());
+	}
+};
+
+#endif // STRUCT_H
diff --git a/core/variant/struct_generator.cpp b/core/variant/struct_generator.cpp
new file mode 100644
index 000000000000..057f7f190c1f
--- /dev/null
+++ b/core/variant/struct_generator.cpp
@@ -0,0 +1,65 @@
+/**************************************************************************/
+/*  struct_generator.cpp                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "struct_generator.h"
+
+#include "core/variant/struct.h"
+#include "core/variant/typed_array.h"
+
+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];
+	}
+	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();
+	}
+	dict["struct_member_infos"] = member_info_dictionaries;
+	dict["default_values"] = default_values;
+	return dict;
+}
+
+// Needs to be in .cpp so struct.h can be included
+template <typename StructType, typename... StructMembers>
+void StructLayout<StructType, StructMembers...>::fill_struct_array(Struct<StructType> &p_array, const StructType &p_struct) {
+	int dummy[] = { 0, (p_array.template set_member_value<StructMembers>(StructMembers::get_variant(p_struct)), 0)... };
+	(void)dummy; // Suppress unused variable warning
+}
diff --git a/core/variant/struct_generator.h b/core/variant/struct_generator.h
new file mode 100644
index 000000000000..0289ff473d49
--- /dev/null
+++ b/core/variant/struct_generator.h
@@ -0,0 +1,303 @@
+/**************************************************************************/
+/*  struct_generator.h                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef STRUCT_GENERATOR_H
+#define STRUCT_GENERATOR_H
+
+#include "core/variant/variant.h"
+
+template <typename T>
+class TypedArray;
+
+template <typename T>
+class Struct;
+
+#define STRUCT_DECLARE(m_struct_name) using StructType = m_struct_name
+
+#define STRUCT_MEMBER_TYPEDEF_ALIAS(m_type, m_member_name, m_member_name_alias, m_default)                                                       \
+	using Type = m_type;                                                                                                                         \
+	_FORCE_INLINE_ static const StringName get_name() { return SNAME(m_member_name_alias); }                                                     \
+	_FORCE_INLINE_ static Variant get_variant(const StructType &p_struct) { return to_variant(p_struct.m_member_name); }                         \
+	_FORCE_INLINE_ static const Variant get_default_value_variant() { return to_variant(m_default); }                                            \
+	_FORCE_INLINE_ static Type get(const StructType &p_struct) { return p_struct.m_member_name; }                                                \
+	_FORCE_INLINE_ static Type get_default_value() { return m_default; }                                                                         \
+	_FORCE_INLINE_ static void set_variant(StructType &p_struct, const Variant &p_variant) { p_struct.m_member_name = from_variant(p_variant); } \
+	_FORCE_INLINE_ static void set(StructType &p_struct, const m_type &p_value) { p_struct.m_member_name = p_value; }
+
+#define STRUCT_MEMBER_TYPEDEF(m_type, m_member_name, m_default) \
+	STRUCT_MEMBER_TYPEDEF_ALIAS(m_type, m_member_name, #m_member_name, m_default)
+
+#define STRUCT_MEMBER_TYPEDEF_POINTER(m_type, m_member_name, m_default)                                                                          \
+	using Type = m_type *;                                                                                                                       \
+	_FORCE_INLINE_ static const StringName get_name() { return SNAME(#m_member_name); }                                                          \
+	_FORCE_INLINE_ static Variant get_variant(const StructType &p_struct) { return to_variant(p_struct.m_member_name); }                         \
+	_FORCE_INLINE_ static const Variant get_default_value_variant() { return to_variant(m_default); }                                            \
+	_FORCE_INLINE_ static Type get(const StructType &p_struct) { return p_struct.m_member_name; }                                                \
+	_FORCE_INLINE_ static const m_type *get_default_value() { return m_default; }                                                                \
+	_FORCE_INLINE_ static void set_variant(StructType &p_struct, const Variant &p_variant) { p_struct.m_member_name = from_variant(p_variant); } \
+	_FORCE_INLINE_ static void set(StructType &p_struct, Type p_value) { p_struct.m_member_name = p_value; }
+
+#define STRUCT_MEMBER_PRIMITIVE_ALIAS(m_type, m_member_name, m_member_name_alias, 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 p_variant; }           \
+		_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; }                               \
+	}
+
+#define STRUCT_MEMBER_PRIMITIVE_FROM(m_type, m_member_name, m_default)                                      \
+	m_type m_member_name = m_default;                                                                       \
+	struct m_member_name {                                                                                  \
+		static m_type from_variant(const Variant &p_variant);                                               \
+		_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; }                               \
+	}
+
+#define STRUCT_MEMBER_PRIMITIVE(m_type, m_member_name, m_default) \
+	STRUCT_MEMBER_PRIMITIVE_ALIAS(m_type, m_member_name, #m_member_name, m_default)
+
+#define STRUCT_MEMBER_PRIMITIVE_FROM_TO_ALIAS(m_type, m_member_name, m_member_name_alias, m_default)        \
+	m_type m_member_name = m_default;                                                                       \
+	struct m_member_name {                                                                                  \
+		static m_type from_variant(const Variant &p_variant);                                               \
+		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; }                               \
+	}
+
+#define STRUCT_MEMBER_PRIMITIVE_FROM_TO(m_type, m_member_name, m_default) \
+	STRUCT_MEMBER_PRIMITIVE_FROM_TO_ALIAS(m_type, m_member_name, #m_member_name, m_default)
+
+#define STRUCT_MEMBER_CLASS_POINTER(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 Object::cast_to<m_type>(p_variant); } \
+		_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; }                                               \
+	}
+
+#define STRUCT_MEMBER_CLASS_VALUE(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 p_variant; } \
+		_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; }                     \
+	}
+
+#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_FROM_TO_ALIAS(m_type, m_member_name, m_member_name_alias, m_default) \
+	m_type m_member_name = m_default;                                                             \
+	struct m_member_name {                                                                        \
+		static m_type from_variant(const Variant &p_variant);                                     \
+		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();                                            \
+		}                                                                                         \
+	}
+
+#define STRUCT_MEMBER_STRUCT_FROM_TO(m_type, m_member_name, m_default) \
+	STRUCT_MEMBER_STRUCT_FROM_TO_ALIAS(m_type, m_member_name, #m_member_name, m_default)
+
+#define STRUCT_LAYOUT_WITH_NAME(m_struct_name, m_struct, ...) \
+	static const StringName get_struct_name() {               \
+		return SNAME(m_struct_name);                          \
+	}                                                         \
+	static const StructInfo &get_struct_info() {              \
+		return Layout::get_struct_info();                     \
+	}                                                         \
+	using Layout = StructLayout<m_struct, __VA_ARGS__>;       \
+	m_struct(const Dictionary &p_dict) {                      \
+		Layout::fill_struct(p_dict, *this);                   \
+	}                                                         \
+	m_struct(const Array &p_array) {                          \
+		Layout::fill_struct(p_array, *this);                  \
+	}
+
+#define STRUCT_LAYOUT_OWNER(m_owner, m_struct, ...) STRUCT_LAYOUT_WITH_NAME(#m_owner "." #m_struct, m_struct, __VA_ARGS__)
+
+#define STRUCT_LAYOUT(m_struct, ...) STRUCT_LAYOUT_WITH_NAME(#m_struct, m_struct, __VA_ARGS__)
+
+struct StructInfo {
+	StringName name = StringName();
+	int32_t count = 0;
+
+	Vector<StringName> names;
+	Vector<Variant::Type> types;
+	Vector<StringName> class_names;
+	Vector<const StructInfo *> struct_member_infos;
+	Vector<Variant> 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);
+		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) :
+			name(p_name),
+			count(p_count),
+			names(p_names),
+			types(p_types),
+			class_names(p_class_names),
+			struct_member_infos(p_struct_member_infos),
+			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) {
+		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;
+		default_values.write[p_index] = p_default_value;
+	}
+
+	_FORCE_INLINE_ bool operator==(const StructInfo &p_struct_info) const {
+		return name == p_struct_info.name;
+	}
+	_FORCE_INLINE_ bool operator!=(const StructInfo &p_struct_info) const {
+		return name != p_struct_info.name;
+	}
+	_FORCE_INLINE_ static bool is_compatible(const StructInfo *p_struct_info_1, const StructInfo *p_struct_info_2) {
+		if (p_struct_info_1) {
+			if (p_struct_info_2) {
+				return *p_struct_info_1 == *p_struct_info_2;
+			}
+			return false;
+		}
+		return p_struct_info_2 == nullptr;
+	}
+};
+
+template <typename StructType, typename... StructMembers>
+struct StructLayout {
+	static constexpr int32_t struct_member_count = sizeof...(StructMembers);
+	_FORCE_INLINE_ static const StringName get_struct_name() {
+		return StructType::get_struct_name();
+	}
+	_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<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);
+		return info;
+	}
+
+	static Array to_array(const StructType &p_struct) {
+		Array array;
+		fill_array(array, p_struct);
+		return array;
+	}
+	static void fill_array(Array &p_array, const StructType &p_struct) {
+		p_array.resize(struct_member_count);
+		Variant vals[struct_member_count] = { StructMembers::get_variant(p_struct)... };
+		for (int32_t i = 0; i < struct_member_count; i++) {
+			p_array.set(i, vals[i]);
+		}
+	}
+	static void fill_struct(const Array &p_array, StructType &p_struct) {
+		int32_t i = 0;
+		int temp[] = { 0, (StructMembers::set_variant(p_struct, p_array.get(i)), i++, 0)... };
+		(void)temp; // Suppress unused variable warning
+	}
+	static void fill_struct_array(Struct<StructType> &p_array, const StructType &p_struct);
+
+	static Dictionary to_dict(const StructType &p_struct) {
+		Dictionary dict;
+		fill_dict(dict, p_struct);
+		return dict;
+	}
+	static void fill_dict(Dictionary &p_dict, const StructType &p_struct) {
+		int temp[] = { 0, (p_dict[StructMembers::get_name()] = StructMembers::get_variant(p_struct), 0)... };
+		(void)temp; // Suppress unused variable warning
+	}
+	static void fill_struct(const Dictionary &p_dict, StructType &p_struct) {
+		int temp[] = { 0, (StructMembers::set_variant(p_struct, p_dict[StructMembers::get_name()]), 0)... };
+		(void)temp; // Suppress unused variable warning
+	}
+
+	template <typename T>
+	_FORCE_INLINE_ static constexpr int get_member_index() {
+		return sizeof...(StructMembers) - TypeFinder<T, StructMembers...>::remaining_count - 1;
+	}
+
+private:
+	template <typename TypeToFind, typename... TypesToSearch>
+	struct TypeFinder;
+
+	template <typename TypeFound, typename... TypesRemaining>
+	struct TypeFinder<TypeFound, TypeFound, TypesRemaining...> {
+		static constexpr int remaining_count = sizeof...(TypesRemaining);
+	};
+
+	template <typename TypeNotFound>
+	struct TypeFinder<TypeNotFound> {
+		static constexpr int remaining_count = 0;
+	};
+
+	template <typename TypeToFind, typename TypeToCheck, typename... TypesRemaining>
+	struct TypeFinder<TypeToFind, TypeToCheck, TypesRemaining...> {
+		static constexpr int remaining_count = TypeFinder<TypeToFind, TypesRemaining...>::remaining_count;
+	};
+};
+
+#endif // STRUCT_GENERATOR_H
diff --git a/core/variant/typed_array.h b/core/variant/typed_array.h
index 07bf8afa7b7b..7cada0e2f705 100644
--- a/core/variant/typed_array.h
+++ b/core/variant/typed_array.h
@@ -57,7 +57,7 @@ class TypedArray : public Array {
 		}
 	}
 	_FORCE_INLINE_ TypedArray() {
-		set_typed(Variant::OBJECT, T::get_class_static(), Variant());
+		initialize_typed(Variant::OBJECT, T::get_class_static(), Variant());
 	}
 };
 
@@ -72,6 +72,53 @@ struct VariantInternalAccessor<const TypedArray<T> &> {
 	static _FORCE_INLINE_ void set(Variant *v, const TypedArray<T> &p_array) { *VariantInternal::get_array(v) = p_array; }
 };
 
+template <typename T>
+class TypedArray<Struct<T>> : public Array {
+public:
+	_FORCE_INLINE_ void operator=(const Array &p_array) {
+		ERR_FAIL_COND_MSG(!is_same_typed(p_array), "Cannot assign an array with a different element type.");
+		_ref(p_array);
+	}
+	_FORCE_INLINE_ TypedArray(const Variant &p_variant) :
+			Array(Array(p_variant), T::get_struct_info()) {
+	}
+	_FORCE_INLINE_ TypedArray(const Array &p_array) : // TypedArray(struct) creates [ struct ]
+			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);
+	}
+	_FORCE_INLINE_ TypedArray(const List<T> *p_list) {
+		initialize_struct_type(T::get_struct_info(), true);
+		for (const typename List<T>::Element *E = p_list->front(); E; E = E->next()) {
+			push_back(Struct<T>(E->get()));
+		}
+	}
+	_FORCE_INLINE_ operator List<T>() const {
+		List<T> list;
+		for (int i = 0; i < size(); i++) {
+			list.push_back(T(Struct<T>(get(i))));
+		}
+		return list;
+	}
+};
+template <typename T>
+struct GetTypeInfo<TypedArray<Struct<T>>> {
+	static const Variant::Type VARIANT_TYPE = Variant::ARRAY;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
+	static inline PropertyInfo get_class_info() {
+		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::get_struct_name());
+	}
+};
+template <typename T>
+struct GetTypeInfo<const TypedArray<Struct<T>> &> {
+	static const Variant::Type VARIANT_TYPE = Variant::ARRAY;
+	static const GodotTypeInfo::Metadata METADATA = GodotTypeInfo::METADATA_NONE;
+	static inline PropertyInfo get_class_info() {
+		return PropertyInfo(Variant::ARRAY, String(), PROPERTY_HINT_ARRAY_TYPE, T::get_struct_name());
+	}
+};
+
 //specialization for the rest of variant types
 
 #define MAKE_TYPED_ARRAY(m_type, m_variant_type)                                                                 \
@@ -94,7 +141,7 @@ struct VariantInternalAccessor<const TypedArray<T> &> {
 			}                                                                                                    \
 		}                                                                                                        \
 		_FORCE_INLINE_ TypedArray() {                                                                            \
-			set_typed(m_variant_type, StringName(), Variant());                                                  \
+			initialize_typed(m_variant_type, StringName(), Variant());                                           \
 		}                                                                                                        \
 	};
 
diff --git a/core/variant/variant.cpp b/core/variant/variant.cpp
index 186643b024ac..ce7b76af487b 100644
--- a/core/variant/variant.cpp
+++ b/core/variant/variant.cpp
@@ -1694,6 +1694,21 @@ String stringify_vector(const T &vec, int recursion_count) {
 	return str;
 }
 
+String stringify_array(const Array &p_array, int recursion_count) { // TODO: should this be called r_recursion_count?
+	String str("[");
+	for (int i = 0; i < p_array.size(); i++) {
+		if (i > 0) {
+			str += ", ";
+		}
+		if (p_array.is_struct()) {
+			str += String(p_array.get_member_name(i)) + ": ";
+		}
+		str += stringify_variant_clean(p_array[i], recursion_count);
+	}
+	str += "]";
+	return str;
+}
+
 String Variant::stringify(int recursion_count) const {
 	switch (type) {
 		case NIL:
@@ -1809,7 +1824,7 @@ String Variant::stringify(int recursion_count) const {
 			ERR_FAIL_COND_V_MSG(recursion_count > MAX_RECURSION, "[...]", "Maximum array recursion reached!");
 			recursion_count++;
 
-			return stringify_vector(operator Array(), recursion_count);
+			return stringify_array(operator Array(), recursion_count);
 		}
 		case OBJECT: {
 			if (_get_obj().obj) {
diff --git a/core/variant/variant.h b/core/variant/variant.h
index d4e4b330cdc6..3d876296ac91 100644
--- a/core/variant/variant.h
+++ b/core/variant/variant.h
@@ -350,6 +350,9 @@ class Variant {
 	_FORCE_INLINE_ bool is_array() const {
 		return type >= ARRAY;
 	}
+	_FORCE_INLINE_ bool is_struct() const {
+		return Array(*this).is_struct(); // TODO: not sure if this is the best way to do this.
+	}
 	bool is_shared() const;
 	bool is_zero() const;
 	bool is_one() const;
diff --git a/core/variant/variant_construct.cpp b/core/variant/variant_construct.cpp
index fb75a874e728..94c5e87dd6b8 100644
--- a/core/variant/variant_construct.cpp
+++ b/core/variant/variant_construct.cpp
@@ -203,6 +203,7 @@ void Variant::_register_variant_constructors() {
 	add_constructor<VariantConstructNoArgs<Array>>(sarray());
 	add_constructor<VariantConstructor<Array, Array>>(sarray("from"));
 	add_constructor<VariantConstructorTypedArray>(sarray("base", "type", "class_name", "script"));
+	//	add_constructor<VariantConstructorStruct>(sarray("base", "size", "struct_name", "member_names"));
 	add_constructor<VariantConstructorToArray<PackedByteArray>>(sarray("from"));
 	add_constructor<VariantConstructorToArray<PackedInt32Array>>(sarray("from"));
 	add_constructor<VariantConstructorToArray<PackedInt64Array>>(sarray("from"));
diff --git a/core/variant/variant_construct.h b/core/variant/variant_construct.h
index 68210a945128..c9bc1b875299 100644
--- a/core/variant/variant_construct.h
+++ b/core/variant/variant_construct.h
@@ -581,6 +581,93 @@ class VariantConstructorTypedArray {
 	}
 };
 
+//class VariantConstructorStruct {
+//public:
+//	static void construct(Variant &r_ret, const Variant **p_args, Callable::CallError &r_error) {
+//		// want to call Array::Array(const Array &p_from, uint32_t p_size, const StringName &p_name, const StructMember &(*p_get_member)(uint32_t))
+//		for (int i = 0; i < get_argument_count(); i++) {
+//			Variant::Type arg_type = get_argument_type(i);
+//			if (p_args[i]->get_type() != arg_type) {
+//				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
+//				r_error.argument = i;
+//				r_error.expected = arg_type;
+//				return;
+//			}
+//		}
+//
+//		const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+//		const uint32_t size = p_args[1]->operator uint32_t();
+//		const StringName &struct_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
+//		// TODO: I don't like have to use PackedStringArray here, but there is no PackedStringNameArray
+//		const PackedStringArray &member_names = *VariantGetInternalPtr<PackedStringArray>::get_ptr(p_args[3]);
+//		Vector<StringName> names;
+//		const int count = member_names.size();
+//		names.resize(count);
+//		for (int i = 0; i < count; i++) {
+//			names.write[i] = StringName(member_names[i]);
+//		}
+//		r_ret = Array(base_arr, size, struct_name, names);
+//	}
+//
+//	_FORCE_INLINE_ static void validated_construct(Variant *r_ret, const Variant **p_args) {
+//		const Array &base_arr = *VariantGetInternalPtr<Array>::get_ptr(p_args[0]);
+//		const uint32_t size = p_args[1]->operator uint32_t();
+//		const StringName &struct_name = *VariantGetInternalPtr<StringName>::get_ptr(p_args[2]);
+//		const PackedStringArray &member_names = *VariantGetInternalPtr<PackedStringArray>::get_ptr(p_args[3]);
+//		Vector<StringName> names;
+//		const int count = member_names.size();
+//		names.resize(count);
+//		for (int i = 0; i < count; i++) {
+//			names.write[i] = StringName(member_names[i]);
+//		}
+//		*r_ret = Array(base_arr, size, struct_name, names);
+//	}
+//
+//	static void ptr_construct(void *base, const void **p_args) {
+//		const Array &base_arr = PtrToArg<Array>::convert(p_args[0]);
+//		const uint32_t size = PtrToArg<uint32_t>::convert(p_args[1]);
+//		const StringName &struct_name = PtrToArg<StringName>::convert(p_args[2]);
+//		const PackedStringArray &member_names = PtrToArg<PackedStringArray>::convert(p_args[3]);
+//		Vector<StringName> names;
+//		const int count = member_names.size();
+//		names.resize(count);
+//		for (int i = 0; i < count; i++) {
+//			names.write[i] = StringName(member_names[i]);
+//		}
+//		Array dst_arr = Array(base_arr, size, struct_name, names);
+//
+//		PtrConstruct<Array>::construct(dst_arr, base);
+//	}
+//
+//	_FORCE_INLINE_ static int get_argument_count() { // TODO: should this be const?
+//		return 4;
+//	}
+//
+//	_FORCE_INLINE_ static Variant::Type get_argument_type(int p_arg) { // TODO: should this be const?
+//		switch (p_arg) {
+//			case 0: {
+//				return Variant::ARRAY;
+//			} break;
+//			case 1: {
+//				return Variant::INT;
+//			} break;
+//			case 2: {
+//				return Variant::STRING_NAME;
+//			} break;
+//			case 3: {
+//				return Variant::PACKED_STRING_ARRAY;
+//			} break;
+//			default: {
+//				return Variant::NIL;
+//			} break;
+//		}
+//	}
+//
+//	_FORCE_INLINE_ static Variant::Type get_base_type() { // TODO: should this be const?
+//		return Variant::ARRAY;
+//	}
+//};
+
 template <typename T>
 class VariantConstructorToArray {
 public:
diff --git a/core/variant/variant_setget.cpp b/core/variant/variant_setget.cpp
index 1652f81d9994..d53c7e214d2f 100644
--- a/core/variant/variant_setget.cpp
+++ b/core/variant/variant_setget.cpp
@@ -253,6 +253,13 @@ void Variant::set_named(const StringName &p_member, const Variant &p_value, bool
 	} else if (type == Variant::DICTIONARY) {
 		Dictionary &dict = *VariantGetInternalPtr<Dictionary>::get_ptr(this);
 		r_valid = dict.set(p_member, p_value);
+	} else if (type == Variant::ARRAY && is_struct()) {
+		Array &array = *VariantGetInternalPtr<Array>::get_ptr(this);
+		int index = array.find_member(p_member);
+		if (index >= 0) {
+			array.set(index, p_value);
+			r_valid = true;
+		}
 	} else {
 		r_valid = false;
 	}
@@ -288,6 +295,20 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 				return *v;
 			}
 		} break;
+		case Variant::ARRAY: {
+			const Array *array = VariantGetInternalPtr<Array>::get_ptr(this);
+			if (!array->get_struct_info()) {
+				if (Variant::has_builtin_method(type, p_member)) {
+					r_valid = true;
+					return Callable(memnew(VariantCallable(*this, p_member)));
+				}
+			}
+			const Variant *v = array->getptr(p_member);
+			if (v) {
+				r_valid = true;
+				return *v;
+			}
+		} break;
 		default: {
 			if (Variant::has_builtin_method(type, p_member)) {
 				r_valid = true;
@@ -1252,28 +1273,45 @@ Variant Variant::get(const Variant &p_index, bool *r_valid, VariantGetError *err
 }
 
 void Variant::get_property_list(List<PropertyInfo> *p_list) const {
-	if (type == DICTIONARY) {
-		const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
-		List<Variant> keys;
-		dic->get_key_list(&keys);
-		for (const Variant &E : keys) {
-			if (E.is_string()) {
-				p_list->push_back(PropertyInfo(dic->get_valid(E).get_type(), E));
+	switch (type) {
+		case DICTIONARY: {
+			const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
+			List<Variant> keys;
+			dic->get_key_list(&keys);
+			for (const Variant &E : keys) {
+				if (E.is_string()) {
+					p_list->push_back(PropertyInfo(dic->get_valid(E).get_type(), E));
+				}
 			}
+			break;
 		}
-	} else if (type == OBJECT) {
-		Object *obj = get_validated_object();
-		ERR_FAIL_NULL(obj);
-		obj->get_property_list(p_list);
-
-	} else {
-		List<StringName> members;
-		get_member_list(type, &members);
-		for (const StringName &E : members) {
-			PropertyInfo pi;
-			pi.name = E;
-			pi.type = get_member_type(type, E);
-			p_list->push_back(pi);
+		case OBJECT: {
+			Object *obj = get_validated_object();
+			ERR_FAIL_NULL(obj);
+			obj->get_property_list(p_list);
+			break;
+		}
+		case ARRAY: {
+			const Array *array = reinterpret_cast<const Array *>(_data._mem);
+			// if not struct, continue on to default case, otherwise...
+			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]));
+				}
+				break;
+			}
+			[[fallthrough]];
+		}
+		default: {
+			List<StringName> members;
+			get_member_list(type, &members);
+			for (const StringName &E : members) {
+				PropertyInfo pi;
+				pi.name = E;
+				pi.type = get_member_type(type, E);
+				p_list->push_back(pi);
+			}
 		}
 	}
 }
diff --git a/scene/resources/2d/tile_set.h b/scene/resources/2d/tile_set.h
index 15e1a16359e8..a2677a5beba8 100644
--- a/scene/resources/2d/tile_set.h
+++ b/scene/resources/2d/tile_set.h
@@ -152,8 +152,8 @@ class TileSet : public Resource {
 private:
 	struct CompatibilityShapeData {
 		Vector2i autotile_coords;
-		bool one_way;
-		float one_way_margin;
+		bool one_way = false; // TODO: I added these defaults to make the CI happy but I'm not sure if it will break anything
+		float one_way_margin = 1.0f;
 		Ref<Shape2D> shape;
 		Transform2D transform;
 	};
diff --git a/tests/core/variant/test_struct.h b/tests/core/variant/test_struct.h
new file mode 100644
index 000000000000..d7cf7c3a8a07
--- /dev/null
+++ b/tests/core/variant/test_struct.h
@@ -0,0 +1,395 @@
+/**************************************************************************/
+/*  test_struct.h                                                         */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef TEST_STRUCT_H
+#define TEST_STRUCT_H
+
+#include "core/variant/array.h"
+#include "core/variant/struct.h"
+#include "core/variant/struct_generator.h"
+#include "core/variant/variant.h"
+#include "scene/main/node.h"
+#include "tests/test_macros.h"
+#include "tests/test_tools.h"
+
+// TODO: methods to structify:
+/*
+ * ClassDB::class_get_signal_list()
+ * ClassDB::class_get_property_list()
+ * ClassDB::class_get_method_list()
+ * CodeEdit::_filter_code_completion_candidates()
+ * CodeEdit::get_code_completion_options()
+ * DisplayServer::tts_get_voices()
+ * EditorExportPlugin::_get_export_options()
+ * EditorImportPlugin::_get_import_options()
+ * ScriptLanguage::CodeCompletionOption
+ * ResourceImporter::ImportOption
+ * EditorVCSInterface::DiffLine
+ * EditorVCSInterface::DiffHunk
+ * EditorVCSInterface::DiffFile
+ * EditorVCSInterface::Commit
+ * EditorVCSInterface::StatusFile
+ * EditorVCSInterface::_get_modified_files_data()
+ * EditorVCSInterface::_get_diff()
+ * EditorVCSInterface::_get_previous_commits()
+ * EditorVCSInterface::_get_line_diff()
+ * EditorVCSInterface::add_diff_hunks_into_diff_file()
+ * EditorVCSInterface::add_line_diffs_into_diff_hunk()
+ * Engine::get_author_info()
+ * Engine::get_copyright_info()
+ * Engine::get_donor_info()
+ * Engine::get_version_info()
+ * Font::get_opentype_features()
+ * Font::get_ot_name_strings()
+ * Font::get_supported_variation_list()
+ * Font::find_variation()
+ * Font::get_opentype_feature_overrides()
+ * GLTFCamera::to_dictionary()
+ * GLTFCamera::from_dictionary()
+ * GLTFLight::to_dictionary()
+ * GLTFLight::from_dictionary()
+ * GLTFPhysicsBody::to_dictionary()
+ * GLTFPhysicsBody::from_dictionary()
+ * GLTFPhysicsShape::to_dictionary()
+ * GLTFPhysicsShape::from_dictionary()
+ * Geometry2D::make_atlas()
+ * GraphEdit::get_connection_list()
+ * Image::compute_image_metrics()
+ * Image::data
+ * IP::get_local_interfaces()
+ * LightmapGIData::probe_data
+ * NavigationAgent2D::waypoint_reached()
+ * NavigationAgent2D::link_reached()
+ * NavigationAgent3D::waypoint_reached()
+ * NavigationAgent3D::link_reached()
+ * Object::get_property_list()
+ * Object::get_method_list()
+ * Object::get_signal_list()
+ * Object::get_signal_connection_list()
+ * Object::get_incoming_connections()
+ * OS::get_memory_info()
+ * PhysicsDirectSpaceState2D::get_rest_info()
+ * PhysicsDirectSpaceState2D::intersect_point()
+ * PhysicsDirectSpaceState2D::intersect_ray()
+ * PhysicsDirectSpaceState2D::intersect_shape()
+ * PhysicsDirectSpaceState3D::get_rest_info()
+ * PhysicsDirectSpaceState3D::intersect_point()
+ * PhysicsDirectSpaceState3D::intersect_ray()
+ * PhysicsDirectSpaceState3D::intersect_shape()
+ * PolygonPathFinder::data
+ * ProjectSettings::add_property_info()
+ * ProjectSettings::get_global_class_list()
+ * RenderingServer::mesh_add_surface()
+ * RenderingServer::mesh_get_surface()
+ * RenderingServer::get_shader_parameter_list()
+ * RenderingServer::mesh_create_from_surfaces()
+ * RenderingServer::instance_geometry_get_shader_parameter_list()
+ * Script::get_script_property_list()
+ * Script::get_script_method_list()
+ * Script::get_script_signal_list()
+ * ScriptLanguage::_get_method_info()
+ * ScriptLanguageExtension::_validate()
+ * ScriptLanguageExtension::_complete_code()
+ * ScriptLanguageExtension::_lookup_code()
+ * ScriptLanguageExtension::_debug_get_current_stack_info()
+ * ScriptLanguageExtension::_get_public_functions()
+ * ScriptLanguageExtension::_get_public_annotations()
+ * ScriptLanguageExtension::_debug_get_stack_level_locals()
+ * ScriptLanguageExtension::_debug_get_stack_level_members()
+ * ScriptLanguageExtension::_debug_get_globals()
+ * ScriptLanguageExtension::_get_built_in_templates()
+ * ScriptLanguageExtension::_get_public_constants()
+ * ScriptLanguageExtension::_get_public_annotations()
+ * ScriptLanguageExtension::_get_global_class_name()
+ * ScriptExtension::_get_documentation()
+ * ScriptExtension::_get_script_signal_list()
+ * ScriptExtension::_get_script_method_list()
+ * ScriptExtension::_get_script_property_list()
+ * TextServer::font_set_variation_coordinates()
+ * TextServer::font_get_variation_coordinates()
+ * TextServer::font_get_glyph_contours()
+ * TextServer::font_set_opentype_feature_overrides()
+ * TextServer::font_get_opentype_feature_overrides()
+ * TextServer::font_supported_feature_list()
+ * TextServer::font_supported_variation_list()
+ * TextServer::shaped_text_add_string()
+ * TextServer::shaped_set_span_update_font()
+ * TextServer::shaped_text_get_carets()
+ * TextServer::shaped_text_get_glyphs()
+ * TextServer::shaped_text_sort_logical()
+ * TextServer::shaped_text_get_ellipsis_glyphs()
+ * TextServerExtension::_font_set_variation_coordinates()
+ * TextServerExtension::_font_get_variation_coordinates()
+ * TextServerExtension::_font_get_glyph_contours()
+ * TextServerExtension::_font_set_opentype_feature_overrides()
+ * TextServerExtension::_font_get_opentype_feature_overrides()
+ * TextServerExtension::_font_supported_feature_list()
+ * TextServerExtension::_font_supported_variation_list()
+ * TextServerExtension::_shaped_text_add_string()
+ * TextServerExtension::_shaped_set_span_update_font()
+ * TextServerManager::get_interfaces()
+ * Time::get_datetime_dict_from_unix_time()
+ * Time::get_date_dict_from_unix_time()
+ * Time::get_time_dict_from_unix_time()
+ * Time::get_datetime_dict_from_datetime_string()
+ * Time::get_datetime_string_from_datetime_dict()
+ * Time::get_unix_time_from_datetime_dict()
+ * Time::get_datetime_dict_from_system()
+ * Time::get_date_dict_from_system()
+ * Time::get_time_dict_from_system()
+ * Time::get_time_zone_from_system()
+ * Tree::get_range_config()
+ * VisualShader::get_node_connections()
+ * WebRTCMultiplayerPeer::get_peer()
+ * WebRTCMultiplayerPeer::get_peers()
+ * WebRTCPeerConnection::initialize()
+ * WebRTCPeerConnection::create_data_channel()
+ * WebRTCPeerConnectionExtension::_initialize()
+ * WebRTCPeerConnectionExtension::_create_data_channel()
+ * XRInterface::get_system_info()
+ * XRInterfaceExtension::_get_system_info()
+ * XRServer::get_interfaces()
+ * XRServer::get_trackers()
+ *
+ *
+ * */
+
+namespace TestStruct {
+
+//TEST_CASE("[Struct] PropertyInfo") {
+//	Node *my_node = memnew(Node);
+//
+//	List<PropertyInfo> list;
+//	my_node->get_property_list(&list);
+//	PropertyInfo info = list.get(0);
+//
+//	TypedArray<Struct<PropertyInfo>> property_list = my_node->call(SNAME("get_property_list_as_structs"));
+//	Struct<PropertyInfo> prop = property_list[0];
+//
+//	SUBCASE("Equality") {
+//		CHECK_EQ(info.name, prop.get_member<struct PropertyInfo::name>());
+//		CHECK_EQ(info.class_name, prop.get_member<struct PropertyInfo::class_name>());
+//		CHECK_EQ(info.type, prop.get_member<struct PropertyInfo::type>());
+//		CHECK_EQ(info.hint, prop.get_member<struct PropertyInfo::hint>());
+//		CHECK_EQ(info.hint_string, prop.get_member<struct PropertyInfo::hint_string>());
+//		CHECK_EQ(info.usage, prop.get_member<struct PropertyInfo::usage>());
+//	}
+//
+//	SUBCASE("Duplication") {
+//		Variant var = prop;
+//		CHECK_EQ(var.get_type(), Variant::ARRAY);
+//		Variant var_dup = prop.duplicate();
+//		CHECK_EQ(var_dup.get_type(), Variant::ARRAY);
+//		CHECK_EQ(var, var_dup);
+//	}
+//
+//	SUBCASE("Setget Named") {
+//		Variant variant_prop = prop;
+//		bool valid = false;
+//		variant_prop.set_named(SNAME("name"), SNAME("Changed"), valid);
+//		CHECK_EQ(valid, true);
+//		Variant val = variant_prop.get_named(SNAME("name"), valid);
+//		CHECK_EQ(valid, true);
+//		CHECK_EQ((StringName)val, SNAME("Changed"));
+//
+//		val = variant_prop.get_named(SNAME("oops"), valid);
+//		CHECK_EQ(valid, false);
+//		CHECK_EQ(val, Variant());
+//
+//		variant_prop.set_named(SNAME("oops"), SNAME("oh no"), valid);
+//		CHECK_EQ(valid, false);
+//	}
+//	memdelete(my_node);
+//}
+
+TEST_CASE("[Struct] Validation") {
+	struct NamedInt {
+		STRUCT_DECLARE(NamedInt);
+		STRUCT_MEMBER_PRIMITIVE(String, name, String());
+		STRUCT_MEMBER_PRIMITIVE(int, value, 0);
+		STRUCT_LAYOUT(NamedInt, struct name, struct value);
+	};
+
+	Struct<NamedInt> named_int;
+	named_int["name"] = "Godot";
+	named_int["value"] = 4;
+	CHECK_EQ(((Variant)named_int).stringify(), "[name: \"Godot\", value: 4]");
+
+	SUBCASE("Self Equal") {
+		CHECK(named_int.is_same_typed(named_int));
+		Variant variant_named_int = named_int;
+		CHECK(named_int.is_same_typed(variant_named_int));
+		Struct<NamedInt> same_named_int = variant_named_int;
+		CHECK_EQ(named_int, same_named_int);
+	}
+
+	SUBCASE("Assignment") {
+		Struct<NamedInt> a_match = named_int;
+		CHECK_EQ(named_int, a_match);
+		Array not_a_match;
+
+		ERR_PRINT_OFF;
+		named_int.set_named("name", 4);
+		CHECK_MESSAGE(named_int["name"] == "Godot", "assigned an int to a string member");
+
+		named_int.set_named("value", "Godot");
+		CHECK_MESSAGE((int)named_int["value"] == 4, "assigned a string to an int member");
+
+		named_int = not_a_match;
+		CHECK_MESSAGE(named_int != not_a_match, "assigned an empty array to a struct");
+
+		not_a_match.resize(2);
+		named_int.assign(not_a_match);
+		CHECK_MESSAGE(named_int != not_a_match, "assigned an array with the wrong size");
+
+		not_a_match[0] = 4;
+		not_a_match[1] = "Godot";
+		named_int.assign(not_a_match);
+		CHECK_MESSAGE(named_int != not_a_match, "assigned an array with mismatched types");
+
+		Array also_a_match;
+		also_a_match.resize(2);
+		also_a_match[0] = "Godooot";
+		also_a_match[1] = 5;
+		named_int = not_a_match;
+		CHECK_MESSAGE(named_int != not_a_match, "assigned a non-struct to a struct using '=' operator");
+		ERR_PRINT_ON;
+
+		named_int.assign(also_a_match);
+		CHECK_MESSAGE(named_int == also_a_match, "failed to assign an array with correct types using 'assign' function");
+	}
+}
+
+TEST_CASE("[Struct] Nesting") {
+	struct BasicStruct {
+		STRUCT_DECLARE(BasicStruct);
+		STRUCT_MEMBER_PRIMITIVE(int, int_val, 4);
+		STRUCT_MEMBER_PRIMITIVE(float, float_val, 5.5f);
+		STRUCT_LAYOUT(BasicStruct, struct int_val, struct float_val);
+		BasicStruct() {};
+	};
+	struct BasicStructLookalike {
+		STRUCT_DECLARE(BasicStructLookalike);
+		STRUCT_MEMBER_PRIMITIVE(int, int_val, 4);
+		STRUCT_MEMBER_PRIMITIVE(float, float_val, 5.5f);
+		STRUCT_LAYOUT(BasicStructLookalike, struct int_val, struct float_val);
+	};
+	struct NestedStruct {
+		STRUCT_DECLARE(NestedStruct);
+		STRUCT_MEMBER_CLASS_POINTER(Node, node, nullptr);
+		STRUCT_MEMBER_STRUCT(BasicStruct, value, BasicStruct());
+		STRUCT_LAYOUT(NestedStruct, struct node, struct value);
+	};
+
+	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;
+	Struct<NestedStruct> nested_struct;
+
+	SUBCASE("Defaults") {
+		CHECK_EQ(basic_struct.get_member<struct BasicStruct::int_val>(), 4);
+		CHECK_EQ(basic_struct.get_member<struct BasicStruct::float_val>(), 5.5);
+
+		CHECK_EQ(nested_struct.get_member<struct NestedStruct::node>(), nullptr);
+		CHECK_EQ(Struct<BasicStruct>(nested_struct.get_member<struct NestedStruct::value>()), basic_struct);
+	}
+
+	SUBCASE("Assignment") {
+		basic_struct.set_member<struct BasicStruct::int_val>(1);
+		basic_struct.set_member<struct BasicStruct::float_val>(3.14);
+
+		basic_struct_lookalike.set_member<struct BasicStructLookalike::int_val>(2);
+		basic_struct_lookalike.set_member<struct BasicStructLookalike::float_val>(2.7);
+
+		Node *node = memnew(Node);
+		nested_struct.set_member<struct NestedStruct::node>(node);
+		nested_struct.set_member<struct NestedStruct::value>(basic_struct);
+
+		CHECK_EQ(nested_struct.get_member<struct NestedStruct::node>(), node);
+		Struct<BasicStruct> basic_struct_match = nested_struct.get_member<struct NestedStruct::value>();
+		CHECK_EQ(basic_struct_match, basic_struct);
+		CHECK_EQ(basic_struct_match.get_member<struct BasicStruct::int_val>(), basic_struct.get_member<struct BasicStruct::int_val>());
+		CHECK_EQ(basic_struct_match.get_member<struct BasicStruct::float_val>(), basic_struct.get_member<struct BasicStruct::float_val>());
+
+		ERR_PRINT_OFF;
+		nested_struct.set_named("value", basic_struct_lookalike);
+		CHECK_EQ(nested_struct["value"], basic_struct);
+		ERR_PRINT_ON;
+
+		memdelete(node);
+	}
+
+	SUBCASE("Typed Array of Struct") {
+		TypedArray<Struct<BasicStruct>> array;
+		Struct<BasicStruct> basic_struct_0;
+		basic_struct_0["int_val"] = 1;
+		basic_struct_0["float_val"] = 3.14;
+		Struct<BasicStruct> basic_struct_1;
+		basic_struct_1["int_val"] = 2;
+		basic_struct_1["float_val"] = 2.7;
+		array.push_back(basic_struct_0);
+		array.push_back(basic_struct_1);
+		CHECK_EQ(array[0], basic_struct_0);
+		CHECK_EQ(array[1], basic_struct_1);
+
+		ERR_PRINT_OFF;
+		array.push_back(0);
+		CHECK_EQ(array.size(), 2);
+
+		basic_struct_lookalike["int_val"] = 3;
+		basic_struct_lookalike["float_val"] = 5.4;
+		array.push_back(basic_struct_lookalike);
+		CHECK_EQ(array.size(), 2);
+		ERR_PRINT_ON;
+
+		TypedArray<Struct<BasicStruct>> array_of_defaults;
+		array_of_defaults.resize(2);
+		CHECK_EQ(array_of_defaults[0], Variant(Struct<BasicStruct>()));
+		CHECK_EQ(array_of_defaults[1], Variant(Struct<BasicStruct>()));
+	}
+}
+
+TEST_CASE("[Struct] ClassDB") {
+	const StructInfo *struct_info = ::ClassDB::get_struct_info(SNAME("Object"), SNAME("PropertyInfo"));
+	REQUIRE(struct_info);
+	CHECK_EQ(struct_info->count, 6);
+	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((int)struct_info->default_values[3], PROPERTY_HINT_NONE);
+}
+
+} // namespace TestStruct
+
+#endif // TEST_STRUCT_H
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index 12ff3ad4bc9e..fdbe7482646a 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -100,6 +100,7 @@
 #include "tests/core/variant/test_array.h"
 #include "tests/core/variant/test_callable.h"
 #include "tests/core/variant/test_dictionary.h"
+#include "tests/core/variant/test_struct.h"
 #include "tests/core/variant/test_variant.h"
 #include "tests/core/variant/test_variant_utility.h"
 #include "tests/scene/test_animation.h"

From 35d7383f337b514aa6659ab802fc5bbdb61d2432 Mon Sep 17 00:00:00 2001
From: nlupugla <lupu.gladstein@gmail.com>
Date: Mon, 8 Apr 2024 19:08:29 -0400
Subject: [PATCH 2/2] Added Structs to GDScript

---
 core/object/script_language.h                 |    1 +
 core/object/script_language_extension.cpp     |    1 +
 doc/classes/CodeEdit.xml                      |    2 +
 doc/classes/ScriptLanguageExtension.xml       |    4 +-
 modules/gdscript/editor/gdscript_docgen.cpp   |   12 +
 modules/gdscript/gdscript.cpp                 |   32 +
 modules/gdscript/gdscript.h                   |    3 +
 modules/gdscript/gdscript_analyzer.cpp        | 1356 ++++++++++-------
 modules/gdscript/gdscript_analyzer.h          |   35 +-
 modules/gdscript/gdscript_byte_codegen.cpp    |   17 +-
 modules/gdscript/gdscript_byte_codegen.h      |    5 +
 modules/gdscript/gdscript_codegen.h           |    1 +
 modules/gdscript/gdscript_compiler.cpp        |  166 +-
 modules/gdscript/gdscript_compiler.h          |    3 +
 modules/gdscript/gdscript_disassembler.cpp    |    3 +
 modules/gdscript/gdscript_editor.cpp          |   53 +-
 modules/gdscript/gdscript_function.cpp        |   10 +
 modules/gdscript/gdscript_function.h          |    8 +-
 modules/gdscript/gdscript_parser.cpp          |  127 +-
 modules/gdscript/gdscript_parser.h            |   57 +-
 modules/gdscript/gdscript_tokenizer.cpp       |    3 +
 modules/gdscript/gdscript_tokenizer.h         |    1 +
 modules/gdscript/gdscript_vm.cpp              |  104 +-
 .../gdscript_extend_parser.cpp                |  184 ++-
 .../language_server/gdscript_extend_parser.h  |    4 +-
 modules/gdscript/language_server/godot_lsp.h  |    4 +
 .../scripts/parser/errors/struct_no_body.gd   |    5 +
 .../scripts/parser/errors/struct_no_body.out  |    2 +
 .../scripts/parser/errors/struct_no_colon.gd  |    5 +
 .../scripts/parser/errors/struct_no_colon.out |    2 +
 .../parser/errors/struct_no_identifier.gd     |    5 +
 .../parser/errors/struct_no_identifier.out    |    2 +
 .../scripts/parser/errors/struct_no_var.gd    |    5 +
 .../scripts/parser/errors/struct_no_var.out   |    2 +
 .../tests/scripts/parser/features/struct.gd   |   11 +
 .../tests/scripts/parser/features/struct.out  |    2 +
 .../runtime/features/struct_constructor.gd    |   16 +
 .../runtime/features/struct_constructor.out   |    8 +
 .../scripts/runtime/features/struct_native.gd |    8 +
 .../runtime/features/struct_native.out        |    4 +
 scene/gui/code_edit.cpp                       |    1 +
 scene/gui/code_edit.h                         |    1 +
 42 files changed, 1571 insertions(+), 704 deletions(-)
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_body.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_body.out
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_colon.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_colon.out
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.out
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_var.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/struct_no_var.out
 create mode 100644 modules/gdscript/tests/scripts/parser/features/struct.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/features/struct.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/struct_constructor.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/struct_constructor.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/struct_native.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/struct_native.out

diff --git a/core/object/script_language.h b/core/object/script_language.h
index 3ddfbb3e7d35..d0e7fbf23d2c 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -296,6 +296,7 @@ class ScriptLanguage : public Object {
 		CODE_COMPLETION_KIND_NODE_PATH,
 		CODE_COMPLETION_KIND_FILE_PATH,
 		CODE_COMPLETION_KIND_PLAIN_TEXT,
+		CODE_COMPLETION_KIND_STRUCT,
 		CODE_COMPLETION_KIND_MAX
 	};
 
diff --git a/core/object/script_language_extension.cpp b/core/object/script_language_extension.cpp
index 73f7ec5a5444..9dcf66083e0d 100644
--- a/core/object/script_language_extension.cpp
+++ b/core/object/script_language_extension.cpp
@@ -188,5 +188,6 @@ void ScriptLanguageExtension::_bind_methods() {
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_NODE_PATH);
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_FILE_PATH);
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_PLAIN_TEXT);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_STRUCT);
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MAX);
 }
diff --git a/doc/classes/CodeEdit.xml b/doc/classes/CodeEdit.xml
index 136b8e5fc5d8..9c85f0039004 100644
--- a/doc/classes/CodeEdit.xml
+++ b/doc/classes/CodeEdit.xml
@@ -647,6 +647,8 @@
 		<constant name="KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind">
 			Marks the option as unclassified or plain text.
 		</constant>
+		<constant name="KIND_STRUCT" value="10" enum="CodeCompletionKind">
+		</constant>
 		<constant name="LOCATION_LOCAL" value="0" enum="CodeCompletionLocation">
 			The option is local to the location of the code completion query - e.g. a local variable. Subsequent value of location represent options from the outer class, the exact value represent how far they are (in terms of inner classes).
 		</constant>
diff --git a/doc/classes/ScriptLanguageExtension.xml b/doc/classes/ScriptLanguageExtension.xml
index f9d9e4f513e1..b8186a38b2d9 100644
--- a/doc/classes/ScriptLanguageExtension.xml
+++ b/doc/classes/ScriptLanguageExtension.xml
@@ -425,7 +425,9 @@
 		</constant>
 		<constant name="CODE_COMPLETION_KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_MAX" value="10" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_STRUCT" value="10" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_MAX" value="11" enum="CodeCompletionKind">
 		</constant>
 	</constants>
 </class>
diff --git a/modules/gdscript/editor/gdscript_docgen.cpp b/modules/gdscript/editor/gdscript_docgen.cpp
index 32ef429b0d47..f9b8c51ea395 100644
--- a/modules/gdscript/editor/gdscript_docgen.cpp
+++ b/modules/gdscript/editor/gdscript_docgen.cpp
@@ -146,6 +146,18 @@ void GDScriptDocGen::_doctype_from_gdtype(const GDType &p_gdtype, String &r_type
 				}
 			}
 			return;
+		case GDType::STRUCT:
+			r_type = "Array";
+			// TODO: just copied from enum for now, probably needs Struct specific logic
+			r_enum = String(p_gdtype.native_type).replace("::", ".");
+			if (r_enum.begins_with("res://")) {
+				r_enum = r_enum.trim_prefix("res://");
+				int dot_pos = r_enum.rfind(".");
+				if (dot_pos >= 0) {
+					r_enum = r_enum.left(dot_pos).quote() + r_enum.substr(dot_pos);
+				}
+			}
+			return;
 		case GDType::VARIANT:
 		case GDType::RESOLVING:
 		case GDType::UNRESOLVED:
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 7b9aa70686a7..d23ae4e9acda 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -1236,6 +1236,33 @@ GDScript *GDScript::get_root_script() {
 	return result;
 }
 
+const StructInfo *GDScript::get_script_struct_info(const String &p_struct_name, bool p_no_inheritance) const {
+	if (const StructInfo *info = structs.getptr(p_struct_name)) {
+		return info;
+	}
+
+	Vector<String> names = String(p_struct_name).split(".");
+	// TODO: this is to handle cases where the name is something like U"res://main.gd.MyStruct" but there should probably be a better solution
+	const StructInfo *info = structs.getptr(names[names.size() - 1]);
+	if (p_no_inheritance) {
+		return info;
+	}
+	// TODO: walk through inheritance chain to look for struct info.
+	return info;
+}
+
+void GDScript::set_script_struct_info(const StructInfo &p_struct_info) {
+	if (ClassDB::get_struct_info(p_struct_info.name)) {
+		// TODO: warn about shadowing native struct?
+		return;
+	}
+	if (structs.has(p_struct_info.name)) {
+		// TODO: warn about shadowing script struct?
+		return;
+	}
+	structs.insert(p_struct_info.name, p_struct_info);
+}
+
 RBSet<GDScript *> GDScript::get_dependencies() {
 	RBSet<GDScript *> dependencies;
 
@@ -1361,6 +1388,7 @@ void GDScript::_collect_function_dependencies(GDScriptFunction *p_func, RBSet<GD
 }
 
 void GDScript::_collect_dependencies(RBSet<GDScript *> &p_dependencies, const GDScript *p_except) {
+	// TODO: Do I need Struct logic here?
 	if (p_dependencies.has(this)) {
 		return;
 	}
@@ -1410,6 +1438,7 @@ GDScript::GDScript() :
 }
 
 void GDScript::_save_orphaned_subclasses(ClearData *p_clear_data) {
+	// TODO: Do I need Struct logic here?
 	struct ClassRefWithName {
 		ObjectID id;
 		String fully_qualified_name;
@@ -2253,6 +2282,8 @@ void GDScriptLanguage::init() {
 		_add_global(n, nc);
 	}
 
+	// TODO: Structs?
+
 	//populate singletons
 
 	List<Engine::Singleton> singletons;
@@ -2741,6 +2772,7 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
 		"namespace", // Reserved for potential future use.
 		"signal",
 		"static",
+		"struct",
 		"trait", // Reserved for potential future use.
 		"var",
 		// Other keywords.
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index 9bb39aac0f7e..da62d3515663 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -107,6 +107,7 @@ class GDScript : public Script {
 	HashMap<StringName, Variant> constants;
 	HashMap<StringName, GDScriptFunction *> member_functions;
 	HashMap<StringName, Ref<GDScript>> subclasses;
+	HashMap<StringName, StructInfo> structs;
 	HashMap<StringName, MethodInfo> _signals;
 	Dictionary rpc_config;
 
@@ -259,6 +260,8 @@ class GDScript : public Script {
 	}
 	const HashMap<StringName, GDScriptFunction *> &get_member_functions() const { return member_functions; }
 	const Ref<GDScriptNativeClass> &get_native() const { return native; }
+	const StructInfo *get_script_struct_info(const String &p_struct_name, bool p_no_inheritance = false) const;
+	void set_script_struct_info(const StructInfo &p_struct_info);
 
 	RBSet<GDScript *> get_dependencies();
 	HashMap<GDScript *, RBSet<GDScript *>> get_all_dependencies();
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 7f0d5005cb0f..d77b1aa1b92d 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -51,6 +51,7 @@
 
 #define UNNAMED_ENUM "<anonymous enum>"
 #define ENUM_SEPARATOR "."
+#define STRUCT_SEPARATOR "."
 
 static MethodInfo info_from_utility_func(const StringName &p_function) {
 	ERR_FAIL_COND_V(!Variant::has_utility_function(p_function), MethodInfo());
@@ -199,25 +200,44 @@ static GDScriptParser::DataType make_builtin_meta_type(Variant::Type p_type) {
 	return type;
 }
 
+// In struct types, native_type is used to store the class (native or otherwise) that the struct belongs to.
+// This disambiguates between similarly named structs in base classes or outer classes
+static GDScriptParser::DataType make_struct_type(const StringName &p_struct_name, const String &p_base_name, const bool p_meta = false) {
+	GDScriptParser::DataType type;
+	type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	type.kind = GDScriptParser::DataType::STRUCT;
+	type.builtin_type = Variant::ARRAY;
+	type.is_constant = p_meta; // TODO: not sure about this
+	type.is_meta_type = p_meta;
+
+	if (p_base_name.is_empty()) {
+		type.native_type = p_struct_name;
+	} else {
+		type.native_type = p_base_name + STRUCT_SEPARATOR + p_struct_name;
+	}
+	return type;
+}
+
 bool GDScriptAnalyzer::has_member_name_conflict_in_script_class(const StringName &p_member_name, const GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_member) {
-	if (p_class->members_indices.has(p_member_name)) {
-		int index = p_class->members_indices[p_member_name];
-		const GDScriptParser::ClassNode::Member *member = &p_class->members[index];
-
-		if (member->type == GDScriptParser::ClassNode::Member::VARIABLE ||
-				member->type == GDScriptParser::ClassNode::Member::CONSTANT ||
-				member->type == GDScriptParser::ClassNode::Member::ENUM ||
-				member->type == GDScriptParser::ClassNode::Member::ENUM_VALUE ||
-				member->type == GDScriptParser::ClassNode::Member::CLASS ||
-				member->type == GDScriptParser::ClassNode::Member::SIGNAL) {
-			return true;
-		}
-		if (p_member->type != GDScriptParser::Node::FUNCTION && member->type == GDScriptParser::ClassNode::Member::FUNCTION) {
+	const int *index = p_class->members_indices.getptr(p_member_name);
+	if (!index) {
+		return false;
+	}
+	const GDScriptParser::ClassNode::Member *member = &p_class->members[*index];
+	switch (member->type) {
+		case GDScriptParser::ClassNode::Member::VARIABLE:
+		case GDScriptParser::ClassNode::Member::CONSTANT:
+		case GDScriptParser::ClassNode::Member::ENUM:
+		case GDScriptParser::ClassNode::Member::ENUM_VALUE:
+		case GDScriptParser::ClassNode::Member::CLASS:
+		case GDScriptParser::ClassNode::Member::SIGNAL:
+		case GDScriptParser::ClassNode::Member::STRUCT:
 			return true;
-		}
+		case GDScriptParser::ClassNode::Member::FUNCTION:
+			return p_member->type != GDScriptParser::Node::FUNCTION;
+		default:
+			return false;
 	}
-
-	return false;
 }
 
 bool GDScriptAnalyzer::has_member_name_conflict_in_native_type(const StringName &p_member_name, const StringName &p_native_type_string) {
@@ -233,7 +253,9 @@ bool GDScriptAnalyzer::has_member_name_conflict_in_native_type(const StringName
 	if (p_member_name == CoreStringName(script)) {
 		return true;
 	}
-
+	if (const StructInfo *info = ClassDB::get_struct_info(p_native_type_string)) {
+		return info->names.has(p_member_name);
+	}
 	return false;
 }
 
@@ -248,6 +270,11 @@ Error GDScriptAnalyzer::check_native_member_name_conflict(const StringName &p_me
 		return ERR_PARSE_ERROR;
 	}
 
+	if (ClassDB::get_struct_info(p_member_name)) {
+		push_error(vformat(R"(The member "%s" shadows a native struct.)", p_member_name), p_member_node);
+		return ERR_PARSE_ERROR;
+	}
+
 	if (GDScriptParser::get_builtin_type(p_member_name) < Variant::VARIANT_MAX) {
 		push_error(vformat(R"(The member "%s" cannot have the same name as a builtin type.)", p_member_name), p_member_node);
 		return ERR_PARSE_ERROR;
@@ -718,6 +745,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 			result.builtin_type = GDScriptParser::get_builtin_type(first);
 
 			if (result.builtin_type == Variant::ARRAY) {
+				// TODO: Struct logic here?
 				GDScriptParser::DataType container_type = type_from_metatype(resolve_datatype(p_type->get_container_type_or_null(0)));
 				if (container_type.kind != GDScriptParser::DataType::VARIANT) {
 					container_type.is_constant = false;
@@ -798,6 +826,10 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				return bad_type;
 			}
 			result = make_global_enum_type(first, StringName());
+		} else if (const StructInfo *info = ClassDB::get_struct_info(parser->current_class->base_type.native_type, first)) {
+			result.kind = GDScriptParser::DataType::STRUCT;
+			result.builtin_type = Variant::ARRAY;
+			result.native_type = info->name;
 		} else {
 			// Classes in current scope.
 			List<GDScriptParser::ClassNode *> script_classes;
@@ -818,10 +850,8 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 					GDScriptParser::ClassNode::Member member = script_class->get_member(first);
 					switch (member.type) {
 						case GDScriptParser::ClassNode::Member::CLASS:
-							result = member.get_datatype();
-							found = true;
-							break;
 						case GDScriptParser::ClassNode::Member::ENUM:
+						case GDScriptParser::ClassNode::Member::STRUCT:
 							result = member.get_datatype();
 							found = true;
 							break;
@@ -1203,6 +1233,33 @@ void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class,
 					resolve_class_inheritance(member.m_class, p_source);
 				}
 				break;
+			case GDScriptParser::ClassNode::Member::STRUCT: {
+				check_class_member_name_conflict(p_class, member.m_struct->identifier->name, member.m_struct);
+				member.m_struct->set_datatype(resolving_datatype);
+				GDScriptParser::DataType struct_type = make_struct_type(member.m_struct->identifier->name, p_class->fqcn, false);
+				struct_type.struct_type = member.m_struct;
+				//				struct_type.script_type = p_class->get_datatype().script_type;
+				//				struct_type.script_path = p_class->get_datatype().script_path;
+				member.m_struct->set_datatype(struct_type);
+
+				// Resolve each struct member
+				for (int i = 0; i < member.m_struct->members.size(); i++) {
+					GDScriptParser::VariableNode *struct_member = member.m_struct->members[i];
+
+					check_class_member_name_conflict(p_class, struct_member->identifier->name, struct_member);
+
+					struct_member->set_datatype(resolving_datatype);
+					resolve_struct_member(struct_member);
+					resolve_pending_lambda_bodies(); // TODO: not sure if needed
+#ifdef DEBUG_ENABLED
+					if (struct_member->initializer && !struct_member->initializer->is_constant) {
+						push_error("Struct member defaults must be constant.", struct_member); // TODO: better error message
+					}
+#endif
+				}
+
+				// TODO: need to handle nested structs
+			} break;
 			case GDScriptParser::ClassNode::Member::GROUP:
 				// No-op, but needed to silence warnings.
 				break;
@@ -1574,6 +1631,7 @@ void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root
 		case GDScriptParser::Node::BREAKPOINT:
 		case GDScriptParser::Node::CONTINUE:
 		case GDScriptParser::Node::ENUM:
+		case GDScriptParser::Node::STRUCT:
 		case GDScriptParser::Node::FUNCTION:
 		case GDScriptParser::Node::PASS:
 		case GDScriptParser::Node::SIGNAL:
@@ -1913,7 +1971,7 @@ void GDScriptAnalyzer::resolve_suite(GDScriptParser::SuiteNode *p_suite) {
 	}
 }
 
-void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind) {
+void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind, bool p_require_constant) {
 	GDScriptParser::DataType type;
 	type.kind = GDScriptParser::DataType::VARIANT;
 
@@ -1950,7 +2008,7 @@ void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assi
 			}
 		}
 
-		if (is_constant && !p_assignable->initializer->is_constant) {
+		if ((is_constant || p_require_constant) && !p_assignable->initializer->is_constant) {
 			bool is_initializer_value_reduced = false;
 			Variant initializer_value = make_expression_reduced_value(p_assignable->initializer, is_initializer_value_reduced);
 			if (is_initializer_value_reduced) {
@@ -2081,6 +2139,11 @@ void GDScriptAnalyzer::resolve_constant(GDScriptParser::ConstantNode *p_constant
 #endif
 }
 
+void GDScriptAnalyzer::resolve_struct_member(GDScriptParser::VariableNode *p_member) {
+	static constexpr const char *kind = "struct member";
+	resolve_assignable(p_member, kind, true);
+}
+
 void GDScriptAnalyzer::resolve_parameter(GDScriptParser::ParameterNode *p_parameter) {
 	static constexpr const char *kind = "parameter";
 	resolve_assignable(p_parameter, kind);
@@ -2572,6 +2635,7 @@ void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expre
 		case GDScriptParser::Node::CONSTANT:
 		case GDScriptParser::Node::CONTINUE:
 		case GDScriptParser::Node::ENUM:
+		case GDScriptParser::Node::STRUCT:
 		case GDScriptParser::Node::FOR:
 		case GDScriptParser::Node::FUNCTION:
 		case GDScriptParser::Node::IF:
@@ -2629,7 +2693,7 @@ void GDScriptAnalyzer::update_const_expression_builtin_type(GDScriptParser::Expr
 	if (p_expression->get_datatype() == p_type) {
 		return;
 	}
-	if (p_type.kind != GDScriptParser::DataType::BUILTIN && p_type.kind != GDScriptParser::DataType::ENUM) {
+	if (p_type.kind != GDScriptParser::DataType::BUILTIN && p_type.kind != GDScriptParser::DataType::ENUM && p_type.kind != GDScriptParser::DataType::STRUCT) {
 		return;
 	}
 
@@ -2832,7 +2896,7 @@ void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assig
 		while (sub) {
 			const GDScriptParser::DataType &base_type = sub->base->datatype;
 			if (base_type.is_hard_type() && base_type.is_read_only) {
-				if (base_type.kind == GDScriptParser::DataType::BUILTIN && !Variant::is_type_shared(base_type.builtin_type)) {
+				if ((base_type.kind == GDScriptParser::DataType::BUILTIN || base_type.kind == GDScriptParser::DataType::STRUCT) && !Variant::is_type_shared(base_type.builtin_type)) {
 					push_error("Cannot assign a new value to a read-only property.", p_assignment->assignee);
 					return;
 				}
@@ -3452,6 +3516,11 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a
 			}
 			p_call->set_datatype(type_from_property(function_info.return_val));
 			return;
+		} else if (const StructInfo *native_struct_info = ClassDB::get_struct_info(parser->current_class->base_type.native_type, function_name)) {
+			validate_call_arg(*native_struct_info, p_call);
+			p_call->set_datatype(type_from_struct_info(*native_struct_info));
+			p_call->is_static = true;
+			return;
 		}
 	}
 
@@ -3636,14 +3705,14 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a
 						push_error(vformat(R"*(Name "%s" called as a function but is a "%s".)*", p_call->function_name, callee_datatype.to_string()), p_call->callee);
 					}
 #ifdef DEBUG_ENABLED
-				} else if (!is_self && !(base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN)) {
+				} else if (!is_self && !(base_type.is_hard_type() && (base_type.kind == GDScriptParser::DataType::BUILTIN || base_type.kind == GDScriptParser::DataType::STRUCT))) {
 					parser->push_warning(p_call, GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->function_name, base_type.to_string());
 					mark_node_unsafe(p_call);
 #endif
 				}
 			}
 		}
-		if (!found && (is_self || (base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN))) {
+		if (!found && (is_self || (base_type.is_hard_type() && (base_type.kind == GDScriptParser::DataType::BUILTIN || base_type.kind == GDScriptParser::DataType::STRUCT)))) {
 			String base_name = is_self && !p_call->is_super ? "self" : base_type.to_string();
 #ifdef SUGGEST_GODOT4_RENAMES
 			String rename_hint;
@@ -3706,6 +3775,7 @@ void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
 #endif
 		} else {
 			bool valid = false;
+			// TODO: should I mark Struct <-> Array as unsafe?
 			if (op_type.builtin_type == Variant::INT && cast_type.kind == GDScriptParser::DataType::ENUM) {
 				mark_node_unsafe(p_cast);
 				valid = true;
@@ -3903,7 +3973,7 @@ Ref<GDScriptParserRef> GDScriptAnalyzer::find_cached_external_parser_for_class(c
 	return nullptr;
 }
 
-Ref<GDScript> GDScriptAnalyzer::get_depended_shallow_script(const String &p_path, Error &r_error) {
+Ref<GDScript> GDScriptAnalyzer::get_depended_shallow_script(const String &p_path, Error &r_error) const {
 	// To keep a local cache of the parser for resolving external nodes later.
 	parser->get_depended_parser_for(p_path);
 	Ref<GDScript> scr = GDScriptCache::get_shallow_script(p_path, r_error, parser->script_path);
@@ -3938,46 +4008,70 @@ void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNod
 
 	StringName name = p_identifier->name;
 
-	if (base.kind == GDScriptParser::DataType::ENUM) {
-		if (base.is_meta_type) {
-			if (base.enum_values.has(name)) {
-				p_identifier->set_datatype(type_from_metatype(base));
-				p_identifier->is_constant = true;
-				p_identifier->reduced_value = base.enum_values[name];
+	switch (base.kind) {
+		case GDScriptParser::DataType::ENUM: {
+			if (base.is_meta_type) {
+				if (base.enum_values.has(name)) {
+					p_identifier->set_datatype(type_from_metatype(base));
+					p_identifier->is_constant = true;
+					p_identifier->reduced_value = base.enum_values[name];
+					return;
+				}
+
+				// Enum does not have this value, return.
+				return;
+			} else {
+				push_error(R"(Cannot get property from enum value.)", p_identifier);
 				return;
 			}
-
-			// Enum does not have this value, return.
-			return;
-		} else {
-			push_error(R"(Cannot get property from enum value.)", p_identifier);
+		}
+		case GDScriptParser::DataType::STRUCT: {
+			if (const GDScriptParser::StructNode *struct_node = base.struct_type) { // User-defined struct
+				// TODO: is linear search okay here?
+				for (int i = 0; i < struct_node->members.size(); i++) {
+					if (struct_node->members[i]->identifier->name == name) {
+						GDScriptParser::DataType member_type = struct_node->members[i]->get_datatype();
+						p_identifier->set_datatype(member_type);
+						return;
+					}
+				}
+			}
+			if (const StructInfo *info = ClassDB::get_struct_info(base.native_type)) { // Native struct
+				// TODO: is linear search okay here?
+				for (int i = 0; i < info->count; i++) {
+					if (info->names[i] == name) {
+						p_identifier->set_datatype(type_from_struct_member(*info, i));
+						return;
+					}
+				}
+			}
+			push_error(vformat(R"(Cannot find property "%s" on struct "%s")", name, base.to_string()), p_identifier);
 			return;
 		}
-	}
-
-	if (base.kind == GDScriptParser::DataType::BUILTIN) {
-		if (base.is_meta_type) {
-			bool valid = true;
-			Variant result = Variant::get_constant_value(base.builtin_type, name, &valid);
-			if (valid) {
-				p_identifier->is_constant = true;
-				p_identifier->reduced_value = result;
-				p_identifier->set_datatype(type_from_variant(result, p_identifier));
-			} else if (base.is_hard_type()) {
+		case GDScriptParser::DataType::BUILTIN: {
+			if (base.is_meta_type) {
+				bool valid = true;
+				Variant result = Variant::get_constant_value(base.builtin_type, name, &valid);
+				if (valid) {
+					p_identifier->is_constant = true;
+					p_identifier->reduced_value = result;
+					p_identifier->set_datatype(type_from_variant(result, p_identifier));
+				} else if (base.is_hard_type()) {
 #ifdef SUGGEST_GODOT4_RENAMES
-				String rename_hint;
-				if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
-					const char *renamed_identifier_name = check_for_renamed_identifier(name, p_identifier->type);
-					if (renamed_identifier_name) {
-						rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", renamed_identifier_name);
+					String rename_hint;
+					if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
+						const char *renamed_identifier_name = check_for_renamed_identifier(name, p_identifier->type);
+						if (renamed_identifier_name) {
+							rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", renamed_identifier_name);
+						}
 					}
-				}
-				push_error(vformat(R"(Cannot find constant "%s" on base "%s".%s)", name, base.to_string(), rename_hint), p_identifier);
+					push_error(vformat(R"(Cannot find constant "%s" on base "%s".%s)", name, base.to_string(), rename_hint), p_identifier);
 #else
-				push_error(vformat(R"(Cannot find constant "%s" on base "%s".)", name, base.to_string()), p_identifier);
+					push_error(vformat(R"(Cannot find constant "%s" on base "%s".)", name, base.to_string()), p_identifier);
 #endif // SUGGEST_GODOT4_RENAMES
+				}
+				return;
 			}
-		} else {
 			switch (base.builtin_type) {
 				case Variant::NIL: {
 					if (base.is_hard_type()) {
@@ -4023,208 +4117,232 @@ void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNod
 					}
 				}
 			}
-		}
-		return;
-	}
-
-	GDScriptParser::ClassNode *base_class = base.class_type;
-	List<GDScriptParser::ClassNode *> script_classes;
-	bool is_base = true;
-
-	if (base_class != nullptr) {
-		get_class_node_current_scope_classes(base_class, &script_classes, p_identifier);
-	}
-
-	bool is_constructor = base.is_meta_type && p_identifier->name == SNAME("new");
-
-	for (GDScriptParser::ClassNode *script_class : script_classes) {
-		if (p_base == nullptr && script_class->identifier && script_class->identifier->name == name) {
-			reduce_identifier_from_base_set_class(p_identifier, script_class->get_datatype());
-			if (script_class->outer != nullptr) {
-				p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
-			}
 			return;
 		}
+		case GDScriptParser::DataType::NATIVE:
+		case GDScriptParser::DataType::SCRIPT:
+		case GDScriptParser::DataType::CLASS:
+		case GDScriptParser::DataType::VARIANT:
+		case GDScriptParser::DataType::RESOLVING:
+		case GDScriptParser::DataType::UNRESOLVED: {
+			GDScriptParser::ClassNode *base_class = base.class_type;
+			List<GDScriptParser::ClassNode *> script_classes;
+			bool is_base = true;
 
-		if (is_constructor) {
-			name = "_init";
-		}
+			if (base_class != nullptr) {
+				get_class_node_current_scope_classes(base_class, &script_classes, p_identifier);
+			}
 
-		if (script_class->has_member(name)) {
-			resolve_class_member(script_class, name, p_identifier);
+			// Struct constructors do not use "new"
+			bool is_constructor = base.is_meta_type && p_identifier->name == SNAME("new");
 
-			GDScriptParser::ClassNode::Member member = script_class->get_member(name);
-			switch (member.type) {
-				case GDScriptParser::ClassNode::Member::CONSTANT: {
-					p_identifier->set_datatype(member.get_datatype());
-					p_identifier->is_constant = true;
-					p_identifier->reduced_value = member.constant->initializer->reduced_value;
-					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
-					p_identifier->constant_source = member.constant;
+			for (GDScriptParser::ClassNode *script_class : script_classes) {
+				if (p_base == nullptr && script_class->identifier && script_class->identifier->name == name) {
+					reduce_identifier_from_base_set_class(p_identifier, script_class->get_datatype());
+					if (script_class->outer != nullptr) {
+						p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
+					}
 					return;
 				}
 
-				case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
-					p_identifier->set_datatype(member.get_datatype());
-					p_identifier->is_constant = true;
-					p_identifier->reduced_value = member.enum_value.value;
-					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
-					return;
+				if (is_constructor) {
+					name = "_init";
 				}
 
-				case GDScriptParser::ClassNode::Member::ENUM: {
-					p_identifier->set_datatype(member.get_datatype());
-					p_identifier->is_constant = true;
-					p_identifier->reduced_value = member.m_enum->dictionary;
-					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
-					return;
-				}
+				if (script_class->has_member(name)) {
+					resolve_class_member(script_class, name, p_identifier);
 
-				case GDScriptParser::ClassNode::Member::VARIABLE: {
-					if (is_base && (!base.is_meta_type || member.variable->is_static)) {
-						p_identifier->set_datatype(member.get_datatype());
-						p_identifier->source = member.variable->is_static ? GDScriptParser::IdentifierNode::STATIC_VARIABLE : GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
-						p_identifier->variable_source = member.variable;
-						member.variable->usages += 1;
-						return;
-					}
-				} break;
-
-				case GDScriptParser::ClassNode::Member::SIGNAL: {
-					if (is_base && !base.is_meta_type) {
-						p_identifier->set_datatype(member.get_datatype());
-						p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
-						p_identifier->signal_source = member.signal;
-						member.signal->usages += 1;
-						return;
-					}
-				} break;
-
-				case GDScriptParser::ClassNode::Member::FUNCTION: {
-					if (is_base && (!base.is_meta_type || member.function->is_static || is_constructor)) {
-						p_identifier->set_datatype(make_callable_type(member.function->info));
-						p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
-						p_identifier->function_source = member.function;
-						p_identifier->function_source_is_static = member.function->is_static;
-						return;
-					}
-				} break;
+					GDScriptParser::ClassNode::Member member = script_class->get_member(name);
+					switch (member.type) {
+						case GDScriptParser::ClassNode::Member::CONSTANT: {
+							p_identifier->set_datatype(member.get_datatype());
+							p_identifier->is_constant = true;
+							p_identifier->reduced_value = member.constant->initializer->reduced_value;
+							p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
+							p_identifier->constant_source = member.constant;
+							return;
+						}
 
-				case GDScriptParser::ClassNode::Member::CLASS: {
-					reduce_identifier_from_base_set_class(p_identifier, member.get_datatype());
-					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
-					return;
+						case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
+							p_identifier->set_datatype(member.get_datatype());
+							p_identifier->is_constant = true;
+							p_identifier->reduced_value = member.enum_value.value;
+							p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
+							return;
+						}
+
+						case GDScriptParser::ClassNode::Member::ENUM: {
+							p_identifier->set_datatype(member.get_datatype());
+							p_identifier->is_constant = true;
+							p_identifier->reduced_value = member.m_enum->dictionary;
+							p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
+							return;
+						}
+
+						case GDScriptParser::ClassNode::Member::VARIABLE: {
+							if (is_base && (!base.is_meta_type || member.variable->is_static)) {
+								p_identifier->set_datatype(member.get_datatype());
+								p_identifier->source = member.variable->is_static ? GDScriptParser::IdentifierNode::STATIC_VARIABLE : GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
+								p_identifier->variable_source = member.variable;
+								member.variable->usages += 1;
+								return;
+							}
+						} break;
+
+						case GDScriptParser::ClassNode::Member::SIGNAL: {
+							if (is_base && !base.is_meta_type) {
+								p_identifier->set_datatype(member.get_datatype());
+								p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
+								p_identifier->signal_source = member.signal;
+								member.signal->usages += 1;
+								return;
+							}
+						} break;
+
+						case GDScriptParser::ClassNode::Member::FUNCTION: {
+							if (is_base && (!base.is_meta_type || member.function->is_static || is_constructor)) {
+								p_identifier->set_datatype(make_callable_type(member.function->info));
+								p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
+								p_identifier->function_source = member.function;
+								p_identifier->function_source_is_static = member.function->is_static;
+								return;
+							}
+						} break;
+
+						case GDScriptParser::ClassNode::Member::CLASS: {
+							reduce_identifier_from_base_set_class(p_identifier, member.get_datatype());
+							p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
+							return;
+						}
+
+						case GDScriptParser::ClassNode::Member::STRUCT: {
+							p_identifier->set_datatype(member.get_datatype());
+							p_identifier->is_constant = true;
+							p_identifier->reduced_value = member.m_struct;
+							p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_STRUCT;
+							p_identifier->struct_source = member.m_struct;
+							return;
+						}
+
+						default: {
+							// Do nothing
+						}
+					}
 				}
 
-				default: {
-					// Do nothing
+				if (is_base) {
+					is_base = script_class->base_type.class_type != nullptr;
+					if (!is_base && p_base != nullptr) {
+						break;
+					}
 				}
 			}
-		}
 
-		if (is_base) {
-			is_base = script_class->base_type.class_type != nullptr;
-			if (!is_base && p_base != nullptr) {
-				break;
-			}
-		}
-	}
+			// Check non-GDScript scripts.
+			Ref<Script> script_type = base.script_type;
 
-	// Check non-GDScript scripts.
-	Ref<Script> script_type = base.script_type;
+			if (base_class == nullptr && script_type.is_valid()) {
+				List<PropertyInfo> property_list;
+				script_type->get_script_property_list(&property_list);
 
-	if (base_class == nullptr && script_type.is_valid()) {
-		List<PropertyInfo> property_list;
-		script_type->get_script_property_list(&property_list);
+				for (const PropertyInfo &property_info : property_list) {
+					if (property_info.name != p_identifier->name) {
+						continue;
+					}
 
-		for (const PropertyInfo &property_info : property_list) {
-			if (property_info.name != p_identifier->name) {
-				continue;
-			}
+					const GDScriptParser::DataType property_type = GDScriptAnalyzer::type_from_property(property_info, false, false);
 
-			const GDScriptParser::DataType property_type = GDScriptAnalyzer::type_from_property(property_info, false, false);
+					p_identifier->set_datatype(property_type);
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
+					return;
+				}
 
-			p_identifier->set_datatype(property_type);
-			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
-			return;
-		}
+				MethodInfo method_info = script_type->get_method_info(p_identifier->name);
 
-		MethodInfo method_info = script_type->get_method_info(p_identifier->name);
+				if (method_info.name == p_identifier->name) {
+					p_identifier->set_datatype(make_callable_type(method_info));
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
+					p_identifier->function_source_is_static = method_info.flags & METHOD_FLAG_STATIC;
+					return;
+				}
 
-		if (method_info.name == p_identifier->name) {
-			p_identifier->set_datatype(make_callable_type(method_info));
-			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
-			p_identifier->function_source_is_static = method_info.flags & METHOD_FLAG_STATIC;
-			return;
-		}
+				List<MethodInfo> signal_list;
+				script_type->get_script_signal_list(&signal_list);
 
-		List<MethodInfo> signal_list;
-		script_type->get_script_signal_list(&signal_list);
+				for (const MethodInfo &signal_info : signal_list) {
+					if (signal_info.name != p_identifier->name) {
+						continue;
+					}
 
-		for (const MethodInfo &signal_info : signal_list) {
-			if (signal_info.name != p_identifier->name) {
-				continue;
-			}
+					const GDScriptParser::DataType signal_type = make_signal_type(signal_info);
 
-			const GDScriptParser::DataType signal_type = make_signal_type(signal_info);
+					p_identifier->set_datatype(signal_type);
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
+					return;
+				}
 
-			p_identifier->set_datatype(signal_type);
-			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
-			return;
-		}
+				HashMap<StringName, Variant> constant_map;
+				script_type->get_constants(&constant_map);
 
-		HashMap<StringName, Variant> constant_map;
-		script_type->get_constants(&constant_map);
+				if (constant_map.has(p_identifier->name)) {
+					Variant constant = constant_map.get(p_identifier->name);
 
-		if (constant_map.has(p_identifier->name)) {
-			Variant constant = constant_map.get(p_identifier->name);
+					p_identifier->set_datatype(make_builtin_meta_type(constant.get_type()));
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
+					return;
+				}
+			}
 
-			p_identifier->set_datatype(make_builtin_meta_type(constant.get_type()));
-			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
-			return;
-		}
-	}
+			// Check native members. No need for native class recursion because Node exposes all Object's properties.
+			const StringName &native = base.native_type;
 
-	// Check native members. No need for native class recursion because Node exposes all Object's properties.
-	const StringName &native = base.native_type;
+			if (!class_exists(native)) {
+				return;
+			}
 
-	if (class_exists(native)) {
-		if (is_constructor) {
-			name = "_init";
-		}
+			if (is_constructor) {
+				name = "_init";
+			}
 
-		MethodInfo method_info;
-		if (ClassDB::has_property(native, name)) {
-			StringName getter_name = ClassDB::get_property_getter(native, name);
-			MethodBind *getter = ClassDB::get_method(native, getter_name);
-			if (getter != nullptr) {
-				bool has_setter = ClassDB::get_property_setter(native, name) != StringName();
-				p_identifier->set_datatype(type_from_property(getter->get_return_info(), false, !has_setter));
+			MethodInfo method_info;
+			if (ClassDB::has_property(native, name)) {
+				StringName getter_name = ClassDB::get_property_getter(native, name);
+				MethodBind *getter = ClassDB::get_method(native, getter_name);
+				if (getter != nullptr) {
+					bool has_setter = ClassDB::get_property_setter(native, name) != StringName();
+					p_identifier->set_datatype(type_from_property(getter->get_return_info(), false, !has_setter));
+					p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
+				}
+				return;
+			}
+			if (ClassDB::get_method_info(native, name, &method_info)) {
+				// Method is callable.
+				p_identifier->set_datatype(make_callable_type(method_info));
 				p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
+				return;
 			}
-			return;
-		}
-		if (ClassDB::get_method_info(native, name, &method_info)) {
-			// Method is callable.
-			p_identifier->set_datatype(make_callable_type(method_info));
-			p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
-			return;
-		}
-		if (ClassDB::get_signal(native, name, &method_info)) {
-			// Signal is a type too.
-			p_identifier->set_datatype(make_signal_type(method_info));
-			p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
-			return;
-		}
-		if (ClassDB::has_enum(native, name)) {
-			p_identifier->set_datatype(make_native_enum_type(name, native));
-			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
-			return;
-		}
-		bool valid = false;
+			if (ClassDB::get_signal(native, name, &method_info)) {
+				// Signal is a type too.
+				p_identifier->set_datatype(make_signal_type(method_info));
+				p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
+				return;
+			}
+			if (const StructInfo *struct_info = ClassDB::get_struct_info(native, name)) {
+				p_identifier->set_datatype(type_from_struct_info(*struct_info, true, true));
+				p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_STRUCT;
+				return;
+			}
+			if (ClassDB::has_enum(native, name)) {
+				p_identifier->set_datatype(make_native_enum_type(name, native));
+				p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
+				return;
+			}
+			bool valid = false;
 
-		int64_t int_constant = ClassDB::get_integer_constant(native, name, &valid);
-		if (valid) {
+			int64_t int_constant = ClassDB::get_integer_constant(native, name, &valid);
+			if (!valid) {
+				return;
+			}
 			p_identifier->is_constant = true;
 			p_identifier->reduced_value = int_constant;
 			p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
@@ -4315,6 +4433,7 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 		case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
 		case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
 		case GDScriptParser::IdentifierNode::MEMBER_CLASS:
+		case GDScriptParser::IdentifierNode::MEMBER_STRUCT:
 			break;
 	}
 
@@ -4383,6 +4502,7 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 				case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
 				case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
 				case GDScriptParser::IdentifierNode::MEMBER_CLASS:
+				case GDScriptParser::IdentifierNode::MEMBER_STRUCT:
 				case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
 				case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
 					return; // No need to capture.
@@ -4426,6 +4546,12 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 		return;
 	}
 
+	if (const StructInfo *struct_info = ClassDB::get_struct_info(name)) {
+		// TODO: not sure about this
+		p_identifier->set_datatype(type_from_struct_info(*struct_info, true, true));
+		return;
+	}
+
 	// Try singletons.
 	// Do this before globals because this might be a singleton loading another one before it's compiled.
 	if (ProjectSettings::get_singleton()->has_autoload(name)) {
@@ -4897,7 +5023,7 @@ void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscri
 				result_type.kind = GDScriptParser::DataType::BUILTIN;
 				result_type.type_source = base_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
 
-				if (base_type.kind != GDScriptParser::DataType::BUILTIN) {
+				if (base_type.kind != GDScriptParser::DataType::BUILTIN && base_type.kind != GDScriptParser::DataType::STRUCT) {
 					base_type.builtin_type = Variant::OBJECT;
 				}
 				switch (base_type.builtin_type) {
@@ -5125,28 +5251,33 @@ void GDScriptAnalyzer::reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op)
 	p_unary_op->set_datatype(result);
 }
 
-Variant GDScriptAnalyzer::make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced) {
-	Variant value;
-
+Variant GDScriptAnalyzer::make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced) const {
 	if (p_expression == nullptr) {
-		return value;
+		return Variant();
 	}
 
 	if (p_expression->is_constant) {
 		is_reduced = true;
-		value = p_expression->reduced_value;
-	} else if (p_expression->type == GDScriptParser::Node::ARRAY) {
-		value = make_array_reduced_value(static_cast<GDScriptParser::ArrayNode *>(p_expression), is_reduced);
-	} else if (p_expression->type == GDScriptParser::Node::DICTIONARY) {
-		value = make_dictionary_reduced_value(static_cast<GDScriptParser::DictionaryNode *>(p_expression), is_reduced);
-	} else if (p_expression->type == GDScriptParser::Node::SUBSCRIPT) {
-		value = make_subscript_reduced_value(static_cast<GDScriptParser::SubscriptNode *>(p_expression), is_reduced);
+		return p_expression->reduced_value;
 	}
 
-	return value;
+	switch (p_expression->type) { // TODO: Struct case?
+		case GDScriptParser::Node::ARRAY: {
+			return make_array_reduced_value(static_cast<GDScriptParser::ArrayNode *>(p_expression), is_reduced);
+		}
+		case GDScriptParser::Node::DICTIONARY: {
+			return make_dictionary_reduced_value(static_cast<GDScriptParser::DictionaryNode *>(p_expression), is_reduced);
+		}
+		case GDScriptParser::Node::SUBSCRIPT: {
+			return make_subscript_reduced_value(static_cast<GDScriptParser::SubscriptNode *>(p_expression), is_reduced);
+		}
+		default: {
+			return Variant();
+		}
+	}
 }
 
-Variant GDScriptAnalyzer::make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced) {
+Variant GDScriptAnalyzer::make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced) const {
 	Array array = p_array->get_datatype().has_container_element_type(0) ? make_array_from_element_datatype(p_array->get_datatype().get_container_element_type(0)) : Array();
 
 	array.resize(p_array->elements.size());
@@ -5168,7 +5299,7 @@ Variant GDScriptAnalyzer::make_array_reduced_value(GDScriptParser::ArrayNode *p_
 	return array;
 }
 
-Variant GDScriptAnalyzer::make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced) {
+Variant GDScriptAnalyzer::make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced) const {
 	Dictionary dictionary = p_dictionary->get_datatype().has_container_element_types()
 			? make_dictionary_from_element_datatype(p_dictionary->get_datatype().get_container_element_type_or_variant(0), p_dictionary->get_datatype().get_container_element_type_or_variant(1))
 			: Dictionary();
@@ -5197,7 +5328,7 @@ Variant GDScriptAnalyzer::make_dictionary_reduced_value(GDScriptParser::Dictiona
 	return dictionary;
 }
 
-Variant GDScriptAnalyzer::make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced) {
+Variant GDScriptAnalyzer::make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced) const {
 	if (p_subscript->base == nullptr || p_subscript->index == nullptr) {
 		return Variant();
 	}
@@ -5235,7 +5366,7 @@ Variant GDScriptAnalyzer::make_subscript_reduced_value(GDScriptParser::Subscript
 	}
 }
 
-Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node) {
+Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node) const {
 	Array array;
 
 	if (p_element_datatype.builtin_type == Variant::OBJECT) {
@@ -5258,7 +5389,7 @@ Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::D
 	return array;
 }
 
-Dictionary GDScriptAnalyzer::make_dictionary_from_element_datatype(const GDScriptParser::DataType &p_key_element_datatype, const GDScriptParser::DataType &p_value_element_datatype, const GDScriptParser::Node *p_source_node) {
+Dictionary GDScriptAnalyzer::make_dictionary_from_element_datatype(const GDScriptParser::DataType &p_key_element_datatype, const GDScriptParser::DataType &p_value_element_datatype, const GDScriptParser::Node *p_source_node) const {
 	Dictionary dictionary;
 	StringName key_name;
 	Variant key_script;
@@ -5301,35 +5432,63 @@ Dictionary GDScriptAnalyzer::make_dictionary_from_element_datatype(const GDScrip
 	return dictionary;
 }
 
-Variant GDScriptAnalyzer::make_variable_default_value(GDScriptParser::VariableNode *p_variable) {
-	Variant result = Variant();
-
+Variant GDScriptAnalyzer::make_variable_default_value(const GDScriptParser::VariableNode *p_variable) const {
 	if (p_variable->initializer) {
 		bool is_initializer_value_reduced = false;
 		Variant initializer_value = make_expression_reduced_value(p_variable->initializer, is_initializer_value_reduced);
 		if (is_initializer_value_reduced) {
-			result = initializer_value;
+			return initializer_value;
 		}
-	} else {
-		GDScriptParser::DataType datatype = p_variable->get_datatype();
-		if (datatype.is_hard_type()) {
-			if (datatype.kind == GDScriptParser::DataType::BUILTIN && datatype.builtin_type != Variant::OBJECT) {
-				if (datatype.builtin_type == Variant::ARRAY && datatype.has_container_element_type(0)) {
-					result = make_array_from_element_datatype(datatype.get_container_element_type(0));
-				} else if (datatype.builtin_type == Variant::DICTIONARY && datatype.has_container_element_types()) {
-					GDScriptParser::DataType key = datatype.get_container_element_type_or_variant(0);
-					GDScriptParser::DataType value = datatype.get_container_element_type_or_variant(1);
-					result = make_dictionary_from_element_datatype(key, value);
-				} else {
+		return Variant();
+	}
+	GDScriptParser::DataType datatype = p_variable->get_datatype();
+	if (!datatype.is_hard_type()) {
+		return Variant();
+	}
+	switch (datatype.kind) {
+		case GDScriptParser::DataType::BUILTIN: {
+			switch (datatype.builtin_type) {
+				case Variant::OBJECT: {
+					return Variant();
+				}
+				case Variant::ARRAY: {
+					if (datatype.has_container_element_type(0)) {
+						return make_array_from_element_datatype(datatype.get_container_element_type(0));
+					}
+					return Array();
+				}
+				case Variant::DICTIONARY: {
+					if (datatype.has_container_element_types()) {
+						GDScriptParser::DataType key = datatype.get_container_element_type_or_variant(0);
+						GDScriptParser::DataType value = datatype.get_container_element_type_or_variant(1);
+						return make_dictionary_from_element_datatype(key, value);
+					}
+					return Dictionary();
+				}
+				default: {
+					Variant result;
 					VariantInternal::initialize(&result, datatype.builtin_type);
+					return result;
 				}
-			} else if (datatype.kind == GDScriptParser::DataType::ENUM) {
-				result = 0;
 			}
 		}
+		case GDScriptParser::DataType::ENUM: {
+			return 0;
+		}
+		case GDScriptParser::DataType::STRUCT: {
+			if (const StructInfo *info = ClassDB::get_struct_info(datatype.native_type)) {
+				return Array(*info);
+			}
+			if (const GDScriptParser::StructNode *struct_node = datatype.struct_type) {
+				return Array(struct_node->make_struct_info()); //TODO: might want to cache the struct_info somewhere
+			}
+			// TODO: hitting this code is a bug
+			return Variant(); // TODO: or maybe Array?
+		}
+		default: {
+			return Variant();
+		}
 	}
-
-	return result;
 }
 
 GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source) {
@@ -5339,95 +5498,105 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_va
 	result.builtin_type = p_value.get_type();
 	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT; // Constant has explicit type.
 
-	if (p_value.get_type() == Variant::ARRAY) {
-		const Array &array = p_value;
-		if (array.get_typed_script()) {
-			result.set_container_element_type(0, type_from_metatype(make_script_meta_type(array.get_typed_script())));
-		} else if (array.get_typed_class_name()) {
-			result.set_container_element_type(0, type_from_metatype(make_native_meta_type(array.get_typed_class_name())));
-		} else if (array.get_typed_builtin() != Variant::NIL) {
-			result.set_container_element_type(0, type_from_metatype(make_builtin_meta_type((Variant::Type)array.get_typed_builtin())));
-		}
-	} else if (p_value.get_type() == Variant::DICTIONARY) {
-		const Dictionary &dict = p_value;
-		if (dict.get_typed_key_script()) {
-			result.set_container_element_type(0, type_from_metatype(make_script_meta_type(dict.get_typed_key_script())));
-		} else if (dict.get_typed_key_class_name()) {
-			result.set_container_element_type(0, type_from_metatype(make_native_meta_type(dict.get_typed_key_class_name())));
-		} else if (dict.get_typed_key_builtin() != Variant::NIL) {
-			result.set_container_element_type(0, type_from_metatype(make_builtin_meta_type((Variant::Type)dict.get_typed_key_builtin())));
-		}
-		if (dict.get_typed_value_script()) {
-			result.set_container_element_type(1, type_from_metatype(make_script_meta_type(dict.get_typed_value_script())));
-		} else if (dict.get_typed_value_class_name()) {
-			result.set_container_element_type(1, type_from_metatype(make_native_meta_type(dict.get_typed_value_class_name())));
-		} else if (dict.get_typed_value_builtin() != Variant::NIL) {
-			result.set_container_element_type(1, type_from_metatype(make_builtin_meta_type((Variant::Type)dict.get_typed_value_builtin())));
-		}
-	} else if (p_value.get_type() == Variant::OBJECT) {
-		// Object is treated as a native type, not a builtin type.
-		result.kind = GDScriptParser::DataType::NATIVE;
-
-		Object *obj = p_value;
-		if (!obj) {
-			return GDScriptParser::DataType();
+	switch (p_value.get_type()) {
+		case Variant::ARRAY: {
+			const Array &array = p_value;
+			if (const StructInfo *info = array.get_struct_info()) {
+				result.kind = GDScriptParser::DataType::STRUCT;
+				result.native_type = info->name;
+			} else if (array.get_typed_script()) {
+				result.set_container_element_type(0, type_from_metatype(make_script_meta_type(array.get_typed_script())));
+			} else if (array.get_typed_class_name()) {
+				result.set_container_element_type(0, type_from_metatype(make_native_meta_type(array.get_typed_class_name())));
+			} else if (array.get_typed_builtin() != Variant::NIL) {
+				result.set_container_element_type(0, type_from_metatype(make_builtin_meta_type((Variant::Type)array.get_typed_builtin())));
+			}
+			return result;
 		}
-		result.native_type = obj->get_class_name();
-
-		Ref<Script> scr = p_value; // Check if value is a script itself.
-		if (scr.is_valid()) {
-			result.is_meta_type = true;
-		} else {
-			result.is_meta_type = false;
-			scr = obj->get_script();
+		case Variant::DICTIONARY: {
+			const Dictionary &dict = p_value;
+			if (dict.get_typed_key_script()) {
+				result.set_container_element_type(0, type_from_metatype(make_script_meta_type(dict.get_typed_key_script())));
+			} else if (dict.get_typed_key_class_name()) {
+				result.set_container_element_type(0, type_from_metatype(make_native_meta_type(dict.get_typed_key_class_name())));
+			} else if (dict.get_typed_key_builtin() != Variant::NIL) {
+				result.set_container_element_type(0, type_from_metatype(make_builtin_meta_type((Variant::Type)dict.get_typed_key_builtin())));
+			}
+			if (dict.get_typed_value_script()) {
+				result.set_container_element_type(1, type_from_metatype(make_script_meta_type(dict.get_typed_value_script())));
+			} else if (dict.get_typed_value_class_name()) {
+				result.set_container_element_type(1, type_from_metatype(make_native_meta_type(dict.get_typed_value_class_name())));
+			} else if (dict.get_typed_value_builtin() != Variant::NIL) {
+				result.set_container_element_type(1, type_from_metatype(make_builtin_meta_type((Variant::Type)dict.get_typed_value_builtin())));
+			}
+			return result;
 		}
-		if (scr.is_valid()) {
-			Ref<GDScript> gds = scr;
-			if (gds.is_valid()) {
-				// This might be an inner class, so we want to get the parser for the root.
-				// But still get the inner class from that tree.
-				String script_path = gds->get_script_path();
-				Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(script_path);
-				if (ref.is_null()) {
-					push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
-					GDScriptParser::DataType error_type;
-					error_type.kind = GDScriptParser::DataType::VARIANT;
-					return error_type;
-				}
-				Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
-				GDScriptParser::ClassNode *found = nullptr;
-				if (err == OK) {
-					found = ref->get_parser()->find_class(gds->fully_qualified_name);
-					if (found != nullptr) {
-						err = resolve_class_inheritance(found, p_source);
-					}
-				}
-				if (err || found == nullptr) {
-					push_error(vformat(R"(Could not resolve script "%s".)", script_path), p_source);
-					GDScriptParser::DataType error_type;
-					error_type.kind = GDScriptParser::DataType::VARIANT;
-					return error_type;
-				}
+		case Variant::OBJECT: {
+			// Object is treated as a native type, not a builtin type.
+			result.kind = GDScriptParser::DataType::NATIVE;
 
-				result.kind = GDScriptParser::DataType::CLASS;
-				result.native_type = found->get_datatype().native_type;
-				result.class_type = found;
-				result.script_path = ref->get_parser()->script_path;
-			} else {
-				result.kind = GDScriptParser::DataType::SCRIPT;
-				result.native_type = scr->get_instance_base_type();
-				result.script_path = scr->get_path();
+			Object *obj = p_value;
+			if (!obj) {
+				return GDScriptParser::DataType();
 			}
-			result.script_type = scr;
-		} else {
-			result.kind = GDScriptParser::DataType::NATIVE;
-			if (result.native_type == GDScriptNativeClass::get_class_static()) {
+			result.native_type = obj->get_class_name();
+
+			Ref<Script> scr = p_value; // Check if value is a script itself.
+			if (scr.is_valid()) {
 				result.is_meta_type = true;
+			} else {
+				result.is_meta_type = false;
+				scr = obj->get_script();
 			}
+			if (scr.is_valid()) {
+				Ref<GDScript> gds = scr;
+				if (gds.is_valid()) {
+					// This might be an inner class, so we want to get the parser for the root.
+					// But still get the inner class from that tree.
+					String script_path = gds->get_script_path();
+					Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(script_path);
+					if (ref.is_null()) {
+						push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
+						GDScriptParser::DataType error_type;
+						error_type.kind = GDScriptParser::DataType::VARIANT;
+						return error_type;
+					}
+					Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+					GDScriptParser::ClassNode *found = nullptr;
+					if (err == OK) {
+						found = ref->get_parser()->find_class(gds->fully_qualified_name);
+						if (found != nullptr) {
+							err = resolve_class_inheritance(found, p_source);
+						}
+					}
+					if (err || found == nullptr) {
+						push_error(vformat(R"(Could not resolve script "%s".)", script_path), p_source);
+						GDScriptParser::DataType error_type;
+						error_type.kind = GDScriptParser::DataType::VARIANT;
+						return error_type;
+					}
+
+					result.kind = GDScriptParser::DataType::CLASS;
+					result.native_type = found->get_datatype().native_type;
+					result.class_type = found;
+					result.script_path = ref->get_parser()->script_path;
+				} else {
+					result.kind = GDScriptParser::DataType::SCRIPT;
+					result.native_type = scr->get_instance_base_type();
+					result.script_path = scr->get_path();
+				}
+				result.script_type = scr;
+			} else {
+				result.kind = GDScriptParser::DataType::NATIVE;
+				if (result.native_type == GDScriptNativeClass::get_class_static()) {
+					result.is_meta_type = true;
+				}
+			}
+			return result;
 		}
+		default:
+			return result;
 	}
-
-	return result;
 }
 
 GDScriptParser::DataType GDScriptAnalyzer::type_from_metatype(const GDScriptParser::DataType &p_meta_type) {
@@ -5443,133 +5612,216 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_metatype(const GDScriptPars
 }
 
 GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo &p_property, bool p_is_arg, bool p_is_readonly) const {
+	switch (p_property.type) {
+		case Variant::NIL: {
+			return make_nil_type(p_is_arg || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT), p_is_readonly);
+		}
+		case Variant::OBJECT: {
+			return make_object_type(p_property.class_name, p_is_readonly);
+		}
+		case Variant::ARRAY: {
+			if (p_property.hint == PROPERTY_HINT_ARRAY_TYPE) {
+				return make_array_type(p_property.hint_string, p_is_readonly);
+			}
+			return make_builtin_type(Variant::ARRAY, p_is_readonly);
+		}
+		case Variant::DICTIONARY: {
+			if (p_property.hint == PROPERTY_HINT_DICTIONARY_TYPE) {
+				return make_dictionary_type(p_property.hint_string, p_is_readonly);
+			}
+			return make_builtin_type(Variant::DICTIONARY, p_is_readonly);
+		}
+		case Variant::INT: {
+			if ((p_property.usage & PROPERTY_USAGE_CLASS_IS_ENUM) && p_property.class_name != StringName()) {
+				return make_int_type(p_property.class_name, p_is_readonly);
+			}
+			return make_builtin_type(Variant::INT, p_is_readonly);
+		}
+		default: {
+			return make_builtin_type(p_property.type, p_is_readonly);
+		}
+	}
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::type_from_struct_info(const StructInfo &p_struct_info, bool p_is_readonly, bool p_meta) const {
 	GDScriptParser::DataType result;
 	result.is_read_only = p_is_readonly;
 	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
-	if (p_property.type == Variant::NIL && (p_is_arg || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
-		// Variant
-		result.kind = GDScriptParser::DataType::VARIANT;
-		return result;
+	result.kind = GDScriptParser::DataType::STRUCT;
+	result.builtin_type = Variant::ARRAY;
+	result.native_type = p_struct_info.name;
+	result.is_meta_type = p_meta;
+	result.is_constant = p_meta;
+	return result;
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::type_from_struct_member(const StructInfo &p_struct_info, int p_index, bool p_is_readonly) const {
+	switch (p_struct_info.types[p_index]) {
+		case Variant::NIL: {
+			return make_nil_type(true, p_is_readonly);
+		}
+		case Variant::OBJECT: {
+			return make_object_type(p_struct_info.class_names[p_index], p_is_readonly);
+		}
+		case Variant::ARRAY: {
+			return make_array_type(p_struct_info.class_names[p_index], p_is_readonly);
+		}
+		case Variant::DICTIONARY: {
+			return make_dictionary_type(p_struct_info.class_names[p_index], p_is_readonly);
+		}
+		case Variant::INT: {
+			return make_int_type(p_struct_info.class_names[p_index], p_is_readonly);
+		}
+		default: {
+			return make_builtin_type(p_struct_info.types[p_index], p_is_readonly);
+		}
 	}
-	result.builtin_type = p_property.type;
-	if (p_property.type == Variant::OBJECT) {
-		if (ScriptServer::is_global_class(p_property.class_name)) {
-			result.kind = GDScriptParser::DataType::SCRIPT;
-			result.script_path = ScriptServer::get_global_class_path(p_property.class_name);
-			result.native_type = ScriptServer::get_global_class_native_base(p_property.class_name);
+}
 
-			Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_property.class_name));
-			if (scr.is_valid()) {
-				result.script_type = scr;
-			}
-		} else {
-			result.kind = GDScriptParser::DataType::NATIVE;
-			result.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
+GDScriptParser::DataType GDScriptAnalyzer::make_object_type(const StringName &p_class_name, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	if (ScriptServer::is_global_class(p_class_name)) {
+		result.kind = GDScriptParser::DataType::SCRIPT;
+		result.script_path = ScriptServer::get_global_class_path(p_class_name);
+		result.native_type = ScriptServer::get_global_class_native_base(p_class_name);
+
+		Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_class_name));
+		if (scr.is_valid()) {
+			result.script_type = scr;
 		}
 	} else {
-		result.kind = GDScriptParser::DataType::BUILTIN;
-		result.builtin_type = p_property.type;
-		if (p_property.type == Variant::ARRAY && p_property.hint == PROPERTY_HINT_ARRAY_TYPE) {
-			// Check element type.
-			StringName elem_type_name = p_property.hint_string;
-			GDScriptParser::DataType elem_type;
-			elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
-
-			Variant::Type elem_builtin_type = GDScriptParser::get_builtin_type(elem_type_name);
-			if (elem_builtin_type < Variant::VARIANT_MAX) {
-				// Builtin type.
-				elem_type.kind = GDScriptParser::DataType::BUILTIN;
-				elem_type.builtin_type = elem_builtin_type;
-			} else if (class_exists(elem_type_name)) {
-				elem_type.kind = GDScriptParser::DataType::NATIVE;
-				elem_type.builtin_type = Variant::OBJECT;
-				elem_type.native_type = elem_type_name;
-			} else if (ScriptServer::is_global_class(elem_type_name)) {
-				// Just load this as it shouldn't be a GDScript.
-				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(elem_type_name));
-				elem_type.kind = GDScriptParser::DataType::SCRIPT;
-				elem_type.builtin_type = Variant::OBJECT;
-				elem_type.native_type = script->get_instance_base_type();
-				elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed array.");
-			}
-			elem_type.is_constant = false;
-			result.set_container_element_type(0, elem_type);
-		} else if (p_property.type == Variant::DICTIONARY && p_property.hint == PROPERTY_HINT_DICTIONARY_TYPE) {
-			// Check element type.
-			StringName key_elem_type_name = p_property.hint_string.get_slice(";", 0);
-			GDScriptParser::DataType key_elem_type;
-			key_elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
-
-			Variant::Type key_elem_builtin_type = GDScriptParser::get_builtin_type(key_elem_type_name);
-			if (key_elem_builtin_type < Variant::VARIANT_MAX) {
-				// Builtin type.
-				key_elem_type.kind = GDScriptParser::DataType::BUILTIN;
-				key_elem_type.builtin_type = key_elem_builtin_type;
-			} else if (class_exists(key_elem_type_name)) {
-				key_elem_type.kind = GDScriptParser::DataType::NATIVE;
-				key_elem_type.builtin_type = Variant::OBJECT;
-				key_elem_type.native_type = key_elem_type_name;
-			} else if (ScriptServer::is_global_class(key_elem_type_name)) {
-				// Just load this as it shouldn't be a GDScript.
-				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(key_elem_type_name));
-				key_elem_type.kind = GDScriptParser::DataType::SCRIPT;
-				key_elem_type.builtin_type = Variant::OBJECT;
-				key_elem_type.native_type = script->get_instance_base_type();
-				key_elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed dictionary.");
-			}
-			key_elem_type.is_constant = false;
-
-			StringName value_elem_type_name = p_property.hint_string.get_slice(";", 1);
-			GDScriptParser::DataType value_elem_type;
-			value_elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
-
-			Variant::Type value_elem_builtin_type = GDScriptParser::get_builtin_type(value_elem_type_name);
-			if (value_elem_builtin_type < Variant::VARIANT_MAX) {
-				// Builtin type.
-				value_elem_type.kind = GDScriptParser::DataType::BUILTIN;
-				value_elem_type.builtin_type = value_elem_builtin_type;
-			} else if (class_exists(value_elem_type_name)) {
-				value_elem_type.kind = GDScriptParser::DataType::NATIVE;
-				value_elem_type.builtin_type = Variant::OBJECT;
-				value_elem_type.native_type = value_elem_type_name;
-			} else if (ScriptServer::is_global_class(value_elem_type_name)) {
-				// Just load this as it shouldn't be a GDScript.
-				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(value_elem_type_name));
-				value_elem_type.kind = GDScriptParser::DataType::SCRIPT;
-				value_elem_type.builtin_type = Variant::OBJECT;
-				value_elem_type.native_type = script->get_instance_base_type();
-				value_elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed dictionary.");
-			}
-			value_elem_type.is_constant = false;
+		result.kind = GDScriptParser::DataType::NATIVE;
+		result.native_type = p_class_name == StringName() ? "Object" : p_class_name;
+	}
+	return result;
+}
 
-			result.set_container_element_type(0, key_elem_type);
-			result.set_container_element_type(1, value_elem_type);
-		} else if (p_property.type == Variant::INT) {
-			// Check if it's enum.
-			if ((p_property.usage & PROPERTY_USAGE_CLASS_IS_ENUM) && p_property.class_name != StringName()) {
-				if (CoreConstants::is_global_enum(p_property.class_name)) {
-					result = make_global_enum_type(p_property.class_name, StringName(), false);
-					result.is_constant = false;
-				} else {
-					Vector<String> names = String(p_property.class_name).split(ENUM_SEPARATOR);
-					if (names.size() == 2) {
-						result = make_native_enum_type(names[1], names[0], false);
-						result.is_constant = false;
-					}
-				}
-			}
-			// PROPERTY_USAGE_CLASS_IS_BITFIELD: BitField[T] isn't supported (yet?), use plain int.
-		}
+GDScriptParser::DataType GDScriptAnalyzer::make_array_type(const StringName &p_element_type_name, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	result.builtin_type = Variant::ARRAY;
+	result.kind = GDScriptParser::DataType::BUILTIN;
+
+	// Check element type.
+	GDScriptParser::DataType elem_type;
+	elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	const Error err = find_type_by_name(elem_type, p_element_type_name);
+	ERR_FAIL_COND_V_MSG(err, result, "Could not find element type from property hint of a typed array."); //TODO: better error message?
+	elem_type.is_constant = false;
+
+	result.set_container_element_type(0, elem_type);
+	return result;
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::make_dictionary_type(const String &p_key_value_type_name, bool p_is_readonly) const {
+	const Vector<String> key_value = p_key_value_type_name.split(";", true, 2);
+	return make_dictionary_type(key_value[0], key_value[1], p_is_readonly);
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::make_dictionary_type(const StringName &p_key_type_name, const StringName &p_value_type_name, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	result.builtin_type = Variant::DICTIONARY;
+	result.kind = GDScriptParser::DataType::BUILTIN;
+
+	// Check element type.
+	GDScriptParser::DataType key_elem_type;
+	key_elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	const Error key_find_error = find_type_by_name(key_elem_type, p_key_type_name);
+	ERR_FAIL_COND_V_MSG(key_find_error, result, "Could not find element type from property hint of a typed dictionary.");
+	key_elem_type.is_constant = false;
+
+	GDScriptParser::DataType value_elem_type;
+	value_elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	const Error value_find_error = find_type_by_name(value_elem_type, p_value_type_name);
+	ERR_FAIL_COND_V_MSG(value_find_error, result, "Could not find element type from property hint of a typed dictionary.");
+	value_elem_type.is_constant = false;
+
+	result.set_container_element_type(0, key_elem_type);
+	result.set_container_element_type(1, value_elem_type);
+	return result;
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::make_int_type(const StringName &p_name, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	result.builtin_type = Variant::INT;
+	if (CoreConstants::is_global_enum(p_name)) {
+		result = make_global_enum_type(p_name, StringName(), false);
+		result.is_constant = false;
+		return result;
 	}
+	Vector<String> names = String(p_name).split(ENUM_SEPARATOR);
+	if (names.size() == 2) {
+		result = make_native_enum_type(names[1], names[0], false);
+		result.is_constant = false;
+		return result;
+	}
+	// PROPERTY_USAGE_CLASS_IS_BITFIELD: BitField[T] isn't supported (yet?), use plain int.
+	return result;
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::make_nil_type(bool p_nil_as_variant, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	if (p_nil_as_variant) {
+		result.kind = GDScriptParser::DataType::VARIANT;
+		return result;
+	}
+	result.kind = GDScriptParser::DataType::BUILTIN;
+	result.builtin_type = Variant::NIL;
+	return result;
+}
+
+GDScriptParser::DataType GDScriptAnalyzer::make_builtin_type(Variant::Type p_builtin_type, bool p_is_readonly) const {
+	GDScriptParser::DataType result;
+	result.is_read_only = p_is_readonly;
+	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	result.kind = GDScriptParser::DataType::BUILTIN;
+	result.builtin_type = p_builtin_type;
 	return result;
 }
 
+Error GDScriptAnalyzer::find_type_by_name(GDScriptParser::DataType &r_type, const StringName &p_type_name) const {
+	Variant::Type elem_builtin_type = GDScriptParser::get_builtin_type(p_type_name);
+	if (elem_builtin_type < Variant::VARIANT_MAX) {
+		// Builtin type.
+		r_type.kind = GDScriptParser::DataType::BUILTIN;
+		r_type.builtin_type = elem_builtin_type;
+		return OK;
+	}
+	if (class_exists(p_type_name)) {
+		r_type.kind = GDScriptParser::DataType::NATIVE;
+		r_type.builtin_type = Variant::OBJECT;
+		r_type.native_type = p_type_name;
+		return OK;
+	}
+	if (ScriptServer::is_global_class(p_type_name)) {
+		// Just load this as it shouldn't be a GDScript.
+		Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(p_type_name));
+		r_type.kind = GDScriptParser::DataType::SCRIPT;
+		r_type.builtin_type = Variant::OBJECT;
+		r_type.native_type = script->get_instance_base_type();
+		r_type.script_type = script;
+		return OK;
+	}
+	if (ClassDB::get_struct_info(p_type_name)) {
+		r_type.kind = GDScriptParser::DataType::STRUCT;
+		r_type.builtin_type = Variant::ARRAY;
+		r_type.native_type = p_type_name;
+		// TODO: what about structs defined in the current script?
+		return OK;
+	}
+	// TODO: what about global enums?
+	return ERR_DOES_NOT_EXIST;
+}
+
 bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bool p_is_constructor, GDScriptParser::DataType p_base_type, const StringName &p_function, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, BitField<MethodFlags> &r_method_flags, StringName *r_native_class) {
 	r_method_flags = METHOD_FLAGS_DEFAULT;
 	r_default_arg_count = 0;
@@ -5579,41 +5831,45 @@ bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bo
 	StringName function_name = p_function;
 
 	bool was_enum = false;
-	if (p_base_type.kind == GDScriptParser::DataType::ENUM) {
-		was_enum = true;
-		if (p_base_type.is_meta_type) {
+	switch (p_base_type.kind) {
+		case GDScriptParser::DataType::ENUM: {
+			was_enum = true;
+			if (!p_base_type.is_meta_type) {
+				push_error("Cannot call function on enum value.", p_source);
+				return false;
+			}
 			// Enum type can be treated as a dictionary value.
 			p_base_type.kind = GDScriptParser::DataType::BUILTIN;
 			p_base_type.is_meta_type = false;
-		} else {
-			push_error("Cannot call function on enum value.", p_source);
-			return false;
 		}
-	}
-
-	if (p_base_type.kind == GDScriptParser::DataType::BUILTIN) {
-		// Construct a base type to get methods.
-		Callable::CallError err;
-		Variant dummy;
-		Variant::construct(p_base_type.builtin_type, dummy, nullptr, 0, err);
-		if (err.error != Callable::CallError::CALL_OK) {
-			ERR_FAIL_V_MSG(false, "Could not construct base Variant type.");
-		}
-		List<MethodInfo> methods;
-		dummy.get_method_list(&methods);
-
-		for (const MethodInfo &E : methods) {
-			if (E.name == p_function) {
-				function_signature_from_info(E, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
-				// Cannot use non-const methods on enums.
-				if (!r_method_flags.has_flag(METHOD_FLAG_STATIC) && was_enum && !(E.flags & METHOD_FLAG_CONST)) {
-					push_error(vformat(R"*(Cannot call non-const Dictionary function "%s()" on enum "%s".)*", p_function, p_base_type.enum_type), p_source);
+			[[fallthrough]];
+		case GDScriptParser::DataType::BUILTIN:
+		case GDScriptParser::DataType::STRUCT: {
+			// Construct a base type to get methods.
+			Callable::CallError err;
+			Variant dummy;
+			Variant::construct(p_base_type.builtin_type, dummy, nullptr, 0, err);
+			if (err.error != Callable::CallError::CALL_OK) {
+				ERR_FAIL_V_MSG(false, "Could not construct base Variant type.");
+			}
+			List<MethodInfo> methods;
+			dummy.get_method_list(&methods);
+
+			for (const MethodInfo &E : methods) {
+				if (E.name == p_function) {
+					function_signature_from_info(E, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
+					// Cannot use non-const methods on enums.
+					if (!r_method_flags.has_flag(METHOD_FLAG_STATIC) && was_enum && !(E.flags & METHOD_FLAG_CONST)) {
+						push_error(vformat(R"*(Cannot call non-const Dictionary function "%s()" on enum "%s".)*", p_function, p_base_type.enum_type), p_source);
+					}
+					return true;
 				}
-				return true;
 			}
-		}
 
-		return false;
+			return false;
+		}
+		default:
+			break;
 	}
 
 	StringName base_native = p_base_type.native_type;
@@ -5641,49 +5897,84 @@ bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bo
 	}
 
 	GDScriptParser::ClassNode *base_class = p_base_type.class_type;
-	GDScriptParser::FunctionNode *found_function = nullptr;
-
-	while (found_function == nullptr && base_class != nullptr) {
-		if (base_class->has_member(function_name)) {
-			if (base_class->get_member(function_name).type != GDScriptParser::ClassNode::Member::FUNCTION) {
-				// TODO: If this is Callable it can have a better error message.
-				push_error(vformat(R"(Member "%s" is not a function.)", function_name), p_source);
-				return false;
-			}
 
-			resolve_class_member(base_class, function_name, p_source);
-			found_function = base_class->get_member(function_name).function;
+	while (base_class) {
+		if (!base_class->has_member(function_name)) {
+			resolve_class_inheritance(base_class, p_source);
+			base_class = base_class->base_type.class_type;
+			continue;
 		}
+		switch (base_class->get_member(function_name).type) {
+			case GDScriptParser::ClassNode::Member::FUNCTION: {
+				resolve_class_member(base_class, function_name, p_source);
+				const GDScriptParser::FunctionNode *found_function = base_class->get_member(function_name).function;
+				resolve_class_inheritance(base_class, p_source);
+				base_class = base_class->base_type.class_type;
 
-		resolve_class_inheritance(base_class, p_source);
-		base_class = base_class->base_type.class_type;
-	}
+				if (p_is_constructor || found_function->is_static) {
+					r_method_flags.set_flag(METHOD_FLAG_STATIC);
+				}
+				for (int i = 0; i < found_function->parameters.size(); i++) {
+					r_par_types.push_back(found_function->parameters[i]->get_datatype());
+					if (found_function->parameters[i]->initializer != nullptr) {
+						r_default_arg_count++;
+					}
+				}
+				r_return_type = p_is_constructor ? p_base_type : found_function->get_datatype();
+				r_return_type.is_meta_type = false;
+				r_return_type.is_coroutine = found_function->is_coroutine;
 
-	if (found_function != nullptr) {
-		if (p_is_constructor || found_function->is_static) {
-			r_method_flags.set_flag(METHOD_FLAG_STATIC);
-		}
-		for (int i = 0; i < found_function->parameters.size(); i++) {
-			r_par_types.push_back(found_function->parameters[i]->get_datatype());
-			if (found_function->parameters[i]->initializer != nullptr) {
-				r_default_arg_count++;
+				return true;
 			}
-		}
-		r_return_type = p_is_constructor ? p_base_type : found_function->get_datatype();
-		r_return_type.is_meta_type = false;
-		r_return_type.is_coroutine = found_function->is_coroutine;
+			case GDScriptParser::ClassNode::Member::STRUCT: {
+				resolve_class_member(base_class, function_name, p_source);
+				const GDScriptParser::StructNode *found_struct = base_class->get_member(function_name).m_struct;
+				resolve_class_inheritance(base_class, p_source);
+				base_class = base_class->base_type.class_type;
 
-		return true;
+				r_method_flags.set_flag(METHOD_FLAG_STATIC);
+				for (const GDScriptParser::VariableNode *member : found_struct->members) {
+					r_par_types.push_back(member->get_datatype());
+				}
+				r_default_arg_count = found_struct->members.size();
+				r_return_type = found_struct->get_datatype();
+				r_return_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+				r_return_type.is_meta_type = false;
+
+				return true;
+			}
+			default:
+				// TODO: If this is Callable it can have a better error message.
+				push_error(vformat(R"(Member "%s" is not a function.)", function_name), p_source);
+				return false;
+		}
 	}
 
 	Ref<Script> base_script = p_base_type.script_type;
 
 	while (base_script.is_valid() && base_script->has_method(function_name)) {
-		MethodInfo info = base_script->get_method_info(function_name);
+		if (base_script->has_method(function_name)) {
+			MethodInfo info = base_script->get_method_info(function_name);
 
-		if (!(info == MethodInfo())) {
-			return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
+			if (!(info == MethodInfo())) {
+				return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
+			}
 		}
+
+		Ref<GDScript> gdscript = base_script;
+		if (gdscript.is_valid()) {
+			if (const StructInfo *struct_info = gdscript->structs.getptr(function_name)) {
+				r_method_flags.set_flag(METHOD_FLAG_STATIC);
+				for (int i = 0; i < struct_info->count; i++) {
+					r_par_types.push_back(type_from_struct_member(*struct_info, i));
+				}
+				r_default_arg_count = struct_info->count;
+				r_return_type = type_from_struct_info(*struct_info);
+				r_return_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+				r_return_type.is_meta_type = false;
+			}
+		}
+
 		base_script = base_script->get_base_script();
 	}
 
@@ -5720,6 +6011,19 @@ bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bo
 		return valid;
 	}
 
+	// TODO: not sure whether this part is necessary or not.
+	if (const StructInfo *struct_info = ClassDB::get_struct_info(base_native, function_name)) {
+		r_method_flags.set_flag(METHOD_FLAG_STATIC);
+		for (int i = 0; i < struct_info->count; i++) {
+			r_par_types.push_back(type_from_struct_member(*struct_info, i));
+		}
+		r_default_arg_count = struct_info->count;
+		r_return_type = type_from_struct_info(*struct_info);
+		r_return_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+		r_return_type.is_meta_type = false;
+		return true;
+	}
+
 	return false;
 }
 
@@ -5734,6 +6038,16 @@ bool GDScriptAnalyzer::function_signature_from_info(const MethodInfo &p_info, GD
 	return true;
 }
 
+void GDScriptAnalyzer::validate_call_arg(const StructInfo &p_struct_info, const GDScriptParser::CallNode *p_call) {
+	List<GDScriptParser::DataType> arg_types;
+
+	for (int i = 0; i < p_struct_info.count; i++) {
+		arg_types.push_back(type_from_struct_member(p_struct_info, i));
+	}
+
+	validate_call_arg(arg_types, p_struct_info.count, false, p_call);
+}
+
 void GDScriptAnalyzer::validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call) {
 	List<GDScriptParser::DataType> arg_types;
 
@@ -5822,6 +6136,8 @@ void GDScriptAnalyzer::is_shadowing(GDScriptParser::IdentifierNode *p_identifier
 		} else if (GDScriptParser::get_builtin_type(name) < Variant::VARIANT_MAX) {
 			parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in type");
 			return;
+		} else if (ClassDB::get_struct_info(name)) {
+			parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "native struct");
 		}
 	}
 
@@ -5854,6 +6170,8 @@ void GDScriptAnalyzer::is_shadowing(GDScriptParser::IdentifierNode *p_identifier
 		} else if (ClassDB::has_enum(parent, name, true)) {
 			parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "enum", parent);
 			return;
+		} else if (ClassDB::get_struct_info(parent, name, true)) {
+			parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "struct", parent);
 		}
 		parent = ClassDB::get_parent_class(parent);
 	}
@@ -5994,6 +6312,10 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 		return false;
 	}
 
+	if (p_target.kind == GDScriptParser::DataType::STRUCT) {
+		return p_source.kind == GDScriptParser::DataType::STRUCT && (p_target.native_type == p_source.native_type);
+	}
+
 	// From here on the target type is an object, so we have to test polymorphism.
 
 	if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::NIL) {
@@ -6048,6 +6370,7 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 		case GDScriptParser::DataType::VARIANT:
 		case GDScriptParser::DataType::BUILTIN:
 		case GDScriptParser::DataType::ENUM:
+		case GDScriptParser::DataType::STRUCT:
 		case GDScriptParser::DataType::RESOLVING:
 		case GDScriptParser::DataType::UNRESOLVED:
 			break; // Already solved before.
@@ -6085,6 +6408,7 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 		case GDScriptParser::DataType::VARIANT:
 		case GDScriptParser::DataType::BUILTIN:
 		case GDScriptParser::DataType::ENUM:
+		case GDScriptParser::DataType::STRUCT:
 		case GDScriptParser::DataType::RESOLVING:
 		case GDScriptParser::DataType::UNRESOLVED:
 			break; // Already solved before.
@@ -6093,12 +6417,12 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 	return false;
 }
 
-void GDScriptAnalyzer::push_error(const String &p_message, const GDScriptParser::Node *p_origin) {
+void GDScriptAnalyzer::push_error(const String &p_message, const GDScriptParser::Node *p_origin) const {
 	mark_node_unsafe(p_origin);
 	parser->push_error(p_message, p_origin);
 }
 
-void GDScriptAnalyzer::mark_node_unsafe(const GDScriptParser::Node *p_node) {
+void GDScriptAnalyzer::mark_node_unsafe(const GDScriptParser::Node *p_node) const {
 #ifdef DEBUG_ENABLED
 	if (p_node == nullptr) {
 		return;
diff --git a/modules/gdscript/gdscript_analyzer.h b/modules/gdscript/gdscript_analyzer.h
index 3b781409a4df..0dbbbfb4931b 100644
--- a/modules/gdscript/gdscript_analyzer.h
+++ b/modules/gdscript/gdscript_analyzer.h
@@ -84,9 +84,10 @@ class GDScriptAnalyzer {
 	void resolve_function_body(GDScriptParser::FunctionNode *p_function, bool p_is_lambda = false);
 	void resolve_node(GDScriptParser::Node *p_node, bool p_is_root = true);
 	void resolve_suite(GDScriptParser::SuiteNode *p_suite);
-	void resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind);
+	void resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind, bool p_require_constant = false);
 	void resolve_variable(GDScriptParser::VariableNode *p_variable, bool p_is_local);
 	void resolve_constant(GDScriptParser::ConstantNode *p_constant, bool p_is_local);
+	void resolve_struct_member(GDScriptParser::VariableNode *p_member);
 	void resolve_parameter(GDScriptParser::ParameterNode *p_parameter);
 	void resolve_if(GDScriptParser::IfNode *p_if);
 	void resolve_for(GDScriptParser::ForNode *p_for);
@@ -118,30 +119,42 @@ class GDScriptAnalyzer {
 	void reduce_type_test(GDScriptParser::TypeTestNode *p_type_test);
 	void reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op);
 
-	Variant make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced);
-	Variant make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced);
-	Variant make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced);
-	Variant make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced);
+	Variant make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced) const;
+	Variant make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced) const;
+	Variant make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced) const;
+	Variant make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced) const;
 
 	// Helpers.
-	Array make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node = nullptr);
-	Dictionary make_dictionary_from_element_datatype(const GDScriptParser::DataType &p_key_element_datatype, const GDScriptParser::DataType &p_value_element_datatype, const GDScriptParser::Node *p_source_node = nullptr);
+	Array make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node = nullptr) const;
+	Dictionary make_dictionary_from_element_datatype(const GDScriptParser::DataType &p_key_element_datatype, const GDScriptParser::DataType &p_value_element_datatype, const GDScriptParser::Node *p_source_node = nullptr) const;
 	GDScriptParser::DataType type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source);
 	static GDScriptParser::DataType type_from_metatype(const GDScriptParser::DataType &p_meta_type);
 	GDScriptParser::DataType type_from_property(const PropertyInfo &p_property, bool p_is_arg = false, bool p_is_readonly = false) const;
+	GDScriptParser::DataType type_from_struct_info(const StructInfo &p_struct_info, bool p_is_readonly = false, bool p_meta = false) const;
+	GDScriptParser::DataType type_from_struct_member(const StructInfo &p_struct_info, int p_member_index, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_object_type(const StringName &p_class_name, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_array_type(const StringName &p_element_type_name, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_dictionary_type(const String &p_key_value_type_name, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_dictionary_type(const StringName &p_key_type_name, const StringName &p_value_type_name, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_int_type(const StringName &p_name = StringName(), bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_nil_type(bool p_nil_as_variant, bool p_is_readonly = false) const;
+	GDScriptParser::DataType make_builtin_type(Variant::Type p_builtin_type, bool p_is_readonly = false) const;
 	GDScriptParser::DataType make_global_class_meta_type(const StringName &p_class_name, const GDScriptParser::Node *p_source);
+	Error find_type_by_name(GDScriptParser::DataType &r_type, const StringName &p_type_name) const;
 	bool get_function_signature(GDScriptParser::Node *p_source, bool p_is_constructor, GDScriptParser::DataType base_type, const StringName &p_function, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, BitField<MethodFlags> &r_method_flags, StringName *r_native_class = nullptr);
 	bool function_signature_from_info(const MethodInfo &p_info, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, BitField<MethodFlags> &r_method_flags);
+	MethodInfo method_info_from_struct_info(const StructInfo &struct_info);
 	void validate_call_arg(const List<GDScriptParser::DataType> &p_par_types, int p_default_args_count, bool p_is_vararg, const GDScriptParser::CallNode *p_call);
 	void validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call);
+	void validate_call_arg(const StructInfo &p_struct_info, const GDScriptParser::CallNode *p_call);
 	GDScriptParser::DataType get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, const GDScriptParser::DataType &p_b, bool &r_valid, const GDScriptParser::Node *p_source);
 	GDScriptParser::DataType get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, bool &r_valid, const GDScriptParser::Node *p_source);
 	void update_const_expression_builtin_type(GDScriptParser::ExpressionNode *p_expression, const GDScriptParser::DataType &p_type, const char *p_usage, bool p_is_cast = false);
 	void update_array_literal_element_type(GDScriptParser::ArrayNode *p_array, const GDScriptParser::DataType &p_element_type);
 	void update_dictionary_literal_element_type(GDScriptParser::DictionaryNode *p_dictionary, const GDScriptParser::DataType &p_key_element_type, const GDScriptParser::DataType &p_value_element_type);
 	bool is_type_compatible(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion = false, const GDScriptParser::Node *p_source_node = nullptr);
-	void push_error(const String &p_message, const GDScriptParser::Node *p_origin = nullptr);
-	void mark_node_unsafe(const GDScriptParser::Node *p_node);
+	void push_error(const String &p_message, const GDScriptParser::Node *p_origin = nullptr) const;
+	void mark_node_unsafe(const GDScriptParser::Node *p_node) const;
 	void downgrade_node_type_source(GDScriptParser::Node *p_node);
 	void mark_lambda_use_self();
 	void resolve_pending_lambda_bodies();
@@ -150,7 +163,7 @@ class GDScriptAnalyzer {
 	Ref<GDScriptParserRef> ensure_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_from_class, const char *p_context, const GDScriptParser::Node *p_source);
 	Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const Ref<GDScriptParserRef> &p_dependant_parser);
 	Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, GDScriptParser *p_dependant_parser);
-	Ref<GDScript> get_depended_shallow_script(const String &p_path, Error &r_error);
+	Ref<GDScript> get_depended_shallow_script(const String &p_path, Error &r_error) const;
 #ifdef DEBUG_ENABLED
 	void is_shadowing(GDScriptParser::IdentifierNode *p_identifier, const String &p_context, const bool p_in_local_scope);
 #endif
@@ -162,7 +175,7 @@ class GDScriptAnalyzer {
 	Error resolve_dependencies();
 	Error analyze();
 
-	Variant make_variable_default_value(GDScriptParser::VariableNode *p_variable);
+	Variant make_variable_default_value(const GDScriptParser::VariableNode *p_variable) const;
 	static bool check_type_compatibility(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion = false, const GDScriptParser::Node *p_source_node = nullptr);
 
 	GDScriptAnalyzer(GDScriptParser *p_parser);
diff --git a/modules/gdscript/gdscript_byte_codegen.cpp b/modules/gdscript/gdscript_byte_codegen.cpp
index b77c641eb550..fc40c16dcf3a 100644
--- a/modules/gdscript/gdscript_byte_codegen.cpp
+++ b/modules/gdscript/gdscript_byte_codegen.cpp
@@ -1459,6 +1459,19 @@ void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_tar
 	ct.cleanup();
 }
 
+void GDScriptByteCodeGenerator::write_construct_struct(const GDScriptCodeGenerator::Address &p_target, const GDScriptDataType &p_struct_type, const Vector<GDScriptCodeGenerator::Address> &p_arguments) {
+	append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_STRUCT, 2 + p_arguments.size());
+	for (int i = 0; i < p_arguments.size(); i++) {
+		append(p_arguments[i]);
+	}
+	CallTarget ct = get_call_target(p_target);
+	append(ct.target);
+	append(get_constant_pos(p_struct_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
+	append(p_arguments.size());
+	append(p_struct_type.native_type);
+	ct.cleanup();
+}
+
 void GDScriptByteCodeGenerator::write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) {
 	append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY, 1 + p_arguments.size());
 	for (int i = 0; i < p_arguments.size(); i++) {
@@ -1888,7 +1901,9 @@ void GDScriptByteCodeGenerator::clear_address(const Address &p_address) {
 				}
 				break;
 			case Variant::ARRAY:
-				if (p_address.type.has_container_element_type(0)) {
+				if (p_address.type.get_struct_info()) {
+					write_construct_struct(p_address, p_address.type, Vector<GDScriptCodeGenerator::Address>());
+				} else if (p_address.type.has_container_element_type(0)) {
 					write_construct_typed_array(p_address, p_address.type.get_container_element_type(0), Vector<GDScriptCodeGenerator::Address>());
 				} else {
 					write_construct(p_address, p_address.type.builtin_type, Vector<GDScriptCodeGenerator::Address>());
diff --git a/modules/gdscript/gdscript_byte_codegen.h b/modules/gdscript/gdscript_byte_codegen.h
index 6303db71fd70..07d4b0d3fe76 100644
--- a/modules/gdscript/gdscript_byte_codegen.h
+++ b/modules/gdscript/gdscript_byte_codegen.h
@@ -395,6 +395,10 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 		opcodes.push_back(get_name_map_pos(p_name));
 	}
 
+	void append(const StructInfo &p_struct) {
+		opcodes.push_back(get_name_map_pos(p_struct.name));
+	}
+
 	void append(const Variant::ValidatedOperatorEvaluator p_operation) {
 		opcodes.push_back(get_operation_pos(p_operation));
 	}
@@ -528,6 +532,7 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	virtual void write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) override;
 	virtual void write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) override;
 	virtual void write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) override;
+	virtual void write_construct_struct(const Address &p_target, const GDScriptDataType &p_struct_type, const Vector<Address> &p_arguments) override;
 	virtual void write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) override;
 	virtual void write_construct_typed_dictionary(const Address &p_target, const GDScriptDataType &p_key_type, const GDScriptDataType &p_value_type, const Vector<Address> &p_arguments) override;
 	virtual void write_await(const Address &p_target, const Address &p_operand) override;
diff --git a/modules/gdscript/gdscript_codegen.h b/modules/gdscript/gdscript_codegen.h
index f3c4acf1c344..02a2bff81017 100644
--- a/modules/gdscript/gdscript_codegen.h
+++ b/modules/gdscript/gdscript_codegen.h
@@ -141,6 +141,7 @@ class GDScriptCodeGenerator {
 	virtual void write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) = 0;
 	virtual void write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) = 0;
 	virtual void write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) = 0;
+	virtual void write_construct_struct(const Address &p_target, const GDScriptDataType &p_struct_type, const Vector<Address> &p_arguments) = 0;
 	virtual void write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) = 0;
 	virtual void write_construct_typed_dictionary(const Address &p_target, const GDScriptDataType &p_key_type, const GDScriptDataType &p_value_type, const Vector<Address> &p_arguments) = 0;
 	virtual void write_await(const Address &p_target, const Address &p_operand) = 0;
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index f4f445e09667..7577a1f39d97 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -181,6 +181,12 @@ GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::D
 				result.native_type = p_datatype.native_type;
 			}
 		} break;
+		case GDScriptParser::DataType::STRUCT: {
+			result.kind = GDScriptDataType::BUILTIN;
+			result.builtin_type = Variant::ARRAY;
+			result.native_type = p_datatype.native_type;
+			result.script_type = p_owner;
+		} break;
 		case GDScriptParser::DataType::ENUM:
 			if (p_handle_metatype && p_datatype.is_meta_type) {
 				result.kind = GDScriptDataType::BUILTIN;
@@ -251,6 +257,39 @@ static bool _can_use_validate_call(const MethodBind *p_method, const Vector<GDSc
 	return true;
 }
 
+void GDScriptCompiler::_parse_instance_method(GDScriptCodeGenerator *p_gen, GDScriptCodeGenerator::Address &r_result, const GDScriptCodeGenerator::Address &p_base, const StringName &p_function_name, const Vector<GDScriptCodeGenerator::Address> &p_arguments, const bool p_is_awaited) {
+	if (p_is_awaited) {
+		p_gen->write_call_async(r_result, p_base, p_function_name, p_arguments);
+	} else if (p_base.type.has_type && p_base.type.kind != GDScriptDataType::BUILTIN) {
+		// Native method, use faster path.
+		StringName class_name;
+		if (p_base.type.kind == GDScriptDataType::NATIVE) {
+			class_name = p_base.type.native_type;
+		} else {
+			class_name = p_base.type.native_type == StringName() ? p_base.type.script_type->get_instance_base_type() : p_base.type.native_type;
+		}
+		if (ClassDB::class_exists(class_name) && ClassDB::has_method(class_name, p_function_name)) {
+			MethodBind *method = ClassDB::get_method(class_name, p_function_name);
+			if (_can_use_validate_call(method, p_arguments)) {
+				// Exact arguments, use validated call.
+				p_gen->write_call_method_bind_validated(r_result, p_base, method, p_arguments);
+			} else {
+				// Not exact arguments, but still can use method bind call.
+				p_gen->write_call_method_bind(r_result, p_base, method, p_arguments);
+			}
+		} else {
+			p_gen->write_call(r_result, p_base, p_function_name, p_arguments);
+		}
+	} else if (p_base.type.has_type && p_base.type.kind == GDScriptDataType::BUILTIN) {
+		p_gen->write_call_builtin_type(r_result, p_base, p_base.type.builtin_type, p_function_name, p_arguments);
+	} else {
+		p_gen->write_call(r_result, p_base, p_function_name, p_arguments);
+	}
+	if (p_base.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
+		p_gen->pop_temporary();
+	}
+}
+
 GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &codegen, Error &r_error, const GDScriptParser::ExpressionNode *p_expression, bool p_root, bool p_initializer) {
 	if (p_expression->is_constant && !(p_expression->get_datatype().is_meta_type && p_expression->get_datatype().kind == GDScriptParser::DataType::CLASS)) {
 		return codegen.add_constant(p_expression->reduced_value);
@@ -387,6 +426,9 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 						owner = owner->_owner;
 					}
 				} break;
+				case GDScriptParser::IdentifierNode::MEMBER_STRUCT: {
+					// TODO: not sure what goes here
+				} break;
 				case GDScriptParser::IdentifierNode::STATIC_VARIABLE: {
 					// Try static variables.
 					GDScript *scr = codegen.script;
@@ -512,8 +554,9 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 				}
 				values.push_back(val);
 			}
-
-			if (array_type.has_container_element_type(0)) {
+			if (array_type.get_struct_info()) { // TODO: is this code reachable?
+				gen->write_construct_struct(result, array_type, values);
+			} else if (array_type.has_container_element_type(0)) {
 				gen->write_construct_typed_array(result, array_type.get_container_element_type(0), values);
 			} else {
 				gen->write_construct_array(result, values);
@@ -650,6 +693,17 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 								// Not exact arguments, but still can use method bind call.
 								gen->write_call_method_bind(result, self, method, arguments);
 							}
+						} else if (const StructInfo *struct_info = ClassDB::get_struct_info(codegen.script->native->get_name(), call->function_name)) {
+							GDScriptDataType native_struct_type;
+							native_struct_type.has_type = true;
+							native_struct_type.kind = GDScriptDataType::BUILTIN;
+							native_struct_type.builtin_type = Variant::ARRAY;
+							native_struct_type.native_type = struct_info->name;
+							native_struct_type.script_type = codegen.script;
+							gen->write_construct_struct(result, native_struct_type, arguments);
+						} else if (call->get_datatype().struct_type) {
+							const GDScriptDataType struct_type = _gdtype_from_datatype(call->get_datatype(), codegen.script);
+							gen->write_construct_struct(result, struct_type, arguments);
 						} else if (call->is_static || codegen.is_static || (codegen.function_node && codegen.function_node->is_static) || call->function_name == "new") {
 							GDScriptCodeGenerator::Address self;
 							self.mode = GDScriptCodeGenerator::Address::CLASS;
@@ -668,63 +722,52 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 					} else if (callee->type == GDScriptParser::Node::SUBSCRIPT) {
 						const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(call->callee);
 
-						if (subscript->is_attribute) {
-							// May be static built-in method call.
-							if (!call->is_super && subscript->base->type == GDScriptParser::Node::IDENTIFIER && GDScriptParser::get_builtin_type(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name) < Variant::VARIANT_MAX) {
-								gen->write_call_builtin_type_static(result, GDScriptParser::get_builtin_type(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name), subscript->attribute->name, arguments);
-							} else if (!call->is_super && subscript->base->type == GDScriptParser::Node::IDENTIFIER && call->function_name != SNAME("new") &&
-									ClassDB::class_exists(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name) && !Engine::get_singleton()->has_singleton(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name)) {
-								// It's a static native method call.
-								StringName class_name = static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name;
-								MethodBind *method = ClassDB::get_method(class_name, subscript->attribute->name);
+						if (!subscript->is_attribute) {
+							_set_error("Cannot call something that isn't a function.", call->callee);
+							r_error = ERR_COMPILATION_FAILED;
+							return GDScriptCodeGenerator::Address();
+						}
+
+						// May be static built-in method call.
+						if (!call->is_super && subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
+							StringName base_name = static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name;
+							if (GDScriptParser::get_builtin_type(base_name) < Variant::VARIANT_MAX) {
+								gen->write_call_builtin_type_static(result, GDScriptParser::get_builtin_type(base_name), subscript->attribute->name, arguments);
+							} else if (const StructInfo *struct_info = ClassDB::get_struct_info(base_name, subscript->attribute->name)) {
+								GDScriptDataType native_struct_type;
+								native_struct_type.has_type = true;
+								native_struct_type.kind = GDScriptDataType::BUILTIN;
+								native_struct_type.builtin_type = Variant::ARRAY;
+								native_struct_type.native_type = struct_info->name;
+								native_struct_type.script_type = codegen.script;
+								gen->write_construct_struct(result, native_struct_type, arguments);
+							} else if (call->get_datatype().struct_type) {
+								const GDScriptDataType struct_type = _gdtype_from_datatype(call->get_datatype(), codegen.script);
+								gen->write_construct_struct(result, struct_type, arguments);
+							} else if (call->function_name != SNAME("new") && ClassDB::class_exists(base_name) && !Engine::get_singleton()->has_singleton(base_name)) {
+								MethodBind *method = ClassDB::get_method(base_name, subscript->attribute->name);
 								if (_can_use_validate_call(method, arguments)) {
 									// Exact arguments, use validated call.
 									gen->write_call_native_static_validated(result, method, arguments);
 								} else {
 									// Not exact arguments, use regular static call
-									gen->write_call_native_static(result, class_name, subscript->attribute->name, arguments);
+									gen->write_call_native_static(result, base_name, subscript->attribute->name, arguments);
 								}
 							} else {
 								GDScriptCodeGenerator::Address base = _parse_expression(codegen, r_error, subscript->base);
 								if (r_error) {
 									return GDScriptCodeGenerator::Address();
 								}
-								if (is_awaited) {
-									gen->write_call_async(result, base, call->function_name, arguments);
-								} else if (base.type.has_type && base.type.kind != GDScriptDataType::BUILTIN) {
-									// Native method, use faster path.
-									StringName class_name;
-									if (base.type.kind == GDScriptDataType::NATIVE) {
-										class_name = base.type.native_type;
-									} else {
-										class_name = base.type.native_type == StringName() ? base.type.script_type->get_instance_base_type() : base.type.native_type;
-									}
-									if (ClassDB::class_exists(class_name) && ClassDB::has_method(class_name, call->function_name)) {
-										MethodBind *method = ClassDB::get_method(class_name, call->function_name);
-										if (_can_use_validate_call(method, arguments)) {
-											// Exact arguments, use validated call.
-											gen->write_call_method_bind_validated(result, base, method, arguments);
-										} else {
-											// Not exact arguments, but still can use method bind call.
-											gen->write_call_method_bind(result, base, method, arguments);
-										}
-									} else {
-										gen->write_call(result, base, call->function_name, arguments);
-									}
-								} else if (base.type.has_type && base.type.kind == GDScriptDataType::BUILTIN) {
-									gen->write_call_builtin_type(result, base, base.type.builtin_type, call->function_name, arguments);
-								} else {
-									gen->write_call(result, base, call->function_name, arguments);
-								}
-								if (base.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
-									gen->pop_temporary();
-								}
+								_parse_instance_method(gen, result, base, call->function_name, arguments, is_awaited);
 							}
 						} else {
-							_set_error("Cannot call something that isn't a function.", call->callee);
-							r_error = ERR_COMPILATION_FAILED;
-							return GDScriptCodeGenerator::Address();
+							GDScriptCodeGenerator::Address base = _parse_expression(codegen, r_error, subscript->base);
+							if (r_error) {
+								return GDScriptCodeGenerator::Address();
+							}
+							_parse_instance_method(gen, result, base, call->function_name, arguments, is_awaited);
 						}
+
 					} else {
 						r_error = ERR_COMPILATION_FAILED;
 						return GDScriptCodeGenerator::Address();
@@ -2326,7 +2369,9 @@ GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_
 
 				GDScriptCodeGenerator::Address dst_address(GDScriptCodeGenerator::Address::MEMBER, codegen.script->member_indices[field->identifier->name].index, field_type);
 
-				if (field_type.builtin_type == Variant::ARRAY && field_type.has_container_element_type(0)) {
+				if (field_type.get_struct_info()) {
+					codegen.generator->write_construct_struct(dst_address, field_type, Vector<GDScriptCodeGenerator::Address>());
+				} else if (field_type.builtin_type == Variant::ARRAY && field_type.has_container_element_type(0)) {
 					codegen.generator->write_construct_typed_array(dst_address, field_type.get_container_element_type(0), Vector<GDScriptCodeGenerator::Address>());
 				} else if (field_type.builtin_type == Variant::DICTIONARY && field_type.has_container_element_types()) {
 					codegen.generator->write_construct_typed_dictionary(dst_address, field_type.get_container_element_type_or_variant(0),
@@ -2519,23 +2564,19 @@ GDScriptFunction *GDScriptCompiler::_make_static_initializer(Error &r_error, GDS
 		if (field_type.has_type) {
 			codegen.generator->write_newline(field->start_line);
 
-			if (field_type.builtin_type == Variant::ARRAY && field_type.has_container_element_type(0)) {
-				GDScriptCodeGenerator::Address temp = codegen.add_temporary(field_type);
+			GDScriptCodeGenerator::Address temp = codegen.add_temporary(field_type);
+			if (field_type.get_struct_info()) {
+				codegen.generator->write_construct_struct(temp, field_type, Vector<GDScriptCodeGenerator::Address>());
+			} else if (field_type.builtin_type == Variant::ARRAY && field_type.has_container_element_type(0)) {
 				codegen.generator->write_construct_typed_array(temp, field_type.get_container_element_type(0), Vector<GDScriptCodeGenerator::Address>());
-				codegen.generator->write_set_static_variable(temp, class_addr, p_script->static_variables_indices[field->identifier->name].index);
-				codegen.generator->pop_temporary();
 			} else if (field_type.builtin_type == Variant::DICTIONARY && field_type.has_container_element_types()) {
-				GDScriptCodeGenerator::Address temp = codegen.add_temporary(field_type);
 				codegen.generator->write_construct_typed_dictionary(temp, field_type.get_container_element_type_or_variant(0),
 						field_type.get_container_element_type_or_variant(1), Vector<GDScriptCodeGenerator::Address>());
-				codegen.generator->write_set_static_variable(temp, class_addr, p_script->static_variables_indices[field->identifier->name].index);
-				codegen.generator->pop_temporary();
 			} else if (field_type.kind == GDScriptDataType::BUILTIN) {
-				GDScriptCodeGenerator::Address temp = codegen.add_temporary(field_type);
 				codegen.generator->write_construct(temp, field_type.builtin_type, Vector<GDScriptCodeGenerator::Address>());
-				codegen.generator->write_set_static_variable(temp, class_addr, p_script->static_variables_indices[field->identifier->name].index);
-				codegen.generator->pop_temporary();
 			}
+			codegen.generator->write_set_static_variable(temp, class_addr, p_script->static_variables_indices[field->identifier->name].index);
+			codegen.generator->pop_temporary();
 			// The `else` branch is for objects, in such case we leave it as `null`.
 		}
 	}
@@ -2652,6 +2693,7 @@ Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptP
 	p_script->base = Ref<GDScript>();
 	p_script->_base = nullptr;
 	p_script->members.clear();
+	p_script->structs.clear();
 
 	// This makes possible to clear script constants and member_functions without heap-use-after-free errors.
 	HashMap<StringName, Variant> constants;
@@ -2846,6 +2888,15 @@ Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptP
 				p_script->constants.insert(name, enum_value.value);
 			} break;
 
+			case GDScriptParser::ClassNode::Member::STRUCT: {
+				if (!member.m_struct) { // member is a native struct
+					break;
+				}
+				const GDScriptParser::StructNode &struct_node = *member.m_struct;
+				StructInfo struct_info = struct_node.make_struct_info();
+				p_script->structs.insert(struct_info.name, struct_info);
+			} break;
+
 			case GDScriptParser::ClassNode::Member::SIGNAL: {
 				const GDScriptParser::SignalNode *signal = member.signal;
 				StringName name = signal->identifier->name;
@@ -3057,7 +3108,8 @@ void GDScriptCompiler::convert_to_initializer_type(Variant &p_variant, const GDS
 	GDScriptParser::DataType member_t = p_node->datatype;
 	GDScriptParser::DataType init_t = p_node->initializer->datatype;
 	if (member_t.is_hard_type() && init_t.is_hard_type() &&
-			member_t.kind == GDScriptParser::DataType::BUILTIN && init_t.kind == GDScriptParser::DataType::BUILTIN) {
+			(member_t.kind == GDScriptParser::DataType::BUILTIN || member_t.kind == GDScriptParser::DataType::STRUCT) &&
+			(init_t.kind == GDScriptParser::DataType::BUILTIN || init_t.kind == GDScriptParser::DataType::STRUCT)) {
 		if (Variant::can_convert_strict(init_t.builtin_type, member_t.builtin_type)) {
 			Variant *v = &p_node->initializer->reduced_value;
 			Callable::CallError ce;
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index 45f0f9e19b97..e6873396b3c6 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -175,6 +175,9 @@ class GDScriptCompiler {
 	GDScriptParser::ExpressionNode *awaited_node = nullptr;
 	bool has_static_data = false;
 
+	/* helpers */
+	void _parse_instance_method(GDScriptCodeGenerator *p_gen, GDScriptCodeGenerator::Address &r_result, const GDScriptCodeGenerator::Address &p_base, const StringName &p_function_name, const Vector<GDScriptCodeGenerator::Address> &p_arguments, const bool p_is_awaited);
+
 public:
 	static void convert_to_initializer_type(Variant &p_variant, const GDScriptParser::VariableNode *p_node);
 	static void make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
diff --git a/modules/gdscript/gdscript_disassembler.cpp b/modules/gdscript/gdscript_disassembler.cpp
index bc063693a392..34745470f5bc 100644
--- a/modules/gdscript/gdscript_disassembler.cpp
+++ b/modules/gdscript/gdscript_disassembler.cpp
@@ -593,6 +593,9 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 
 				incr += 6 + argc;
 			} break;
+			case OPCODE_CONSTRUCT_STRUCT: {
+				// TODO
+			} break;
 			case OPCODE_CONSTRUCT_DICTIONARY: {
 				int instr_var_args = _code_ptr[++ip];
 				int argc = _code_ptr[ip + 1 + instr_var_args];
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 73f2b1d61833..001e1d70cbfb 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -1126,6 +1126,12 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 						}
 						option = ScriptLanguage::CodeCompletionOption(member.signal->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL, location);
 						break;
+					case GDScriptParser::ClassNode::Member::STRUCT:
+						if (p_only_functions) {
+							continue;
+						}
+						option = ScriptLanguage::CodeCompletionOption(member.m_struct->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_STRUCT, location);
+						break;
 					case GDScriptParser::ClassNode::Member::GROUP:
 						break; // No-op, but silences warnings.
 					case GDScriptParser::ClassNode::Member::UNDEFINED:
@@ -1156,7 +1162,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 
 	GDScriptParser::DataType base_type = p_base.type;
 
-	if (!p_types_only && base_type.is_meta_type && base_type.kind != GDScriptParser::DataType::BUILTIN && base_type.kind != GDScriptParser::DataType::ENUM) {
+	if (!p_types_only && base_type.is_meta_type && base_type.kind != GDScriptParser::DataType::BUILTIN && base_type.kind != GDScriptParser::DataType::ENUM && base_type.kind != GDScriptParser::DataType::STRUCT) {
 		ScriptLanguage::CodeCompletionOption option("new", ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, ScriptLanguage::LOCATION_LOCAL);
 		option.insert_text += "(";
 		r_result.insert(option.display, option);
@@ -1325,6 +1331,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 				}
 			}
 				[[fallthrough]];
+			case GDScriptParser::DataType::STRUCT:
 			case GDScriptParser::DataType::BUILTIN: {
 				if (p_types_only) {
 					return;
@@ -1332,9 +1339,13 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 
 				Callable::CallError err;
 				Variant tmp;
-				Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
-				if (err.error != Callable::CallError::CALL_OK) {
-					return;
+				if (base_type.kind == GDScriptParser::DataType::STRUCT && base_type.get_struct_info()) {
+					tmp = Array(*base_type.get_struct_info());
+				} else {
+					Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
+					if (err.error != Callable::CallError::CALL_OK) {
+						return;
+					}
 				}
 
 				int location = ScriptLanguage::LOCATION_OTHER;
@@ -1632,7 +1643,7 @@ static bool _guess_expression_type(GDScriptParser::CompletionContext &p_context,
 		// Already has a value, so just use that.
 		r_type = _type_from_variant(p_expression->reduced_value, p_context);
 		switch (p_expression->get_datatype().kind) {
-			case GDScriptParser::DataType::ENUM:
+			case GDScriptParser::DataType::ENUM: // TODO: Structs?
 			case GDScriptParser::DataType::CLASS:
 				r_type.type = p_expression->get_datatype();
 				break;
@@ -2427,6 +2438,12 @@ static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &
 							r_type.type.class_type = member.m_class;
 							r_type.type.is_meta_type = true;
 							return true;
+						case GDScriptParser::ClassNode::Member::STRUCT:
+							r_type.type = member.m_struct->get_datatype();
+							//							r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+							//							r_type.type.kind = GDScriptParser::DataType::STRUCT;
+							//							r_type.type.native_type = member.get_name();
+							return true;
 						case GDScriptParser::ClassNode::Member::GROUP:
 							return false; // No-op, but silences warnings.
 						case GDScriptParser::ClassNode::Member::UNDEFINED:
@@ -2495,13 +2512,18 @@ static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &
 				}
 				return false;
 			} break;
+			case GDScriptParser::DataType::STRUCT: // TODO: probably a more efficient way to handle Structs
 			case GDScriptParser::DataType::BUILTIN: {
 				Callable::CallError err;
 				Variant tmp;
-				Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
+				if (base_type.kind == GDScriptParser::DataType::STRUCT && base_type.get_struct_info()) {
+					tmp = Array(*base_type.get_struct_info());
+				} else {
+					Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
 
-				if (err.error != Callable::CallError::CALL_OK) {
-					return false;
+					if (err.error != Callable::CallError::CALL_OK) {
+						return false;
+					}
 				}
 				bool valid = false;
 				Variant res = tmp.get(p_identifier, &valid);
@@ -2652,12 +2674,17 @@ static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContex
 				}
 				return false;
 			} break;
+			case GDScriptParser::DataType::STRUCT: // TODO: more efficient way to handle Structs?
 			case GDScriptParser::DataType::BUILTIN: {
 				Callable::CallError err;
 				Variant tmp;
-				Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
-				if (err.error != Callable::CallError::CALL_OK) {
-					return false;
+				if (base_type.kind == GDScriptParser::DataType::STRUCT && base_type.get_struct_info()) {
+					tmp = Array(*base_type.get_struct_info());
+				} else {
+					Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
+					if (err.error != Callable::CallError::CALL_OK) {
+						return false;
+					}
 				}
 
 				List<MethodInfo> methods;
@@ -2935,6 +2962,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 
 				base_type.kind = GDScriptParser::DataType::UNRESOLVED;
 			} break;
+			case GDScriptParser::DataType::STRUCT:
 			case GDScriptParser::DataType::BUILTIN: {
 				if (base.get_type() == Variant::NIL) {
 					Callable::CallError err;
@@ -3738,6 +3766,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					base_type.kind = GDScriptParser::DataType::UNRESOLVED;
 				}
 			} break;
+			case GDScriptParser::DataType::STRUCT: // TODO: not sure about this one
 			case GDScriptParser::DataType::BUILTIN: {
 				base_type.kind = GDScriptParser::DataType::UNRESOLVED;
 
@@ -3753,6 +3782,8 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				if (base_type.builtin_type == Variant::OBJECT) {
 					v_ref.instantiate();
 					v = v_ref;
+				} else if (base_type.kind == GDScriptParser::DataType::STRUCT && base_type.get_struct_info()) {
+					v = Array(*base_type.get_struct_info());
 				} else {
 					Callable::CallError err;
 					Variant::construct(base_type.builtin_type, v, nullptr, 0, err);
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index 372c212d2ba0..fcaa7d972ef7 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -32,6 +32,16 @@
 
 #include "gdscript.h"
 
+const StructInfo *GDScriptDataType::get_struct_info(bool p_no_inheritance) const {
+	// TODO: This ordering will prefer user-defined names over native names, but not sure if this is good.
+	if (const GDScript *gdscript_type = Object::cast_to<GDScript>(script_type)) {
+		if (const StructInfo *struct_info = gdscript_type->get_script_struct_info(native_type, p_no_inheritance)) {
+			return struct_info;
+		}
+	}
+	return ClassDB::get_struct_info(native_type, p_no_inheritance);
+}
+
 Variant GDScriptFunction::get_constant(int p_idx) const {
 	ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>");
 	return constants[p_idx];
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index 6433072b5560..8d52a83d0cc4 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -60,10 +60,12 @@ class GDScriptDataType {
 
 	bool has_type = false;
 	Variant::Type builtin_type = Variant::NIL;
-	StringName native_type;
+	StringName native_type; // also names struct types
 	Script *script_type = nullptr;
 	Ref<Script> script_type_ref;
 
+	const StructInfo *get_struct_info(bool p_no_inheritance = false) const;
+
 	bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
 		if (!has_type) {
 			return true; // Can't type check
@@ -292,6 +294,7 @@ class GDScriptFunction {
 		OPCODE_CONSTRUCT_VALIDATED, // Only for basic types!
 		OPCODE_CONSTRUCT_ARRAY,
 		OPCODE_CONSTRUCT_TYPED_ARRAY,
+		OPCODE_CONSTRUCT_STRUCT,
 		OPCODE_CONSTRUCT_DICTIONARY,
 		OPCODE_CONSTRUCT_TYPED_DICTIONARY,
 		OPCODE_CALL,
@@ -504,7 +507,8 @@ class GDScriptFunction {
 	int *_code_ptr = nullptr;
 	const int *_default_arg_ptr = nullptr;
 	mutable Variant *_constants_ptr = nullptr;
-	const StringName *_global_names_ptr = nullptr;
+	const StringName *
+			_global_names_ptr = nullptr;
 	const Variant::ValidatedOperatorEvaluator *_operator_funcs_ptr = nullptr;
 	const Variant::ValidatedSetter *_setters_ptr = nullptr;
 	const Variant::ValidatedGetter *_getters_ptr = nullptr;
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index e169566705a6..f334baf78a15 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -527,6 +527,7 @@ void GDScriptParser::synchronize() {
 			case GDScriptTokenizer::Token::VAR:
 			case GDScriptTokenizer::Token::CONST:
 			case GDScriptTokenizer::Token::SIGNAL:
+			case GDScriptTokenizer::Token::STRUCT:
 			//case GDScriptTokenizer::Token::IF: // Can also be inside expressions.
 			case GDScriptTokenizer::Token::FOR:
 			case GDScriptTokenizer::Token::WHILE:
@@ -862,6 +863,52 @@ GDScriptParser::ClassNode *GDScriptParser::parse_class(bool p_is_static) {
 	return n_class;
 }
 
+GDScriptParser::StructNode *GDScriptParser::parse_struct(bool p_is_static) {
+	StructNode *struct_node = alloc_node<StructNode>();
+	reset_extents(struct_node, current);
+
+	if (!consume(GDScriptTokenizer::Token::IDENTIFIER, R"(Expected identifier for the struct name after "struct".)")) {
+		complete_extents(struct_node);
+		return nullptr;
+	}
+
+	struct_node->identifier = parse_identifier();
+	update_extents(struct_node);
+
+	if (!consume(GDScriptTokenizer::Token::COLON, R"(Expected ":" after struct name.)")) {
+		complete_extents(struct_node);
+		return nullptr;
+	}
+
+	if (!consume(GDScriptTokenizer::Token::NEWLINE, R"(Expected newline after struct name.)")) {
+		complete_extents(struct_node);
+		return nullptr;
+	}
+
+	if (!consume(GDScriptTokenizer::Token::INDENT, R"(Expected indented block after struct declaration.)")) {
+		complete_extents(struct_node);
+		return struct_node;
+	}
+
+	while (!check(GDScriptTokenizer::Token::DEDENT) && !is_at_end()) {
+		if (match(GDScriptTokenizer::Token::VAR)) {
+			VariableNode *member = parse_variable(false, false);
+			if (member != nullptr) {
+				struct_node->members.push_back(member);
+			}
+		} else {
+			make_completion_context(COMPLETION_IDENTIFIER, nullptr);
+			push_error(vformat(R"(Unexpected "%s" in struct body.)", current.get_name()));
+			advance();
+		}
+	}
+
+	consume(GDScriptTokenizer::Token::DEDENT, R"(Missing unindent at the end of the struct body.)");
+	complete_extents(struct_node);
+
+	return struct_node;
+}
+
 void GDScriptParser::parse_class_name() {
 	if (consume(GDScriptTokenizer::Token::IDENTIFIER, R"(Expected identifier for the global class name after "class_name".)")) {
 		current_class->identifier = parse_identifier();
@@ -1014,6 +1061,9 @@ void GDScriptParser::parse_class_body(bool p_is_multiline) {
 					push_error(R"(Expected "func" or "var" after "static".)");
 				}
 			} break;
+			case GDScriptTokenizer::Token::STRUCT:
+				parse_class_member(&GDScriptParser::parse_struct, AnnotationInfo::STRUCT, "struct");
+				break;
 			case GDScriptTokenizer::Token::ANNOTATION: {
 				advance();
 
@@ -3992,6 +4042,7 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
 		{ &GDScriptParser::parse_self,                   	nullptr,                                        PREC_NONE }, // SELF,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // SIGNAL,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // STATIC,
+		{ nullptr,                                          nullptr,                                        PREC_NONE }, // STRUCT,
 		{ &GDScriptParser::parse_call,						nullptr,                                        PREC_NONE }, // SUPER,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // TRAIT,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // VAR,
@@ -4037,6 +4088,29 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
 	return &rules[p_token_type];
 }
 
+StructInfo GDScriptParser::StructNode::make_struct_info() const {
+	// TODO: should the struct's name be the identifier name e.g. "MyStruct" or the native_type, e.g. "res://main.gd.MyStruct"?
+	StructInfo struct_info = StructInfo(datatype.native_type, members.size());
+	//StructInfo struct_info = StructInfo(identifier->name, members.size());
+	for (int i = 0; i < struct_info.count; i++) {
+		const GDScriptParser::VariableNode *member = members[i];
+		Variant default_value;
+		if (member->initializer) {
+			default_value = member->initializer->reduced_value;
+		} else {
+			VariantInternal::initialize(&default_value, member->datatype.builtin_type);
+		}
+		struct_info.set(i,
+				member->identifier->name,
+				member->datatype.builtin_type,
+				member->datatype.native_type,
+				nullptr,
+				default_value);
+		//TODO: does not yet support nested structs.
+	}
+	return struct_info;
+}
+
 bool GDScriptParser::SuiteNode::has_local(const StringName &p_name) const {
 	if (locals_indices.has(p_name)) {
 		return true;
@@ -4436,6 +4510,11 @@ bool GDScriptParser::export_annotations(AnnotationNode *p_annotation, Node *p_ta
 				variable->export_info.hint = PROPERTY_HINT_NONE;
 				variable->export_info.hint_string = String();
 				break;
+			case GDScriptParser::DataType::STRUCT:
+				variable->export_info.type = export_type.builtin_type;
+				variable->export_info.hint = PROPERTY_HINT_ARRAY_TYPE;
+				variable->export_info.hint_string = export_type.native_type;
+				break;
 			case GDScriptParser::DataType::NATIVE:
 			case GDScriptParser::DataType::SCRIPT:
 			case GDScriptParser::DataType::CLASS: {
@@ -4724,24 +4803,27 @@ bool GDScriptParser::export_group_annotations(AnnotationNode *p_annotation, Node
 	switch (t_usage) {
 		case PROPERTY_USAGE_CATEGORY: {
 			p_annotation->export_info.usage = t_usage;
-		} break;
+			return true;
+		}
 
 		case PROPERTY_USAGE_GROUP: {
 			p_annotation->export_info.usage = t_usage;
 			if (p_annotation->resolved_arguments.size() == 2) {
 				p_annotation->export_info.hint_string = p_annotation->resolved_arguments[1];
 			}
-		} break;
+			return true;
+		}
 
 		case PROPERTY_USAGE_SUBGROUP: {
 			p_annotation->export_info.usage = t_usage;
 			if (p_annotation->resolved_arguments.size() == 2) {
 				p_annotation->export_info.hint_string = p_annotation->resolved_arguments[1];
 			}
-		} break;
+			return true;
+		}
+		default:
+			return true;
 	}
-
-	return true;
 }
 
 bool GDScriptParser::warning_annotations(AnnotationNode *p_annotation, Node *p_target, ClassNode *p_class) {
@@ -4942,6 +5024,7 @@ String GDScriptParser::DataType::to_string() const {
 				return vformat("Dictionary[%s, %s]", get_container_element_type_or_variant(0).to_string(), get_container_element_type_or_variant(1).to_string());
 			}
 			return Variant::get_type_name(builtin_type);
+		case STRUCT:
 		case NATIVE:
 			if (is_meta_type) {
 				return GDScriptNativeClass::get_class_static();
@@ -4990,6 +5073,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 	}
 
 	switch (kind) {
+		case STRUCT:
 		case BUILTIN:
 			result.type = builtin_type;
 			if (builtin_type == Variant::ARRAY && has_container_element_type(0)) {
@@ -4999,6 +5083,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 						result.hint = PROPERTY_HINT_ARRAY_TYPE;
 						result.hint_string = Variant::get_type_name(elem_type.builtin_type);
 						break;
+					case STRUCT:
 					case NATIVE:
 						result.hint = PROPERTY_HINT_ARRAY_TYPE;
 						result.hint_string = elem_type.native_type;
@@ -5143,6 +5228,23 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 	return result;
 }
 
+const StructInfo *GDScriptParser::DataType::get_struct_info() {
+	if (const StructInfo *info = ClassDB::get_struct_info(native_type)) {
+		return info;
+	}
+	if (unlikely(!struct_type)) {
+		return nullptr;
+	}
+	if (unlikely(!struct_type->resolved)) {
+		return nullptr;
+	}
+	Ref<GDScript> gdscript = script_type;
+	if (unlikely(gdscript.is_null())) {
+		return nullptr;
+	}
+	return gdscript->get_script_struct_info(native_type);
+}
+
 static Variant::Type _variant_type_to_typed_array_element_type(Variant::Type p_type) {
 	switch (p_type) {
 		case Variant::PACKED_BYTE_ARRAY:
@@ -5545,6 +5647,9 @@ void GDScriptParser::TreePrinter::print_class(ClassNode *p_class) {
 				break;
 			case ClassNode::Member::ENUM_VALUE:
 				break; // Nothing. Will be printed by enum.
+			case ClassNode::Member::STRUCT:
+				print_struct(m.m_struct);
+				break;
 			case ClassNode::Member::GROUP:
 				break; // Nothing. Groups are only used by inspector.
 			case ClassNode::Member::UNDEFINED:
@@ -5976,6 +6081,18 @@ void GDScriptParser::TreePrinter::print_statement(Node *p_statement) {
 	}
 }
 
+void GDScriptParser::TreePrinter::print_struct(StructNode *p_struct) {
+	push_text("Struct ");
+	print_identifier(p_struct->identifier);
+
+	push_line(" :");
+	increase_indent();
+	for (int i = 0; i < p_struct->members.size(); i++) {
+		print_variable(p_struct->members[i]);
+	}
+	decrease_indent();
+}
+
 void GDScriptParser::TreePrinter::print_suite(SuiteNode *p_suite) {
 	for (int i = 0; i < p_suite->statements.size(); i++) {
 		print_statement(p_suite->statements[i]);
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 7f64ae902b03..1cb719237813 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -91,6 +91,7 @@ class GDScriptParser {
 	struct ReturnNode;
 	struct SelfNode;
 	struct SignalNode;
+	struct StructNode;
 	struct SubscriptNode;
 	struct SuiteNode;
 	struct TernaryOpNode;
@@ -105,11 +106,12 @@ class GDScriptParser {
 		Vector<DataType> container_element_types;
 
 		enum Kind {
-			BUILTIN,
-			NATIVE,
-			SCRIPT,
+			BUILTIN, // All variants except Object.
+			NATIVE, // Engine classes.
+			SCRIPT, // User classes.
 			CLASS, // GDScript.
 			ENUM, // Enumeration.
+			STRUCT, // Struct.
 			VARIANT, // Can be any type.
 			RESOLVING, // Currently resolving.
 			UNRESOLVED,
@@ -136,7 +138,9 @@ class GDScriptParser {
 		Ref<Script> script_type;
 		String script_path;
 		ClassNode *class_type = nullptr;
+		StructNode *struct_type = nullptr;
 
+	public:
 		MethodInfo method_info; // For callable/signals.
 		HashMap<StringName, int64_t> enum_values; // For enums.
 
@@ -149,6 +153,7 @@ class GDScriptParser {
 		String to_string() const;
 		_FORCE_INLINE_ String to_string_strict() const { return is_hard_type() ? to_string() : "Variant"; }
 		PropertyInfo to_property_info(const String &p_name) const;
+		const StructInfo *get_struct_info();
 
 		_FORCE_INLINE_ static DataType get_variant_type() { // Default DataType for container elements.
 			DataType datatype;
@@ -210,6 +215,7 @@ class GDScriptParser {
 				case BUILTIN:
 					return builtin_type == p_other.builtin_type;
 				case NATIVE:
+				case STRUCT:
 				case ENUM: // Enums use native_type to identify the enum and its base class.
 					return native_type == p_other.native_type;
 				case SCRIPT:
@@ -245,6 +251,7 @@ class GDScriptParser {
 			method_info = p_other.method_info;
 			enum_values = p_other.enum_values;
 			container_element_types = p_other.container_element_types;
+			struct_type = p_other.struct_type;
 		}
 
 		DataType() = default;
@@ -324,6 +331,7 @@ class GDScriptParser {
 			RETURN,
 			SELF,
 			SIGNAL,
+			STRUCT,
 			SUBSCRIPT,
 			SUITE,
 			TERNARY_OPERATOR,
@@ -552,6 +560,25 @@ class GDScriptParser {
 		}
 	};
 
+	struct StructNode : public Node {
+		IdentifierNode *identifier = nullptr;
+		Vector<VariableNode *> members;
+		int index = -1;
+		bool resolved = false;
+		int line = 0;
+		int leftmost_column = 0;
+		int rightmost_column = 0;
+#ifdef TOOLS_ENABLED
+		MemberDocData doc_data;
+#endif // TOOLS_ENABLED
+
+		StructNode() {
+			type = STRUCT;
+		}
+
+		StructInfo make_struct_info() const;
+	};
+
 	struct ClassNode : public Node {
 		struct Member {
 			enum Type {
@@ -564,6 +591,7 @@ class GDScriptParser {
 				ENUM,
 				ENUM_VALUE, // For unnamed enums.
 				GROUP, // For member grouping.
+				STRUCT,
 			};
 
 			Type type = UNDEFINED;
@@ -576,6 +604,7 @@ class GDScriptParser {
 				VariableNode *variable;
 				EnumNode *m_enum;
 				AnnotationNode *annotation;
+				StructNode *m_struct;
 			};
 			EnumNode::Value enum_value;
 
@@ -601,6 +630,8 @@ class GDScriptParser {
 						return enum_value.identifier->name;
 					case GROUP:
 						return annotation->export_info.name;
+					case STRUCT:
+						return m_struct->identifier->name;
 				}
 				return "";
 			}
@@ -625,6 +656,8 @@ class GDScriptParser {
 						return "enum value";
 					case GROUP:
 						return "group";
+					case STRUCT:
+						return "struct";
 				}
 				return "";
 			}
@@ -647,6 +680,8 @@ class GDScriptParser {
 						return signal->start_line;
 					case GROUP:
 						return annotation->start_line;
+					case STRUCT:
+						return m_struct->start_line;
 					case UNDEFINED:
 						ERR_FAIL_V_MSG(-1, "Reaching undefined member type.");
 				}
@@ -671,6 +706,8 @@ class GDScriptParser {
 						return signal->get_datatype();
 					case GROUP:
 						return DataType();
+					case STRUCT:
+						return m_struct->get_datatype();
 					case UNDEFINED:
 						return DataType();
 				}
@@ -695,6 +732,8 @@ class GDScriptParser {
 						return signal;
 					case GROUP:
 						return annotation;
+					case STRUCT:
+						return m_struct;
 					case UNDEFINED:
 						return nullptr;
 				}
@@ -735,6 +774,10 @@ class GDScriptParser {
 				type = GROUP;
 				annotation = p_annotation;
 			}
+			Member(StructNode *p_struct) {
+				type = STRUCT;
+				m_struct = p_struct;
+			}
 		};
 
 		IdentifierNode *identifier = nullptr;
@@ -893,6 +936,7 @@ class GDScriptParser {
 			MEMBER_FUNCTION,
 			MEMBER_SIGNAL,
 			MEMBER_CLASS,
+			MEMBER_STRUCT,
 			INHERITED_VARIABLE,
 			STATIC_VARIABLE,
 		};
@@ -905,6 +949,7 @@ class GDScriptParser {
 			ConstantNode *constant_source;
 			SignalNode *signal_source;
 			FunctionNode *function_source;
+			StructNode *struct_source;
 		};
 		bool function_source_is_static = false; // For non-GDScript scripts.
 
@@ -1385,7 +1430,8 @@ class GDScriptParser {
 			FUNCTION = 1 << 5,
 			STATEMENT = 1 << 6,
 			STANDALONE = 1 << 7,
-			CLASS_LEVEL = CLASS | VARIABLE | CONSTANT | SIGNAL | FUNCTION,
+			STRUCT = 1 << 8,
+			CLASS_LEVEL = CLASS | VARIABLE | CONSTANT | SIGNAL | FUNCTION | STRUCT,
 		};
 		uint32_t target_kind = 0; // Flags.
 		AnnotationAction apply = nullptr;
@@ -1430,6 +1476,7 @@ class GDScriptParser {
 	static ParseRule *get_rule(GDScriptTokenizer::Token::Type p_token_type);
 
 	List<Node *> nodes_in_progress;
+
 	void complete_extents(Node *p_node);
 	void update_extents(Node *p_node);
 	void reset_extents(Node *p_node, GDScriptTokenizer::Token p_token);
@@ -1484,6 +1531,7 @@ class GDScriptParser {
 	// Main blocks.
 	void parse_program();
 	ClassNode *parse_class(bool p_is_static);
+	StructNode *parse_struct(bool p_is_static);
 	void parse_class_name();
 	void parse_extends();
 	void parse_class_body(bool p_is_multiline);
@@ -1643,6 +1691,7 @@ class GDScriptParser {
 		void print_self(SelfNode *p_self);
 		void print_signal(SignalNode *p_signal);
 		void print_statement(Node *p_statement);
+		void print_struct(StructNode *p_struct);
 		void print_subscript(SubscriptNode *p_subscript);
 		void print_suite(SuiteNode *p_suite);
 		void print_ternary_op(TernaryOpNode *p_ternary_op);
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 404b61fb400c..9889a9c89c99 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -118,6 +118,7 @@ static const char *token_names[] = {
 	"self", // SELF,
 	"signal", // SIGNAL,
 	"static", // STATIC,
+	"struct", // STRUCT,
 	"super", // SUPER,
 	"trait", // TRAIT,
 	"var", // VAR,
@@ -237,6 +238,7 @@ bool GDScriptTokenizer::Token::is_node_name() const {
 		case SELF:
 		case SIGNAL:
 		case STATIC:
+		case STRUCT:
 		case SUPER:
 		case TRAIT:
 		case UNDERSCORE:
@@ -526,6 +528,7 @@ GDScriptTokenizer::Token GDScriptTokenizerText::annotation() {
 	KEYWORD("self", Token::SELF)             \
 	KEYWORD("signal", Token::SIGNAL)         \
 	KEYWORD("static", Token::STATIC)         \
+	KEYWORD("struct", Token::STRUCT)         \
 	KEYWORD("super", Token::SUPER)           \
 	KEYWORD_GROUP('t')                       \
 	KEYWORD("trait", Token::TRAIT)           \
diff --git a/modules/gdscript/gdscript_tokenizer.h b/modules/gdscript/gdscript_tokenizer.h
index 5d7637517381..c265aad6668f 100644
--- a/modules/gdscript/gdscript_tokenizer.h
+++ b/modules/gdscript/gdscript_tokenizer.h
@@ -130,6 +130,7 @@ class GDScriptTokenizer {
 			SELF,
 			SIGNAL,
 			STATIC,
+			STRUCT,
 			SUPER,
 			TRAIT,
 			VAR,
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 4617a0dbb9f4..4b7be8171828 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -116,38 +116,45 @@ void GDScriptFunction::_profile_native_call(uint64_t p_t_taken, const String &p_
 #endif // DEBUG_ENABLED
 
 Variant GDScriptFunction::_get_default_variant_for_data_type(const GDScriptDataType &p_data_type) {
-	if (p_data_type.kind == GDScriptDataType::BUILTIN) {
-		if (p_data_type.builtin_type == Variant::ARRAY) {
-			Array array;
-			// Typed array.
-			if (p_data_type.has_container_element_type(0)) {
-				const GDScriptDataType &element_type = p_data_type.get_container_element_type(0);
-				array.set_typed(element_type.builtin_type, element_type.native_type, element_type.script_type);
-			}
-
-			return array;
-		} else if (p_data_type.builtin_type == Variant::DICTIONARY) {
-			Dictionary dict;
-			// Typed dictionary.
-			if (p_data_type.has_container_element_types()) {
-				const GDScriptDataType &key_type = p_data_type.get_container_element_type_or_variant(0);
-				const GDScriptDataType &value_type = p_data_type.get_container_element_type_or_variant(1);
-				dict.set_typed(key_type.builtin_type, key_type.native_type, key_type.script_type, value_type.builtin_type, value_type.native_type, value_type.script_type);
-			}
-
-			return dict;
-		} else {
-			Callable::CallError ce;
-			Variant variant;
-			Variant::construct(p_data_type.builtin_type, variant, nullptr, 0, ce);
+	switch (p_data_type.kind) {
+		case GDScriptDataType::BUILTIN: {
+			switch (p_data_type.builtin_type) {
+				case Variant::ARRAY: {
+					if (const StructInfo *info = p_data_type.get_struct_info()) {
+						return Array(*info);
+					}
+					Array array;
+					// Typed array.
+					if (p_data_type.has_container_element_type(0)) {
+						const GDScriptDataType &element_type = p_data_type.get_container_element_type(0);
+						array.set_typed(element_type.builtin_type, element_type.native_type, element_type.script_type);
+					}
+					return array;
+				}
+				case Variant::DICTIONARY: {
+					Dictionary dict;
+					// Typed dictionary.
+					if (p_data_type.has_container_element_types()) {
+						const GDScriptDataType &key_type = p_data_type.get_container_element_type_or_variant(0);
+						const GDScriptDataType &value_type = p_data_type.get_container_element_type_or_variant(1);
+						dict.set_typed(key_type.builtin_type, key_type.native_type, key_type.script_type, value_type.builtin_type, value_type.native_type, value_type.script_type);
+					}
 
-			ERR_FAIL_COND_V(ce.error != Callable::CallError::CALL_OK, Variant());
+					return dict;
+				}
+				default:
+					Callable::CallError ce;
+					Variant variant;
+					Variant::construct(p_data_type.builtin_type, variant, nullptr, 0, ce);
 
-			return variant;
+					ERR_FAIL_COND_V(ce.error != Callable::CallError::CALL_OK, Variant());
+
+					return variant;
+			}
 		}
+		default:
+			return Variant();
 	}
-
-	return Variant();
 }
 
 String GDScriptFunction::_get_call_error(const String &p_where, const Variant **p_argptrs, const Variant &p_ret, const Callable::CallError &p_err) const {
@@ -267,6 +274,7 @@ void (*type_init_function_table[])(Variant *) = {
 		&&OPCODE_CONSTRUCT_VALIDATED,                    \
 		&&OPCODE_CONSTRUCT_ARRAY,                        \
 		&&OPCODE_CONSTRUCT_TYPED_ARRAY,                  \
+		&&OPCODE_CONSTRUCT_STRUCT,                       \
 		&&OPCODE_CONSTRUCT_DICTIONARY,                   \
 		&&OPCODE_CONSTRUCT_TYPED_DICTIONARY,             \
 		&&OPCODE_CALL,                                   \
@@ -1788,6 +1796,45 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			}
 			DISPATCH_OPCODE;
 
+			OPCODE(OPCODE_CONSTRUCT_STRUCT) {
+				LOAD_INSTRUCTION_ARGS
+				CHECK_SPACE(3 + instr_arg_count);
+				ip += instr_arg_count;
+
+				int argc = _code_ptr[ip + 1];
+				int struct_name_idx = _code_ptr[ip + 2];
+				GD_ERR_BREAK(struct_name_idx < 0 || struct_name_idx >= _global_names_count);
+				const StringName native_type = _global_names_ptr[struct_name_idx];
+
+				// TODO: this ordering will prefer native structs to user structs, which I'm not sure is right
+				// TODO: move this logic to the compiler and/or bytecode generator
+				const StructInfo *struct_info;
+				if (const StructInfo *native_struct_info = ClassDB::get_struct_info(native_type)) {
+					struct_info = native_struct_info;
+				} else {
+					GET_INSTRUCTION_ARG(script_type, argc + 1);
+					const GDScript *gd_script = Object::cast_to<GDScript>(script_type->operator Object *());
+					GD_ERR_BREAK(!gd_script);
+					struct_info = gd_script->get_script_struct_info(native_type);
+				}
+
+				GD_ERR_BREAK(!struct_info);
+				GD_ERR_BREAK(struct_info->count < argc);
+				// TODO: avoid reassigning non-default values
+				Array array = Array(*struct_info);
+				for (int i = 0; i < argc; i++) {
+					array[i] = *(instruction_args[i]);
+				}
+
+				GET_INSTRUCTION_ARG(dst, argc);
+				*dst = Variant(); // Clear potential previous struct.
+
+				*dst = Array(array, *struct_info);
+
+				ip += 3;
+			}
+			DISPATCH_OPCODE;
+
 			OPCODE(OPCODE_CONSTRUCT_DICTIONARY) {
 				LOAD_INSTRUCTION_ARGS
 				CHECK_SPACE(2 + instr_arg_count);
@@ -1808,7 +1855,6 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				*dst = Variant(); // Clear potential previous typed dictionary.
 
 				*dst = dict;
-
 				ip += 2;
 			}
 			DISPATCH_OPCODE;
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index 2a3db4f508d5..54cf9326a3e5 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -268,47 +268,7 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 		switch (m.type) {
 			case ClassNode::Member::VARIABLE: {
 				lsp::DocumentSymbol symbol;
-				symbol.name = m.variable->identifier->name;
-				symbol.kind = m.variable->property == VariableNode::PROP_NONE ? lsp::SymbolKind::Variable : lsp::SymbolKind::Property;
-				symbol.deprecated = false;
-				symbol.range = range_of_node(m.variable);
-				symbol.selectionRange = range_of_node(m.variable->identifier);
-				if (m.variable->exported) {
-					symbol.detail += "@export ";
-				}
-				symbol.detail += "var " + m.variable->identifier->name;
-				if (m.get_datatype().is_hard_type()) {
-					symbol.detail += ": " + m.get_datatype().to_string();
-				}
-				if (m.variable->initializer != nullptr && m.variable->initializer->is_constant) {
-					symbol.detail += " = " + m.variable->initializer->reduced_value.to_json_string();
-				}
-
-				symbol.documentation = m.variable->doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
-
-				if (m.variable->initializer && m.variable->initializer->type == GDScriptParser::Node::LAMBDA) {
-					GDScriptParser::LambdaNode *lambda_node = (GDScriptParser::LambdaNode *)m.variable->initializer;
-					lsp::DocumentSymbol lambda;
-					parse_function_symbol(lambda_node->function, lambda);
-					// Merge lambda into current variable.
-					symbol.children.append_array(lambda.children);
-				}
-
-				if (m.variable->getter && m.variable->getter->type == GDScriptParser::Node::FUNCTION) {
-					lsp::DocumentSymbol get_symbol;
-					parse_function_symbol(m.variable->getter, get_symbol);
-					get_symbol.local = true;
-					symbol.children.push_back(get_symbol);
-				}
-				if (m.variable->setter && m.variable->setter->type == GDScriptParser::Node::FUNCTION) {
-					lsp::DocumentSymbol set_symbol;
-					parse_function_symbol(m.variable->setter, set_symbol);
-					set_symbol.local = true;
-					symbol.children.push_back(set_symbol);
-				}
-
+				parse_variable_symbol(m.variable, symbol);
 				r_symbol.children.push_back(symbol);
 			} break;
 			case ClassNode::Member::CONSTANT: {
@@ -444,6 +404,30 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 
 				r_symbol.children.push_back(symbol);
 			} break;
+			case ClassNode::Member::STRUCT: {
+				lsp::DocumentSymbol struct_symbol;
+
+				struct_symbol.name = m.m_struct->identifier->name;
+				struct_symbol.kind = lsp::SymbolKind::Struct;
+				struct_symbol.deprecated = false;
+				struct_symbol.range = range_of_node(m.m_struct);
+				struct_symbol.selectionRange = range_of_node(m.m_struct->identifier);
+				struct_symbol.documentation = m.m_struct->doc_data.description;
+				struct_symbol.uri = uri;
+				struct_symbol.script_path = path;
+
+				struct_symbol.detail = "struct " + String(m.m_struct->identifier->name) + " {";
+				for (int j = 0; j < m.m_struct->members.size(); j++) {
+					if (j > 0) {
+						struct_symbol.detail += ", ";
+					}
+					lsp::DocumentSymbol symbol;
+					parse_variable_symbol(m.variable, symbol);
+					struct_symbol.children.push_back(symbol);
+				}
+				struct_symbol.detail += "}";
+				r_symbol.children.push_back(struct_symbol);
+			} break;
 			case ClassNode::Member::FUNCTION: {
 				lsp::DocumentSymbol symbol;
 				parse_function_symbol(m.function, symbol);
@@ -462,6 +446,51 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 	}
 }
 
+void ExtendGDScriptParser::parse_variable_symbol(const GDScriptParser::VariableNode *p_var, lsp::DocumentSymbol &r_symbol) {
+	r_symbol.name = p_var->identifier->name;
+	r_symbol.kind = p_var->property == VariableNode::PROP_NONE ? lsp::SymbolKind::Variable : lsp::SymbolKind::Property;
+	r_symbol.deprecated = false;
+	r_symbol.range = range_of_node(p_var);
+	r_symbol.selectionRange = range_of_node(p_var->identifier);
+	if (p_var->exported) {
+		r_symbol.detail += "@export ";
+	}
+	r_symbol.detail += "var " + p_var->identifier->name;
+	if (p_var->get_datatype().is_hard_type()) {
+		r_symbol.detail += ": " + p_var->get_datatype().to_string();
+	}
+	if (p_var->initializer != nullptr && p_var->initializer->is_constant) {
+		r_symbol.detail += " = " + p_var->initializer->reduced_value.to_json_string();
+	}
+
+	r_symbol.documentation = p_var->doc_data.description;
+	r_symbol.uri = get_uri();
+	r_symbol.script_path = path;
+
+	if (p_var->initializer && p_var->initializer->type == GDScriptParser::Node::LAMBDA) {
+		GDScriptParser::LambdaNode *lambda_node = (GDScriptParser::LambdaNode *)p_var->initializer;
+		lsp::DocumentSymbol lambda;
+		parse_function_symbol(lambda_node->function, lambda);
+		// Merge lambda into current variable.
+		r_symbol.children.append_array(lambda.children);
+	}
+
+	if (p_var->getter && p_var->getter->type == GDScriptParser::Node::FUNCTION) {
+		lsp::DocumentSymbol get_symbol;
+		parse_function_symbol(p_var->getter, get_symbol);
+		get_symbol.local = true;
+		r_symbol.children.push_back(get_symbol);
+	}
+	if (p_var->setter && p_var->setter->type == GDScriptParser::Node::FUNCTION) {
+		lsp::DocumentSymbol set_symbol;
+		parse_function_symbol(p_var->setter, set_symbol);
+		set_symbol.local = true;
+		r_symbol.children.push_back(set_symbol);
+	}
+
+	r_symbol.children.push_back(r_symbol);
+}
+
 void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol) {
 	const String uri = get_uri();
 
@@ -858,23 +887,37 @@ const Array &ExtendGDScriptParser::get_member_completions() {
 	return member_completions;
 }
 
-Dictionary ExtendGDScriptParser::dump_function_api(const GDScriptParser::FunctionNode *p_func) const {
+Dictionary ExtendGDScriptParser::dump_variable_api(const GDScriptParser::VariableNode &p_var) const {
+	Dictionary api;
+	api["name"] = p_var.identifier->name;
+	api["data_type"] = p_var.get_datatype().to_string();
+	api["default_value"] = p_var.initializer != nullptr ? p_var.initializer->reduced_value : Variant();
+	api["setter"] = p_var.setter ? ("@" + String(p_var.identifier->name) + "_setter") : (p_var.setter_pointer != nullptr ? String(p_var.setter_pointer->name) : String());
+	api["getter"] = p_var.getter ? ("@" + String(p_var.identifier->name) + "_getter") : (p_var.getter_pointer != nullptr ? String(p_var.getter_pointer->name) : String());
+	api["export"] = p_var.exported;
+	if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(p_var.start_line))) {
+		api["signature"] = symbol->detail;
+		api["description"] = symbol->documentation;
+	}
+	return api;
+}
+
+Dictionary ExtendGDScriptParser::dump_function_api(const GDScriptParser::FunctionNode &p_func) const {
 	Dictionary func;
-	ERR_FAIL_NULL_V(p_func, func);
-	func["name"] = p_func->identifier->name;
-	func["return_type"] = p_func->get_datatype().to_string();
-	func["rpc_config"] = p_func->rpc_config;
+	func["name"] = p_func.identifier->name;
+	func["return_type"] = p_func.get_datatype().to_string();
+	func["rpc_config"] = p_func.rpc_config;
 	Array parameters;
-	for (int i = 0; i < p_func->parameters.size(); i++) {
+	for (int i = 0; i < p_func.parameters.size(); i++) {
 		Dictionary arg;
-		arg["name"] = p_func->parameters[i]->identifier->name;
-		arg["type"] = p_func->parameters[i]->get_datatype().to_string();
-		if (p_func->parameters[i]->initializer != nullptr) {
-			arg["default_value"] = p_func->parameters[i]->initializer->reduced_value;
+		arg["name"] = p_func.parameters[i]->identifier->name;
+		arg["type"] = p_func.parameters[i]->get_datatype().to_string();
+		if (p_func.parameters[i]->initializer != nullptr) {
+			arg["default_value"] = p_func.parameters[i]->initializer->reduced_value;
 		}
 		parameters.push_back(arg);
 	}
-	if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(p_func->start_line))) {
+	if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(p_func.start_line))) {
 		func["signature"] = symbol->detail;
 		func["description"] = symbol->documentation;
 	}
@@ -903,6 +946,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 	}
 
 	Array nested_classes;
+	Array structs;
 	Array constants;
 	Array class_members;
 	Array signals;
@@ -953,19 +997,27 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 				}
 				constants.push_back(api);
 			} break;
-			case ClassNode::Member::VARIABLE: {
-				Dictionary api;
-				api["name"] = m.variable->identifier->name;
-				api["data_type"] = m.variable->get_datatype().to_string();
-				api["default_value"] = m.variable->initializer != nullptr ? m.variable->initializer->reduced_value : Variant();
-				api["setter"] = m.variable->setter ? ("@" + String(m.variable->identifier->name) + "_setter") : (m.variable->setter_pointer != nullptr ? String(m.variable->setter_pointer->name) : String());
-				api["getter"] = m.variable->getter ? ("@" + String(m.variable->identifier->name) + "_getter") : (m.variable->getter_pointer != nullptr ? String(m.variable->getter_pointer->name) : String());
-				api["export"] = m.variable->exported;
-				if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m.variable->start_line))) {
-					api["signature"] = symbol->detail;
-					api["description"] = symbol->documentation;
+			case ClassNode::Member::STRUCT: {
+				Dictionary struct_api;
+				struct_api["name"] = m.m_struct->identifier->name;
+				struct_api["data_type"] = m.m_struct->get_datatype().to_string();
+				Array struct_members;
+
+				for (int j = 0; j < m.m_struct->members.size(); j++) {
+					struct_members.push_back(dump_variable_api(*m.m_struct->members[j]));
 				}
-				class_members.push_back(api);
+
+				struct_api["members"] = struct_members;
+
+				if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m.m_struct->start_line))) {
+					struct_api["signature"] = symbol->detail;
+					struct_api["description"] = symbol->documentation;
+				}
+
+				structs.push_back(struct_api);
+			} break;
+			case ClassNode::Member::VARIABLE: {
+				class_members.push_back(dump_variable_api(*m.variable));
 			} break;
 			case ClassNode::Member::SIGNAL: {
 				Dictionary api;
@@ -983,9 +1035,9 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 			} break;
 			case ClassNode::Member::FUNCTION: {
 				if (m.function->is_static) {
-					static_functions.append(dump_function_api(m.function));
+					static_functions.append(dump_function_api(*m.function));
 				} else {
-					methods.append(dump_function_api(m.function));
+					methods.append(dump_function_api(*m.function));
 				}
 			} break;
 			case ClassNode::Member::GROUP:
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.h b/modules/gdscript/language_server/gdscript_extend_parser.h
index 239f7d9f43f4..2af5c44d44e5 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.h
+++ b/modules/gdscript/language_server/gdscript_extend_parser.h
@@ -128,9 +128,11 @@ class ExtendGDScriptParser : public GDScriptParser {
 	void update_symbols();
 	void update_document_links(const String &p_code);
 	void parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol &r_symbol);
+	void parse_variable_symbol(const GDScriptParser::VariableNode *p_var, lsp::DocumentSymbol &r_symbol);
 	void parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol);
 
-	Dictionary dump_function_api(const GDScriptParser::FunctionNode *p_func) const;
+	Dictionary dump_variable_api(const GDScriptParser::VariableNode &p_var) const;
+	Dictionary dump_function_api(const GDScriptParser::FunctionNode &p_func) const;
 	Dictionary dump_class_api(const GDScriptParser::ClassNode *p_class) const;
 
 	const lsp::DocumentSymbol *search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent, const String &p_symbol_name = "") const;
diff --git a/modules/gdscript/language_server/godot_lsp.h b/modules/gdscript/language_server/godot_lsp.h
index 6e19cd7a233c..6585ae31c051 100644
--- a/modules/gdscript/language_server/godot_lsp.h
+++ b/modules/gdscript/language_server/godot_lsp.h
@@ -1270,6 +1270,9 @@ struct DocumentSymbol {
 			case lsp::SymbolKind::Enum:
 				item.kind = lsp::CompletionItemKind::Enum;
 				break;
+			case lsp::SymbolKind::Struct:
+				item.kind = lsp::CompletionItemKind::Struct;
+				break;
 			case lsp::SymbolKind::Class:
 				item.kind = lsp::CompletionItemKind::Class;
 				break;
@@ -1939,6 +1942,7 @@ static String marked_documentation(const String &p_bbcode) {
 			line = line.replace("[member ", "`");
 			line = line.replace("[signal ", "`");
 			line = line.replace("[enum ", "`");
+			line = line.replace("[struct ", "`");
 			line = line.replace("[constant ", "`");
 			line = line.replace("[", "`");
 			line = line.replace("]", "`");
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_body.gd b/modules/gdscript/tests/scripts/parser/errors/struct_no_body.gd
new file mode 100644
index 000000000000..996e8559f89d
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_body.gd
@@ -0,0 +1,5 @@
+struct Test:
+
+
+func test():
+    pass
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_body.out b/modules/gdscript/tests/scripts/parser/errors/struct_no_body.out
new file mode 100644
index 000000000000..e59d7238b5f6
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_body.out
@@ -0,0 +1,2 @@
+GDTEST_PARSER_ERROR
+Expected indented block after struct declaration.
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.gd b/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.gd
new file mode 100644
index 000000000000..41c29e3e4f7d
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.gd
@@ -0,0 +1,5 @@
+struct Test
+    var oops
+
+func test():
+    pass
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.out b/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.out
new file mode 100644
index 000000000000..714557d673be
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_colon.out
@@ -0,0 +1,2 @@
+GDTEST_PARSER_ERROR
+Expected ":" after struct name.
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.gd b/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.gd
new file mode 100644
index 000000000000..bd0d5c533363
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.gd
@@ -0,0 +1,5 @@
+struct     :
+    var oops
+
+func test():
+    pass
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.out b/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.out
new file mode 100644
index 000000000000..2d2befc3fa30
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_identifier.out
@@ -0,0 +1,2 @@
+GDTEST_PARSER_ERROR
+Expected identifier for the struct name after "struct".
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_var.gd b/modules/gdscript/tests/scripts/parser/errors/struct_no_var.gd
new file mode 100644
index 000000000000..77aace3e00e6
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_var.gd
@@ -0,0 +1,5 @@
+struct Test:
+    oops
+
+func test():
+    pass
diff --git a/modules/gdscript/tests/scripts/parser/errors/struct_no_var.out b/modules/gdscript/tests/scripts/parser/errors/struct_no_var.out
new file mode 100644
index 000000000000..4c69b559814b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/struct_no_var.out
@@ -0,0 +1,2 @@
+GDTEST_PARSER_ERROR
+Unexpected "Identifier" in struct body.
diff --git a/modules/gdscript/tests/scripts/parser/features/struct.gd b/modules/gdscript/tests/scripts/parser/features/struct.gd
new file mode 100644
index 000000000000..2dc332e5d9b3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/features/struct.gd
@@ -0,0 +1,11 @@
+var test_struct: Test
+
+struct Test:
+    var number = 25
+    var string = "hello"
+    var arr = [6]
+    var dict = {"hi" : "ho"}
+
+
+func test():
+    print(test_struct)
diff --git a/modules/gdscript/tests/scripts/parser/features/struct.out b/modules/gdscript/tests/scripts/parser/features/struct.out
new file mode 100644
index 000000000000..4ae0be73cb13
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/features/struct.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+[number: 25, string: "hello", arr: [6], dict: { "hi": "ho" }]
diff --git a/modules/gdscript/tests/scripts/runtime/features/struct_constructor.gd b/modules/gdscript/tests/scripts/runtime/features/struct_constructor.gd
new file mode 100644
index 000000000000..59ded2f1f0fa
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/struct_constructor.gd
@@ -0,0 +1,16 @@
+struct TestStruct:
+	var test_int : int = 1
+	var test_float : float = 2.5
+	var test_dict : Dictionary = {4 : 5}
+	var test_array : Array = [3, "Godot"]
+
+func test():
+	print(TestStruct())
+	print(TestStruct(3))
+	print(TestStruct(3, 1.5))
+	print(TestStruct(3, 1.5, {"key": "val"}))
+	print(TestStruct(3, 1.5, {"key": "val"}, [0.5]))
+
+	print(PropertyInfo())
+	print(Object.PropertyInfo())
+	# print(self.TestStruct())
diff --git a/modules/gdscript/tests/scripts/runtime/features/struct_constructor.out b/modules/gdscript/tests/scripts/runtime/features/struct_constructor.out
new file mode 100644
index 000000000000..8583066b786f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/struct_constructor.out
@@ -0,0 +1,8 @@
+GDTEST_OK
+[test_int: 1, test_float: 2.5, test_dict: { 4: 5 }, test_array: [3, "Godot"]]
+[test_int: 3, test_float: 2.5, test_dict: { 4: 5 }, test_array: [3, "Godot"]]
+[test_int: 3, test_float: 1.5, test_dict: { 4: 5 }, test_array: [3, "Godot"]]
+[test_int: 3, test_float: 1.5, test_dict: { "key": "val" }, test_array: [3, "Godot"]]
+[test_int: 3, test_float: 1.5, test_dict: { "key": "val" }, test_array: [0.5]]
+[name: "", class_name: &"", type: 0, hint: 0, hint_string: "", usage: 6]
+[name: "", class_name: &"", type: 0, hint: 0, hint_string: "", usage: 6]
diff --git a/modules/gdscript/tests/scripts/runtime/features/struct_native.gd b/modules/gdscript/tests/scripts/runtime/features/struct_native.gd
new file mode 100644
index 000000000000..47eca69f3145
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/struct_native.gd
@@ -0,0 +1,8 @@
+var test_struct: PropertyInfo
+
+
+func test():
+    print(test_struct)
+    print(test_struct.name)
+    test_struct.name = "test"
+    print(test_struct.name)
diff --git a/modules/gdscript/tests/scripts/runtime/features/struct_native.out b/modules/gdscript/tests/scripts/runtime/features/struct_native.out
new file mode 100644
index 000000000000..b9587ba008e7
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/struct_native.out
@@ -0,0 +1,4 @@
+GDTEST_OK
+[name: "", class_name: &"", type: 0, hint: 0, hint_string: "", usage: 6]
+
+test
diff --git a/scene/gui/code_edit.cpp b/scene/gui/code_edit.cpp
index 635228670d08..8606d139bff2 100644
--- a/scene/gui/code_edit.cpp
+++ b/scene/gui/code_edit.cpp
@@ -2730,6 +2730,7 @@ void CodeEdit::_bind_methods() {
 	BIND_ENUM_CONSTANT(KIND_NODE_PATH);
 	BIND_ENUM_CONSTANT(KIND_FILE_PATH);
 	BIND_ENUM_CONSTANT(KIND_PLAIN_TEXT);
+	BIND_ENUM_CONSTANT(KIND_STRUCT);
 
 	BIND_ENUM_CONSTANT(LOCATION_LOCAL);
 	BIND_ENUM_CONSTANT(LOCATION_PARENT_MASK);
diff --git a/scene/gui/code_edit.h b/scene/gui/code_edit.h
index ab443e95e147..5c24724d2200 100644
--- a/scene/gui/code_edit.h
+++ b/scene/gui/code_edit.h
@@ -51,6 +51,7 @@ class CodeEdit : public TextEdit {
 		KIND_NODE_PATH,
 		KIND_FILE_PATH,
 		KIND_PLAIN_TEXT,
+		KIND_STRUCT,
 	};
 
 	// core/object/script_language.h - ScriptLanguage::CodeCompletionLocation