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/doc/classes/CodeEdit.xml b/doc/classes/CodeEdit.xml
index 136b8e5fc5d8..2149a7827fbb 100644
--- a/doc/classes/CodeEdit.xml
+++ b/doc/classes/CodeEdit.xml
@@ -620,31 +620,31 @@
 		<constant name="KIND_CLASS" value="0" enum="CodeCompletionKind">
 			Marks the option as a class.
 		</constant>
-		<constant name="KIND_FUNCTION" value="1" enum="CodeCompletionKind">
+		<constant name="KIND_FUNCTION" value="2" enum="CodeCompletionKind">
 			Marks the option as a function.
 		</constant>
-		<constant name="KIND_SIGNAL" value="2" enum="CodeCompletionKind">
+		<constant name="KIND_SIGNAL" value="3" enum="CodeCompletionKind">
 			Marks the option as a Godot signal.
 		</constant>
-		<constant name="KIND_VARIABLE" value="3" enum="CodeCompletionKind">
+		<constant name="KIND_VARIABLE" value="4" enum="CodeCompletionKind">
 			Marks the option as a variable.
 		</constant>
-		<constant name="KIND_MEMBER" value="4" enum="CodeCompletionKind">
+		<constant name="KIND_MEMBER" value="5" enum="CodeCompletionKind">
 			Marks the option as a member.
 		</constant>
-		<constant name="KIND_ENUM" value="5" enum="CodeCompletionKind">
+		<constant name="KIND_ENUM" value="6" enum="CodeCompletionKind">
 			Marks the option as an enum entry.
 		</constant>
-		<constant name="KIND_CONSTANT" value="6" enum="CodeCompletionKind">
+		<constant name="KIND_CONSTANT" value="7" enum="CodeCompletionKind">
 			Marks the option as a constant.
 		</constant>
-		<constant name="KIND_NODE_PATH" value="7" enum="CodeCompletionKind">
+		<constant name="KIND_NODE_PATH" value="8" enum="CodeCompletionKind">
 			Marks the option as a Godot node path.
 		</constant>
-		<constant name="KIND_FILE_PATH" value="8" enum="CodeCompletionKind">
+		<constant name="KIND_FILE_PATH" value="9" enum="CodeCompletionKind">
 			Marks the option as a file path.
 		</constant>
-		<constant name="KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind">
+		<constant name="KIND_PLAIN_TEXT" value="10" enum="CodeCompletionKind">
 			Marks the option as unclassified or plain text.
 		</constant>
 		<constant name="LOCATION_LOCAL" value="0" enum="CodeCompletionLocation">
diff --git a/doc/classes/ScriptLanguageExtension.xml b/doc/classes/ScriptLanguageExtension.xml
index f9d9e4f513e1..b89369b089cb 100644
--- a/doc/classes/ScriptLanguageExtension.xml
+++ b/doc/classes/ScriptLanguageExtension.xml
@@ -407,25 +407,25 @@
 		</constant>
 		<constant name="CODE_COMPLETION_KIND_CLASS" value="0" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_FUNCTION" value="1" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_FUNCTION" value="2" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_SIGNAL" value="2" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_SIGNAL" value="3" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_VARIABLE" value="3" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_VARIABLE" value="4" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_MEMBER" value="4" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_MEMBER" value="5" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_ENUM" value="5" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_ENUM" value="6" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_CONSTANT" value="6" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_CONSTANT" value="7" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_NODE_PATH" value="7" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_NODE_PATH" value="8" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_FILE_PATH" value="8" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_FILE_PATH" value="9" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind">
+		<constant name="CODE_COMPLETION_KIND_PLAIN_TEXT" value="10" enum="CodeCompletionKind">
 		</constant>
-		<constant name="CODE_COMPLETION_KIND_MAX" value="10" enum="CodeCompletionKind">
+		<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..73e5bd60d7ea 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,61 @@ 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);
+					}
+				}
+				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 +5496,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 +5610,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 +5829,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) {
-			// 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.");
+	switch (p_base_type.kind) {
+		case GDScriptParser::DataType::ENUM: {
+			was_enum = true;
+			if (p_base_type.is_meta_type) {
+				// 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;
+			}
 		}
-		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);
+		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 +5895,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 +6009,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 +6036,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 +6134,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 +6168,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 +6310,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 +6368,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 +6406,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 +6415,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..0bf3970d0dfa 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
+				}
 				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.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