diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp
index 7f15eca11dc4..c9a31384d350 100644
--- a/editor/editor_help.cpp
+++ b/editor/editor_help.cpp
@@ -1997,7 +1997,8 @@ void EditorHelp::_help_callback(const String &p_topic) {
 	}
 }
 
-static void _add_text_to_rt(const String &p_bbcode, RichTextLabel *p_rt, Control *p_owner_node, const String &p_class = "") {
+// TODO: Should probably move this to a shared utility file/class so it can be accessed by both 'editor_help.cpp' and 'symbol_tooltip.cpp'
+void _add_text_to_rt(const String &p_bbcode, RichTextLabel *p_rt, Control *p_owner_node, const String &p_class) {
 	DocTools *doc = EditorHelp::get_doc_data();
 	String base_path;
 
diff --git a/editor/editor_help.h b/editor/editor_help.h
index 49d13c552281..17a29cef9b26 100644
--- a/editor/editor_help.h
+++ b/editor/editor_help.h
@@ -283,6 +283,8 @@ class EditorHelpBit : public MarginContainer {
 	EditorHelpBit();
 };
 
+void _add_text_to_rt(const String &p_bbcode, RichTextLabel *p_rt, Control *p_owner_node, const String &p_class = "");
+
 class EditorHelpTooltip : public EditorHelpBit {
 	GDCLASS(EditorHelpTooltip, EditorHelpBit);
 
diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp
index 06aedecd0ee7..3ad92102afff 100644
--- a/editor/plugins/script_text_editor.cpp
+++ b/editor/plugins/script_text_editor.cpp
@@ -1948,6 +1948,7 @@ void ScriptTextEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data
 
 void ScriptTextEditor::_text_edit_gui_input(const Ref<InputEvent> &ev) {
 	Ref<InputEventMouseButton> mb = ev;
+	Ref<InputEventMouseMotion> mm = ev;
 	Ref<InputEventKey> k = ev;
 	Point2 local_pos;
 	bool create_menu = false;
@@ -1956,6 +1957,10 @@ void ScriptTextEditor::_text_edit_gui_input(const Ref<InputEvent> &ev) {
 	if (mb.is_valid() && mb->get_button_index() == MouseButton::RIGHT && mb->is_pressed()) {
 		local_pos = mb->get_global_position() - tx->get_global_position();
 		create_menu = true;
+	} else if (mm.is_valid()) {
+		if (script->is_valid() && (script->has_source_code() || script->get_path().is_resource_file())) {
+			symbol_tooltip->update_symbol_tooltip(mm->get_position(), script);
+		}
 	} else if (k.is_valid() && k->is_action("ui_menu", true)) {
 		tx->adjust_viewport_to_caret(0);
 		local_pos = tx->get_caret_draw_pos(0);
@@ -2416,6 +2421,9 @@ ScriptTextEditor::ScriptTextEditor() {
 	connection_info_dialog = memnew(ConnectionInfoDialog);
 
 	SET_DRAG_FORWARDING_GCD(code_editor->get_text_editor(), ScriptTextEditor);
+
+	symbol_tooltip = memnew(SymbolTooltip(code_editor->get_text_editor()));
+	add_child(symbol_tooltip);
 }
 
 ScriptTextEditor::~ScriptTextEditor() {
diff --git a/editor/plugins/script_text_editor.h b/editor/plugins/script_text_editor.h
index 8c0ba6d7e669..87f4e2cccef7 100644
--- a/editor/plugins/script_text_editor.h
+++ b/editor/plugins/script_text_editor.h
@@ -34,6 +34,7 @@
 #include "script_editor_plugin.h"
 
 #include "editor/code_editor.h"
+#include "editor/symbol_tooltip.h"
 #include "scene/gui/color_picker.h"
 #include "scene/gui/dialogs.h"
 #include "scene/gui/tree.h"
@@ -159,6 +160,8 @@ class ScriptTextEditor : public ScriptEditorBase {
 
 	void _enable_code_editor();
 
+	SymbolTooltip *symbol_tooltip = nullptr;
+
 protected:
 	void _update_breakpoint_list();
 	void _breakpoint_item_pressed(int p_idx);
diff --git a/editor/symbol_tooltip.cpp b/editor/symbol_tooltip.cpp
new file mode 100644
index 000000000000..2aa6735cce33
--- /dev/null
+++ b/editor/symbol_tooltip.cpp
@@ -0,0 +1,659 @@
+/**************************************************************************/
+/*  symbol_tooltip.cpp                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "symbol_tooltip.h"
+#include "core/config/project_settings.h"
+#include "editor/plugins/script_text_editor.h"
+#include "editor/editor_string_names.h"
+#include "editor_help.h"
+#include "modules/gdscript/editor/gdscript_highlighter.h"
+#include <queue>
+
+SymbolTooltip::SymbolTooltip(CodeEdit *p_text_editor) :
+		text_editor(p_text_editor) {
+	Ref<GDScriptSyntaxHighlighter> highlighter;
+	highlighter.instantiate();
+
+	// Set the tooltip's theme (PanelContainer's theme)
+	//set_theme(EditorNode::get_singleton()->get_gui_base()->get_theme());
+
+	set_as_top_level(true); // Prevents the tooltip from affecting the editor's layout.
+	hide();
+	/*set_v_size_flags(0);
+	set_h_size_flags(0);*/
+	set_z_index(1000);
+	set_theme(_create_panel_theme());
+	set_v_size_flags(Control::SIZE_SHRINK_BEGIN);
+	//set_size(Size2(400, 400));
+	//set_position(Size2(800, 800));
+	set_process(true);
+	//set_clip_contents(true);
+
+	// Create VBoxContainer to hold the tooltip's header and body.
+	layout_container = memnew(VBoxContainer);
+	layout_container->add_theme_constant_override("separation", 0);
+	layout_container->set_v_size_flags(Control::SIZE_SHRINK_BEGIN);
+	add_child(layout_container);
+
+	// Create RichTextLabel for the tooltip's header.
+	header_label = memnew(TextEdit);
+	header_label->set_focus_mode(Control::FOCUS_ALL);
+	header_label->set_context_menu_enabled(false);
+	header_label->set_h_scroll_visibility(false);
+	header_label->set_v_scroll_visibility(false);
+	header_label->set_syntax_highlighter(highlighter);
+	header_label->set_custom_minimum_size(Size2(50, 45));
+
+	header_label->set_v_size_flags(Control::SIZE_SHRINK_BEGIN);
+	header_label->set_line_wrapping_mode(TextEdit::LINE_WRAPPING_BOUNDARY);
+	header_label->set_fit_content_height_enabled(true);
+
+	//header_label->set_editable(false); // WARNING!! - Enabling this will mess with the theme.
+	//header_label->set_selection_enabled(true);
+	header_label->set_theme(_create_header_label_theme());
+	layout_container->add_child(header_label);
+
+	// Create RichTextLabel for the tooltip's body.
+	body_label = memnew(RichTextLabel);
+	body_label->set_use_bbcode(true);
+	body_label->set_selection_enabled(true);
+	body_label->set_custom_minimum_size(Size2(400, 45));
+	body_label->set_focus_mode(Control::FOCUS_ALL);
+	//body_label->set_v_size_flags(Control::SIZE_EXPAND_FILL);
+	body_label->set_theme(_create_body_label_theme());
+	body_label->set_mouse_filter(Control::MOUSE_FILTER_STOP);
+	body_label->set_context_menu_enabled(true);
+	//body_label->set_fit_content(true); // WARNING!! - Enabling this will cause issues in _update_tooltip_size().
+	body_label->hide();
+	layout_container->add_child(body_label);
+
+	float tooltip_delay_time = ProjectSettings::get_singleton()->get("gui/timers/tooltip_delay_sec");
+	tooltip_delay = memnew(Timer);
+	tooltip_delay->set_one_shot(true);
+	tooltip_delay->set_wait_time(tooltip_delay_time);
+	add_child(tooltip_delay);
+
+	tooltip_delay->connect("timeout", callable_mp(this, &SymbolTooltip::_on_tooltip_delay_timeout));
+
+	mouse_inside = false;
+
+	// Connect the tooltip's update function to the mouse motion signal.
+	// connect("mouse_motion", callable_mp(this, &SymbolTooltip::_update_symbol_tooltip));
+}
+
+SymbolTooltip::~SymbolTooltip() {
+}
+
+void SymbolTooltip::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_PROCESS: {
+			// Note: Child components prevent NOTIFICATION_MOUSE_ENTER and NOTIFICATION_MOUSE_EXIT from working properly.
+			// Get the local mouse position
+			Point2i local_mouse_position = get_global_mouse_position() - get_global_position();
+
+			// Check if it's within the rect of the PanelContainer
+			Rect2 tooltip_rect = Rect2(Point2i(0, 0), get_size());
+			if (tooltip_rect.has_point(local_mouse_position)) {
+				if (is_visible() && !mouse_inside) {
+					// Mouse just entered
+					mouse_inside = true;
+				}
+			} else {
+				if (mouse_inside) {
+					// Mouse just exited
+					mouse_inside = false;
+					if (is_visible()) {
+						_close_tooltip();
+					}
+				}
+			}
+		} break;
+	}
+}
+
+void SymbolTooltip::_on_tooltip_delay_timeout() {
+	print_line("size: " + get_size() + ", vbox_size: " + layout_container->get_size() + ", header_size: " + header_label->get_size() + ", body_size: " + body_label->get_size());
+
+	show();
+}
+
+void SymbolTooltip::_close_tooltip() {
+	tooltip_delay->stop();
+	hide();
+}
+
+void SymbolTooltip::update_symbol_tooltip(const Point2i &p_mouse_pos, const Ref<Script> &p_script) {
+	String symbol = _get_symbol(p_mouse_pos);
+	if (symbol.is_empty()) {
+		last_symbol = "";
+		_close_tooltip();
+		return;
+	}
+
+	if (symbol == last_symbol && is_visible()) { // Symbol has not changed.
+		return;
+	} else {
+		// Symbol has changed, reset the timer.
+		_close_tooltip();
+		last_symbol = symbol;
+	}
+
+	lsp::Range symbol_range;
+	if (!_try_get_symbol_range_at_pos(symbol,p_mouse_pos, symbol_range)) {
+		_close_tooltip();
+		return;
+	}
+
+	if (!_update_tooltip_content(p_script, symbol, symbol_range)) {
+		_close_tooltip();
+		return;
+	}
+	_update_tooltip_size();
+
+	Rect2 tooltip_rect = Rect2(get_position(), get_size());
+	bool mouse_over_tooltip = tooltip_rect.has_point(p_mouse_pos) && is_visible();
+	if (!mouse_over_tooltip) {
+		Point2i tooltip_pos = _calculate_tooltip_position(symbol_range);
+		set_position(tooltip_pos);
+	}
+
+	// Start the timer to show the tooltip after a delay.
+	if (!is_visible()) {
+		tooltip_delay->start();
+	}
+}
+
+String SymbolTooltip::_get_symbol(const Point2i &p_mouse_pos) {
+	// Get the word under the mouse cursor.
+	return text_editor->get_word_at_pos(p_mouse_pos);
+}
+
+bool SymbolTooltip::_update_tooltip_content(const Ref<Script> &p_script, const String &p_symbol, const lsp::Range &p_symbol_range) {
+	// Update the tooltip's header and body.
+
+	bool is_built_in = false;
+	String built_in_header = "";
+	String built_in_body = "";
+	Vector<const DocData::ClassDoc *> class_docs = _get_built_in_class_docs();
+	for (const DocData::ClassDoc *class_doc : class_docs) {
+		const DocData::ConstantDoc *constant_doc = _get_class_constant_doc(class_doc, p_symbol);
+		if (constant_doc) {
+			built_in_header = constant_doc->name + " = " + constant_doc->value;
+			if (!constant_doc->enumeration.is_empty()) {
+				built_in_header = constant_doc->enumeration + "." + built_in_header;
+				built_in_body = constant_doc->description.strip_edges();
+			}
+			is_built_in = true;
+			break;
+		} else {
+			const DocData::MethodDoc *method_doc = _get_class_method_doc(class_doc, p_symbol);
+			if (method_doc) {
+				built_in_header = _get_class_method_doc_definition(method_doc);
+				built_in_body = method_doc->description.strip_edges();
+				is_built_in = true;
+				break;
+			}
+		}
+	}
+
+	// String official_documentation = _get_doc_of_word(p_symbol);
+	// ScriptLanguage::LookupResult symbol_info = _lookup_symbol(p_script, p_symbol);
+	//ExtendGDScriptParser *parser = _get_script_parser(p_script);
+	//const lsp::DocumentSymbol *member_symbol = parser->get_member_symbol(p_symbol);
+
+	const lsp::DocumentSymbol *member_symbol = _get_member_symbol(p_script, p_symbol, p_symbol_range);
+
+	if (member_symbol == nullptr && !is_built_in) { // Symbol is not a member of the script.
+		return false;
+	}
+
+	// TODO: Improve header content. Add the ability to see documentation comments or official documentation.
+	// Add constant value to the header content. e.g. "PI" becomes "PI = 3.141592653589793" (similar to how we do with ENUMs)
+	String header_content = _get_header_content(p_symbol, member_symbol, built_in_header);
+	String body_content = _get_body_content(member_symbol, built_in_body);
+
+	_update_header_label(header_content);
+	_update_body_label(body_content);
+	return true;
+}
+
+void SymbolTooltip::_update_tooltip_size() {
+	// Constants and References
+	const int MAX_WIDTH = 800;
+	Ref<Theme> header_theme = header_label->get_theme();
+	Ref<StyleBox> header_style_box = header_theme->get_stylebox("normal", "TextEdit");
+	Ref<Font> font = get_theme_font(SNAME("doc"), EditorStringName(EditorFonts));
+	int font_size = get_theme_font_size(SNAME("doc_size"), EditorStringName(EditorFonts));
+	String header_text = header_label->get_text();
+	String body_text = body_label->get_parsed_text();
+	Ref<Theme> body_theme = body_label->get_theme();
+	Ref<StyleBox> body_style_box = body_theme->get_stylebox("normal", "RichTextLabel");
+
+	// Calculate content size and style box paddings
+	Size2 header_content_size = font->get_string_size(header_text, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size);
+	Size2 body_content_size = font->get_string_size(body_text, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size);
+	real_t header_h_padding = header_style_box->get_content_margin(SIDE_LEFT) + header_style_box->get_content_margin(SIDE_RIGHT);
+	//real_t header_v_padding = header_style_box->get_content_margin(SIDE_TOP) + header_style_box->get_content_margin(SIDE_BOTTOM);
+	real_t body_h_padding = body_style_box->get_content_margin(SIDE_LEFT) + body_style_box->get_content_margin(SIDE_RIGHT);
+	real_t body_v_padding = body_style_box->get_content_margin(SIDE_TOP) + body_style_box->get_content_margin(SIDE_BOTTOM);
+
+	// Determine tooltip width based on max width, header width, and body visibility
+	real_t header_width = header_content_size.width + header_h_padding;
+	real_t body_width = body_content_size.width + body_h_padding;
+	real_t tooltip_width = MIN(MAX_WIDTH, MAX(header_width, body_label->is_visible() ? body_width : 0) + 10); // TODO: Should be +2, but +10 is needed and I'm not sure why.
+
+	// Set sizes
+	header_label->set_custom_minimum_size(Size2(tooltip_width, -1)); // TODO: Calculate this accurately instead of using -1.
+	body_label->set_custom_minimum_size(Size2(tooltip_width, MIN(body_label->get_content_height() + body_v_padding, 400)));
+	set_size(Size2(tooltip_width, -1));
+}
+
+Point2i SymbolTooltip::_calculate_tooltip_position(const lsp::Range &p_symbol_range) {
+	Point2i symbol_position = text_editor->get_pos_at_line_column(p_symbol_range.start.line, p_symbol_range.start.character);
+	return text_editor->get_global_position() + symbol_position;
+}
+
+Vector<const DocData::ClassDoc *> SymbolTooltip::_get_built_in_class_docs() {
+	const HashMap<String, DocData::ClassDoc> &class_list = EditorHelp::get_doc_data()->class_list;
+	Vector<const DocData::ClassDoc *> class_docs;
+	class_docs.append(&class_list["@GDScript"]);
+	class_docs.append(&class_list["@GlobalScope"]);
+	return class_docs;
+}
+
+ExtendGDScriptParser *SymbolTooltip::_get_script_parser(const Ref<Script> &p_script) {
+	// Create and initialize the parser.
+	ExtendGDScriptParser *parser = memnew(ExtendGDScriptParser);
+	Error err = parser->parse(p_script->get_source_code(), p_script->get_path());
+
+	if (err != OK) {
+		ERR_PRINT("Failed to parse GDScript with GDScriptParser.");
+		return nullptr;
+	}
+
+	return parser;
+}
+
+/*ScriptLanguage::LookupResult SymbolTooltip::_lookup_symbol(const Ref<Script> &p_script, const String &p_symbol) {
+	Node *base = get_tree()->get_edited_scene_root();
+	if (base) {
+		base = _find_node_for_script(base, base, p_script);
+	}
+
+	ScriptLanguage::LookupResult result;
+	String lc_text = text_editor->get_text_for_symbol_lookup();
+	Error lc_error = p_script->get_language()->lookup_code(lc_text, p_symbol, p_script->get_path(), base, result);
+	return result;
+}*/
+
+// TODO: Need to find the correct symbol instance instead of just the first match.
+const lsp::DocumentSymbol *SymbolTooltip::_get_member_symbol(
+		const Ref<Script> &p_script,
+		const String &p_symbol,
+		const lsp::Range &p_symbol_range) {
+	ExtendGDScriptParser *parser = _get_script_parser(p_script);
+	HashMap<String, const lsp::DocumentSymbol *> members = parser->get_members();
+
+	// Use a queue to implement breadth-first search.
+	std::queue<const lsp::DocumentSymbol *> queue;
+
+	// Add all members to the queue.
+	for (const KeyValue<String, const lsp::DocumentSymbol *> &E : members) {
+		queue.push(E.value);
+	}
+
+	// While there are still elements in the queue.
+	while (!queue.empty()) {
+		// Get the next symbol.
+		const lsp::DocumentSymbol *symbol = queue.front();
+		queue.pop();
+
+		bool is_within_range = p_symbol_range.is_within(symbol->parent->range);
+
+		if (symbol->name == p_symbol && !symbol->detail.is_empty()) {
+			print_line(
+				"symbol: ", symbol->name,
+				"parent: ", symbol->parent->name,
+				", is_within_range: ", is_within_range,
+				", parent_range: ", symbol->parent->range.to_json(),
+				", symbol_range: ", p_symbol_range.to_json()
+			);
+		}
+
+		// If the name matches, return the symbol.
+		// TODO: Add '&& is_within_range' once the range of member symbols is corrected. They are currently incorrect.
+		if (symbol->name == p_symbol && !symbol->detail.is_empty()) {
+			return symbol;
+		}
+
+		// Add the children to the queue for later processing.
+		for (int i = 0; i < symbol->children.size(); ++i) {
+			queue.push(symbol->children[i]);
+		}
+	}
+
+	return nullptr; // If the symbol is not found, return nullptr.
+}
+
+const DocData::MethodDoc *SymbolTooltip::_get_class_method_doc(const DocData::ClassDoc *p_class_doc, const String &p_symbol) {
+	for (int i = 0; i < p_class_doc->methods.size(); ++i) {
+		const DocData::MethodDoc &method_doc = p_class_doc->methods[i];
+
+		if (method_doc.name == p_symbol) {
+			return &method_doc;
+		}
+	}
+	return nullptr;
+}
+
+const DocData::ConstantDoc *SymbolTooltip::_get_class_constant_doc(const DocData::ClassDoc *p_class_doc, const String &p_symbol) {
+	for (int i = 0; i < p_class_doc->constants.size(); ++i) {
+		const DocData::ConstantDoc &constant_doc = p_class_doc->constants[i];
+
+		if (constant_doc.name == p_symbol) {
+			if (constant_doc.is_value_valid) {
+				return &constant_doc;
+			}
+		}
+	}
+	return nullptr;
+}
+
+String SymbolTooltip::_get_class_method_doc_definition(const DocData::MethodDoc *p_method_doc) {
+	String definition = "func " + p_method_doc->name + "(";
+	String parameters;
+	for (int i = 0; i < p_method_doc->arguments.size(); i++) {
+		const DocData::ArgumentDoc &parameter = p_method_doc->arguments[i];
+		if (i > 0) {
+			parameters += ", ";
+		}
+		parameters += parameter.name;
+		if (!parameter.type.is_empty()) {
+			parameters += ": " + parameter.type;
+		}
+	}
+	if (p_method_doc->qualifiers.contains("vararg")) {
+		parameters += parameters.is_empty() ? "..." : ", ...";
+	}
+
+	String return_type = p_method_doc->return_type;
+	if (return_type.is_empty()) {
+		return_type = "void";
+	}
+	definition += parameters + ") -> " + return_type;
+	return definition;
+}
+
+String SymbolTooltip::_get_header_content(const String &p_symbol, const lsp::DocumentSymbol *p_member_symbol, String p_built_in_header) {
+	if (p_member_symbol && !p_member_symbol->reduced_detail.is_empty()) {
+		return p_member_symbol->reduced_detail;
+	}
+	if (!p_built_in_header.is_empty()) {
+		return p_built_in_header;
+	}
+	return p_symbol;
+}
+
+String SymbolTooltip::_get_body_content(const lsp::DocumentSymbol *p_member_symbol, String p_built_in_body) {
+	String body_content = "";
+	if (p_member_symbol) {
+		// Append relevant docstrings.
+		// TODO: Docstring formatting currently has no built-in formatting for documentation comments.
+		body_content += p_member_symbol->documentation.replace("\n\n", "\n");
+	}
+	if (!p_built_in_body.is_empty()) {
+		// Append official documentation.
+		body_content += p_built_in_body;
+	}
+	return body_content;
+}
+
+void SymbolTooltip::_update_header_label(const String &p_header_content) {
+	// Set the tooltip's header text.
+	header_label->set_text(p_header_content);
+}
+
+void SymbolTooltip::_update_body_label(const String &p_body_content) {
+	// Set the tooltip's body text.
+	if (p_body_content.is_empty()) {
+		if (body_label->is_visible()) {
+			body_label->hide();
+		}
+		return;
+	}
+	body_label->clear();
+	_add_text_to_rt(p_body_content, body_label, layout_container);
+	if (!body_label->is_visible()) {
+		body_label->show();
+	}
+}
+
+bool SymbolTooltip::_is_valid_line(const String &p_line) const {
+	// Check if the line is empty or only contains whitespace.
+	if (p_line.is_empty() || p_line.strip_edges().is_empty()) {
+		return false;
+	}
+
+	// Check if the line is a comment.
+	if (p_line.begins_with("#")) {
+		return false;
+	}
+
+	// Check if the line is a docstring. TODO: Need a better way to detect docstrings.
+	if (p_line.begins_with("\"\"\"") || p_line.begins_with("'''")) {
+		return false;
+	}
+
+	return true;
+}
+
+bool SymbolTooltip::_try_get_symbol_range_at_pos(const String &p_symbol, const Point2i &p_pos, lsp::Range &r_symbol_range) const {
+	Point2i line_column = text_editor->get_line_column_at_pos(p_pos, false);
+	int row = line_column.y;
+	int column = line_column.x;
+	if (line_column == Point2i(-1, -1)) { // If the position is outside the text editor.
+		return false;
+	}
+
+	String line = text_editor->get_line(row);
+	if(!_is_valid_line(line)) {
+		return false;
+	}
+
+	bool is_outside_line = column < 0 || column >= line.length();
+	// Invalid if the symbol word is empty or if the column is outside of the line.
+	if (p_symbol.is_empty() || is_outside_line) {
+		return false;
+	}
+
+	int start = column;
+	int end = column;
+
+	// Extend the start and end until they reach the beginning or end of the word.
+	while (start > 0 && is_ascii_identifier_char(line[start - 1])) {
+		start--;
+	}
+	while (end < line.length() && is_ascii_identifier_char(line[end])) {
+		end++;
+	}
+
+	String word_under_mouse = line.substr(start, end - start);
+
+	// Invalid if the word under the mouse is not the symbol word.
+	if (word_under_mouse != p_symbol) {
+		return false;
+	}
+
+	r_symbol_range = {
+		{ row, start + 1 }, // Note: +1 is added to account for zero-based indexing.
+		{ row, end }
+	};
+	return true;
+}
+
+Ref<Theme> SymbolTooltip::_create_panel_theme() {
+	Ref<Theme> theme = memnew(Theme); // TODO: Get the global theme instead (e.g. dark mode, light mode).
+
+	Ref<StyleBoxFlat> style_box = memnew(StyleBoxFlat);
+	style_box->set_bg_color(Color().html("#363d4a")); // Set the background color (RGBA).
+	style_box->set_border_color(Color(0.8, 0.81, 0.82, 0.47)); // Set the border color (RGBA).
+	style_box->set_border_width_all(1); // Set the border width.
+	style_box->set_corner_radius_all(4); // Set the border radius for curved corners.
+	//style_box->set_content_margin_all(20);
+	theme->set_stylebox("panel", "PanelContainer", style_box);
+
+	return theme;
+}
+
+Ref<Theme> SymbolTooltip::_create_header_label_theme() {
+	Ref<Theme> theme = memnew(Theme); // TODO: Get the global theme instead (e.g. dark mode, light mode).
+
+	Ref<StyleBoxFlat> style_box = memnew(StyleBoxFlat);
+	style_box->set_draw_center(false);
+	style_box->set_content_margin_individual(15, 10, 15, 10);
+
+	// Set the style boxes for the TextEdit
+	theme->set_stylebox("normal", "TextEdit", style_box);
+	theme->set_stylebox("focus", "TextEdit", style_box);
+	theme->set_stylebox("readonly", "TextEdit", style_box);
+
+	// Set the font color.
+	theme->set_color("font_color", "TextEdit", Color(1, 1, 1));
+
+	return theme;
+}
+
+Ref<Theme> SymbolTooltip::_create_body_label_theme() {
+	Ref<Theme> theme = memnew(Theme); // TODO: Get the global theme instead (e.g. dark mode, light mode).
+
+	Ref<StyleBoxFlat> style_box = memnew(StyleBoxFlat);
+	style_box->set_draw_center(false);
+	style_box->set_border_width(SIDE_TOP, 1);
+	style_box->set_border_color(Color(0.8, 0.81, 0.82, 0.27)); // Set the border color (RGBA).
+	style_box->set_content_margin_individual(15, 10, 15, 10);
+	theme->set_stylebox("normal", "RichTextLabel", style_box);
+
+	return theme;
+}
+
+/*const GDScriptParser::ClassNode::Member *find_symbol(const GDScriptParser::ClassNode *node, const String &p_symbol) {
+	for (int i = 0; i < node->members.size(); ++i) {
+		const GDScriptParser::ClassNode::Member &member = node->members[i];
+
+		if (member.get_name() == p_symbol) {
+			// Found the symbol.
+			return &member;
+		} else if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
+			const GDScriptParser::ClassNode::Member *found_symbol = find_symbol(member.m_class, p_symbol);
+			if (found_symbol) {
+				return found_symbol;
+			}
+		}
+	}
+
+	return nullptr;
+}*/
+
+/*String SymbolTooltip::_get_doc_of_word(const String &p_symbol) {
+	String documentation;
+
+	const HashMap<String, DocData::ClassDoc> &class_list = EditorHelp::get_doc_data()->class_list;
+	for (const KeyValue<String, DocData::ClassDoc> &E : class_list) {
+		const DocData::ClassDoc &class_doc = E.value;
+
+		if (class_doc.name == p_symbol) {
+			documentation = class_doc.brief_description.strip_edges(); //class_doc.brief_description + "\n\n" + class_doc.description;
+			if (documentation.is_empty()) {
+				documentation = class_doc.description.strip_edges();
+			}
+			break;
+		}
+
+		for (int i = 0; i < class_doc.methods.size(); ++i) {
+			const DocData::MethodDoc &method_doc = class_doc.methods[i];
+
+			if (method_doc.name == p_symbol) {
+				documentation = method_doc.description.strip_edges();
+				break;
+			}
+		}
+
+		for (int i = 0; i < class_doc.constants.size(); ++i) {
+			const DocData::ConstantDoc &constant_doc = class_doc.constants[i];
+
+			if (constant_doc.name == p_symbol) {
+				if (constant_doc.is_value_valid) {
+					documentation = constant_doc.value.strip_edges();
+				}
+				break;
+			}
+		}
+
+		if (!documentation.is_empty()) {
+			break;
+		}
+	}
+	return documentation;
+}*/
+
+// Copied from script_text_editor.cpp
+/*static Node *_find_node_for_script(Node *p_base, Node *p_current, const Ref<Script> &p_script) {
+	if (p_current->get_owner() != p_base && p_base != p_current) {
+		return nullptr;
+	}
+	Ref<Script> c = p_current->get_script();
+	if (c == p_script) {
+		return p_current;
+	}
+	for (int i = 0; i < p_current->get_child_count(); i++) {
+		Node *found = _find_node_for_script(p_base, p_current->get_child(i), p_script);
+		if (found) {
+			return found;
+		}
+	}
+
+return nullptr;
+}*/
+
+// Gets the head of the GDScriptParser AST tree.
+/*static const GDScriptParser::ClassNode *get_ast_tree(const Ref<Script> &p_script) {
+	// Create and initialize the parser.
+	GDScriptParser *parser = memnew(GDScriptParser);
+	Error err = parser->parse(p_script->get_source_code(), p_script->get_path(), false);
+
+if (err != OK) {
+	ERR_PRINT("Failed to parse GDScript with GDScriptParser.");
+	return nullptr;
+}
+
+// Get the AST tree.
+const GDScriptParser::ClassNode *ast_tree = parser->get_tree();
+return ast_tree;
+}*/
diff --git a/editor/symbol_tooltip.h b/editor/symbol_tooltip.h
new file mode 100644
index 000000000000..7821d436cf31
--- /dev/null
+++ b/editor/symbol_tooltip.h
@@ -0,0 +1,92 @@
+/**************************************************************************/
+/*  symbol_tooltip.h                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef SYMBOL_TOOLTIP_H
+#define SYMBOL_TOOLTIP_H
+
+#include "code_editor.h"
+#include "modules/gdscript/gdscript_parser.h"
+#include "modules/gdscript/language_server/gdscript_extend_parser.h"
+#include "scene/gui/box_container.h"
+#include "scene/gui/panel_container.h"
+#include "scene/gui/rich_text_label.h"
+
+class SymbolTooltip : public PanelContainer {
+	GDCLASS(SymbolTooltip, PanelContainer);
+
+	CodeEdit *text_editor = nullptr;
+	PanelContainer *panel_container = nullptr;
+	VBoxContainer *layout_container = nullptr;
+	TextEdit *header_label = nullptr;
+	RichTextLabel *body_label = nullptr;
+	Timer *tooltip_delay = nullptr;
+	String last_symbol;
+	bool mouse_inside;
+
+	void _on_tooltip_delay_timeout();
+	void _close_tooltip();
+	String _get_symbol(const Point2i &p_mouse_pos);
+	bool _update_tooltip_content(const Ref<Script> &p_script, const String &p_symbol, const lsp::Range &p_symbol_range);
+	void _update_tooltip_size();
+	Point2i _calculate_tooltip_position(const lsp::Range &p_symbol_range);
+	Vector<const DocData::ClassDoc *> _get_built_in_class_docs();
+	ExtendGDScriptParser *_get_script_parser(const Ref<Script> &p_script);
+	// ScriptLanguage::LookupResult _lookup_symbol(const Ref<Script> &p_script, const String &p_symbol);
+	const lsp::DocumentSymbol *_get_member_symbol(const Ref<Script> &p_script, const String &p_symbol, const lsp::Range &p_symbol_range);
+	const DocData::MethodDoc *_get_class_method_doc(const DocData::ClassDoc *p_class_doc, const String &p_symbol);
+	const DocData::ConstantDoc *_get_class_constant_doc(const DocData::ClassDoc *p_class_doc, const String &p_symbol);
+	String _get_class_method_doc_definition(const DocData::MethodDoc *p_method_doc);
+	String _get_header_content(const String &p_symbol, const lsp::DocumentSymbol *p_member_symbol, String p_built_in_header);
+	String _get_body_content(const lsp::DocumentSymbol *p_member_symbol, String p_built_in_body);
+	void _update_header_label(const String &p_header_content);
+	void _update_body_label(const String &p_body_content);
+	bool _is_valid_line(const String &p_line) const;
+	bool _try_get_symbol_range_at_pos(const String &p_symbol, const Point2i &p_pos, lsp::Range &r_symbol_range) const;
+	Ref<Theme> _create_panel_theme();
+	Ref<Theme> _create_header_label_theme();
+	Ref<Theme> _create_body_label_theme();
+
+	// String _get_doc_of_word(const String &p_symbol);
+
+protected:
+	void _notification(int p_what);
+
+public:
+	void update_symbol_tooltip(const Point2i &p_mouse_pos, const Ref<Script> &p_script);
+	SymbolTooltip(CodeEdit *p_text_editor);
+	~SymbolTooltip();
+};
+
+// static Node *_find_node_for_script(Node *p_base, Node *p_current, const Ref<Script> &p_script);
+// static const GDScriptParser::ClassNode *get_ast_tree(const Ref<Script> &p_script);
+// static ExtendGDScriptParser *get_script_parser(const Ref<Script> &p_script);
+// const lsp::DocumentSymbol *get_member_symbol(HashMap<String, const lsp::DocumentSymbol *> &p_members, const String &p_symbol);
+
+#endif // SYMBOL_TOOLTIP_H
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index 649bd735c6a8..2d53b08d508a 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -4430,7 +4430,7 @@ String GDScriptParser::DataType::to_string() const {
 			return "Variant";
 		case BUILTIN:
 			if (builtin_type == Variant::NIL) {
-				return "null";
+				return "void";
 			}
 			if (builtin_type == Variant::ARRAY && has_container_element_type(0)) {
 				return vformat("Array[%s]", container_element_types[0].to_string());
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index ad7af34bf113..1dec6cd826aa 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -171,18 +171,18 @@ void ExtendGDScriptParser::update_symbols() {
 	if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(get_tree())) {
 		parse_class_symbol(gdclass, class_symbol);
 
-		for (int i = 0; i < class_symbol.children.size(); i++) {
-			const lsp::DocumentSymbol &symbol = class_symbol.children[i];
-			members.insert(symbol.name, &symbol);
+		for (int i = 0; i < class_symbol->children.size(); i++) {
+			const lsp::DocumentSymbol *symbol = class_symbol->children[i];
+			members.insert(symbol->name, symbol);
 
 			// Cache level one inner classes.
-			if (symbol.kind == lsp::SymbolKind::Class) {
+			if (symbol->kind == lsp::SymbolKind::Class) {
 				ClassMembers inner_class;
-				for (int j = 0; j < symbol.children.size(); j++) {
-					const lsp::DocumentSymbol &s = symbol.children[j];
-					inner_class.insert(s.name, &s);
+				for (int j = 0; j < symbol->children.size(); j++) {
+					const lsp::DocumentSymbol *s = symbol->children[j];
+					inner_class.insert(s->name, s);
 				}
-				inner_classes.insert(symbol.name, inner_class);
+				inner_classes.insert(symbol->name, inner_class);
 			}
 		}
 	}
@@ -225,32 +225,35 @@ lsp::Range ExtendGDScriptParser::range_of_node(const GDScriptParser::Node *p_nod
 	return GodotRange(start, end).to_lsp(lines);
 }
 
-void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol &r_symbol) {
+void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol *r_symbol) {
 	const String uri = get_uri();
 
-	r_symbol.uri = uri;
-	r_symbol.script_path = path;
-	r_symbol.children.clear();
-	r_symbol.name = p_class->identifier != nullptr ? String(p_class->identifier->name) : String();
-	if (r_symbol.name.is_empty()) {
-		r_symbol.name = path.get_file();
+	r_symbol->uri = uri;
+	r_symbol->script_path = path;
+	r_symbol->children.clear();
+	r_symbol->name = p_class->identifier != nullptr ? String(p_class->identifier->name) : String();
+	if (r_symbol->name.is_empty()) {
+		r_symbol->name = path.get_file();
 	}
-	r_symbol.kind = lsp::SymbolKind::Class;
-	r_symbol.deprecated = false;
-	r_symbol.range = range_of_node(p_class);
-	r_symbol.range.start.line = MAX(r_symbol.range.start.line, 0);
+	r_symbol->kind = lsp::SymbolKind::Class;
+	r_symbol->deprecated = false;
+	r_symbol->range = range_of_node(p_class);
+	r_symbol->range.start.line = MAX(r_symbol->range.start.line, 0);
 	if (p_class->identifier) {
-		r_symbol.selectionRange = range_of_node(p_class->identifier);
+		r_symbol->selectionRange = range_of_node(p_class->identifier);
 	}
-	r_symbol.detail = "class " + r_symbol.name;
+	r_symbol->detail = "class " + r_symbol->name;
+	r_symbol->reduced_detail = r_symbol->detail;
 	{
-		String doc = p_class->doc_data.description;
+		String doc = "";
+		if (!p_class->doc_data.brief.is_empty()) {
+			doc += p_class->doc_data.brief + "\n";
+		}
 		if (!p_class->doc_data.description.is_empty()) {
-			doc += "\n\n" + p_class->doc_data.description;
+			doc += p_class->doc_data.description + "\n";
 		}
 
 		if (!p_class->doc_data.tutorials.is_empty()) {
-			doc += "\n";
 			for (const Pair<String, String> &tutorial : p_class->doc_data.tutorials) {
 				if (tutorial.first.is_empty()) {
 					doc += vformat("\n@tutorial: %s", tutorial.second);
@@ -259,7 +262,7 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 				}
 			}
 		}
-		r_symbol.documentation = doc;
+		r_symbol->documentation = doc;
 	}
 
 	for (int i = 0; i < p_class->members.size(); i++) {
@@ -267,66 +270,74 @@ 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);
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+				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 += "@export ";
 				}
-				symbol.detail += "var " + m.variable->identifier->name;
+				symbol->detail += "var " + m.variable->identifier->name;
 				if (m.get_datatype().is_hard_type()) {
-					symbol.detail += ": " + m.get_datatype().to_string();
+					symbol->detail += ": " + m.get_datatype().to_string();
 				}
+				symbol->reduced_detail = symbol->detail;
 				if (m.variable->initializer != nullptr && m.variable->initializer->is_constant) {
-					symbol.detail += " = " + m.variable->initializer->reduced_value.to_json_string();
+					symbol->detail += " = " + m.variable->initializer->reduced_value.to_json_string();
 				}
 
-				symbol.documentation = m.variable->doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
+				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;
+					lsp::DocumentSymbol *lambda = memnew(lsp::DocumentSymbol);
 					parse_function_symbol(lambda_node->function, lambda);
 					// Merge lambda into current variable.
-					symbol.children.append_array(lambda.children);
+					for (lsp::DocumentSymbol *lambda_symbol : lambda->children) {
+						lambda_symbol->parent = symbol;
+						symbol->children.push_back(lambda_symbol);
+					}
 				}
 
 				if (m.variable->getter && m.variable->getter->type == GDScriptParser::Node::FUNCTION) {
-					lsp::DocumentSymbol get_symbol;
+					lsp::DocumentSymbol *get_symbol = memnew(lsp::DocumentSymbol);
 					parse_function_symbol(m.variable->getter, get_symbol);
-					get_symbol.local = true;
-					symbol.children.push_back(get_symbol);
+					get_symbol->local = true;
+					get_symbol->parent = symbol;
+					symbol->children.push_back(get_symbol);
 				}
 				if (m.variable->setter && m.variable->setter->type == GDScriptParser::Node::FUNCTION) {
-					lsp::DocumentSymbol set_symbol;
+					lsp::DocumentSymbol *set_symbol = memnew(lsp::DocumentSymbol);
 					parse_function_symbol(m.variable->setter, set_symbol);
-					set_symbol.local = true;
-					symbol.children.push_back(set_symbol);
+					set_symbol->local = true;
+					set_symbol->parent = symbol;
+					symbol->children.push_back(set_symbol);
 				}
 
-				r_symbol.children.push_back(symbol);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::CONSTANT: {
-				lsp::DocumentSymbol symbol;
-
-				symbol.name = m.constant->identifier->name;
-				symbol.kind = lsp::SymbolKind::Constant;
-				symbol.deprecated = false;
-				symbol.range = range_of_node(m.constant);
-				symbol.selectionRange = range_of_node(m.constant->identifier);
-				symbol.documentation = m.constant->doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
-
-				symbol.detail = "const " + symbol.name;
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+
+				symbol->name = m.constant->identifier->name;
+				symbol->kind = lsp::SymbolKind::Constant;
+				symbol->deprecated = false;
+				symbol->range = range_of_node(m.constant);
+				symbol->selectionRange = range_of_node(m.constant->identifier);
+				symbol->documentation = m.constant->doc_data.description;
+				symbol->uri = uri;
+				symbol->script_path = path;
+
+				symbol->detail = "const " + symbol->name;
 				if (m.constant->get_datatype().is_hard_type()) {
-					symbol.detail += ": " + m.constant->get_datatype().to_string();
+					symbol->detail += ": " + m.constant->get_datatype().to_string();
 				}
+				symbol->reduced_detail = symbol->detail;
 
 				const Variant &default_value = m.constant->initializer->reduced_value;
 				String value_text;
@@ -334,9 +345,9 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 					Ref<Resource> res = default_value;
 					if (res.is_valid() && !res->get_path().is_empty()) {
 						value_text = "preload(\"" + res->get_path() + "\")";
-						if (symbol.documentation.is_empty()) {
+						if (symbol->documentation.is_empty()) {
 							if (HashMap<String, ExtendGDScriptParser *>::Iterator S = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(res->get_path())) {
-								symbol.documentation = S->value->class_symbol.documentation;
+								symbol->documentation = S->value->class_symbol->documentation;
 							}
 						}
 					} else {
@@ -346,113 +357,103 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 					value_text = default_value.to_json_string();
 				}
 				if (!value_text.is_empty()) {
-					symbol.detail += " = " + value_text;
+					symbol->detail += " = " + value_text;
 				}
 
-				r_symbol.children.push_back(symbol);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::SIGNAL: {
-				lsp::DocumentSymbol symbol;
-				symbol.name = m.signal->identifier->name;
-				symbol.kind = lsp::SymbolKind::Event;
-				symbol.deprecated = false;
-				symbol.range = range_of_node(m.signal);
-				symbol.selectionRange = range_of_node(m.signal->identifier);
-				symbol.documentation = m.signal->doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
-				symbol.detail = "signal " + String(m.signal->identifier->name) + "(";
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+				symbol->name = m.signal->identifier->name;
+				symbol->kind = lsp::SymbolKind::Event;
+				symbol->deprecated = false;
+				symbol->range = range_of_node(m.signal);
+				symbol->selectionRange = range_of_node(m.signal->identifier);
+				symbol->documentation = m.signal->doc_data.description;
+				symbol->uri = uri;
+				symbol->script_path = path;
+				symbol->detail = "signal " + String(m.signal->identifier->name) + "(";
 				for (int j = 0; j < m.signal->parameters.size(); j++) {
+					const ParameterNode *parameter = m.signal->parameters[j];
 					if (j > 0) {
-						symbol.detail += ", ";
+						symbol->detail += ", ";
+					}
+					symbol->detail += parameter->identifier->name;
+					if (parameter->get_datatype().is_hard_type()) {
+						symbol->detail += ": " + parameter->get_datatype().to_string();
 					}
-					symbol.detail += m.signal->parameters[j]->identifier->name;
 				}
-				symbol.detail += ")";
+				symbol->detail += ")";
+				symbol->reduced_detail = symbol->detail;
 
 				for (GDScriptParser::ParameterNode *param : m.signal->parameters) {
-					lsp::DocumentSymbol param_symbol;
-					param_symbol.name = param->identifier->name;
-					param_symbol.kind = lsp::SymbolKind::Variable;
-					param_symbol.deprecated = false;
-					param_symbol.local = true;
-					param_symbol.range = range_of_node(param);
-					param_symbol.selectionRange = range_of_node(param->identifier);
-					param_symbol.uri = uri;
-					param_symbol.script_path = path;
-					param_symbol.detail = "var " + param_symbol.name;
+					lsp::DocumentSymbol *param_symbol = memnew(lsp::DocumentSymbol);
+					param_symbol->name = param->identifier->name;
+					param_symbol->kind = lsp::SymbolKind::Variable;
+					param_symbol->deprecated = false;
+					param_symbol->local = true;
+					param_symbol->range = range_of_node(param);
+					param_symbol->selectionRange = range_of_node(param->identifier);
+					param_symbol->uri = uri;
+					param_symbol->script_path = path;
+					param_symbol->detail = "var " + param_symbol->name;
 					if (param->get_datatype().is_hard_type()) {
-						param_symbol.detail += ": " + param->get_datatype().to_string();
+						param_symbol->detail += ": " + param->get_datatype().to_string();
 					}
-					symbol.children.push_back(param_symbol);
+					param_symbol->reduced_detail = param_symbol->detail;
+					param_symbol->parent = symbol;
+					symbol->children.push_back(param_symbol);
 				}
-				r_symbol.children.push_back(symbol);
+
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::ENUM_VALUE: {
-				lsp::DocumentSymbol symbol;
-
-				symbol.name = m.enum_value.identifier->name;
-				symbol.kind = lsp::SymbolKind::EnumMember;
-				symbol.deprecated = false;
-				symbol.range.start = GodotPosition(m.enum_value.line, m.enum_value.leftmost_column).to_lsp(lines);
-				symbol.range.end = GodotPosition(m.enum_value.line, m.enum_value.rightmost_column).to_lsp(lines);
-				symbol.selectionRange = range_of_node(m.enum_value.identifier);
-				symbol.documentation = m.enum_value.doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
-
-				symbol.detail = symbol.name + " = " + itos(m.enum_value.value);
-
-				r_symbol.children.push_back(symbol);
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+				parse_enum_value_symbol(&m.enum_value, symbol);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::ENUM: {
-				lsp::DocumentSymbol symbol;
-				symbol.name = m.m_enum->identifier->name;
-				symbol.kind = lsp::SymbolKind::Enum;
-				symbol.range = range_of_node(m.m_enum);
-				symbol.selectionRange = range_of_node(m.m_enum->identifier);
-				symbol.documentation = m.m_enum->doc_data.description;
-				symbol.uri = uri;
-				symbol.script_path = path;
-
-				symbol.detail = "enum " + String(m.m_enum->identifier->name) + "{";
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+				symbol->name = m.m_enum->identifier->name;
+				symbol->kind = lsp::SymbolKind::Enum;
+				symbol->range = range_of_node(m.m_enum);
+				symbol->selectionRange = range_of_node(m.m_enum->identifier);
+				symbol->documentation = m.m_enum->doc_data.description;
+				symbol->uri = uri;
+				symbol->script_path = path;
+
+				symbol->detail = "enum " + String(m.m_enum->identifier->name) + "{";
 				for (int j = 0; j < m.m_enum->values.size(); j++) {
 					if (j > 0) {
-						symbol.detail += ", ";
+						symbol->detail += ", ";
 					}
-					symbol.detail += String(m.m_enum->values[j].identifier->name) + " = " + itos(m.m_enum->values[j].value);
-				}
-				symbol.detail += "}";
-
-				for (GDScriptParser::EnumNode::Value value : m.m_enum->values) {
-					lsp::DocumentSymbol child;
-
-					child.name = value.identifier->name;
-					child.kind = lsp::SymbolKind::EnumMember;
-					child.deprecated = false;
-					child.range.start = GodotPosition(value.line, value.leftmost_column).to_lsp(lines);
-					child.range.end = GodotPosition(value.line, value.rightmost_column).to_lsp(lines);
-					child.selectionRange = range_of_node(value.identifier);
-					child.documentation = value.doc_data.description;
-					child.uri = uri;
-					child.script_path = path;
+					const EnumNode::Value *enum_value = &m.m_enum->values[j];
+					symbol->detail += String(enum_value->identifier->name) + " = " + itos(enum_value->value);
 
-					child.detail = child.name + " = " + itos(value.value);
-
-					symbol.children.push_back(child);
+					lsp::DocumentSymbol *ev_symbol = memnew(lsp::DocumentSymbol);
+					parse_enum_value_symbol(enum_value, ev_symbol);
+					ev_symbol->parent = symbol;
+					symbol->children.push_back(ev_symbol);
 				}
-
-				r_symbol.children.push_back(symbol);
+				symbol->detail += "}";
+				symbol->reduced_detail = "enum " + String(m.m_enum->identifier->name);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::FUNCTION: {
-				lsp::DocumentSymbol symbol;
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
 				parse_function_symbol(m.function, symbol);
-				r_symbol.children.push_back(symbol);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::CLASS: {
-				lsp::DocumentSymbol symbol;
+				lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
 				parse_class_symbol(m.m_class, symbol);
-				r_symbol.children.push_back(symbol);
+				symbol->parent = r_symbol;
+				r_symbol->children.push_back(symbol);
 			} break;
 			case ClassNode::Member::GROUP:
 				break; // No-op, but silences warnings.
@@ -462,28 +463,49 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 	}
 }
 
-void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol) {
+void ExtendGDScriptParser::parse_enum_value_symbol(const GDScriptParser::EnumNode::Value *p_value, lsp::DocumentSymbol *r_symbol) {
+	r_symbol->name = p_value->identifier->name;
+	r_symbol->kind = lsp::SymbolKind::EnumMember;
+	r_symbol->deprecated = false;
+	r_symbol->range.start = GodotPosition(p_value->line, p_value->leftmost_column).to_lsp(lines);
+	r_symbol->range.end = GodotPosition(p_value->line, p_value->rightmost_column).to_lsp(lines);
+	r_symbol->selectionRange = range_of_node(p_value->identifier);
+	r_symbol->documentation = p_value->doc_data.description;
+	r_symbol->uri = get_uri();
+	r_symbol->script_path = path;
+
+	if (p_value->parent_enum->identifier != nullptr) {
+		r_symbol->detail = String(p_value->parent_enum->identifier->name) + "." + r_symbol->name + " = " + itos(p_value->value);
+	} else {
+		r_symbol->detail = r_symbol->name + " = " + itos(p_value->value);
+	}
+
+	r_symbol->reduced_detail = r_symbol->detail;
+}
+
+
+void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol *r_symbol) {
 	const String uri = get_uri();
 
 	bool is_named = p_func->identifier != nullptr;
 
-	r_symbol.name = is_named ? p_func->identifier->name : "";
-	r_symbol.kind = (p_func->is_static || p_func->source_lambda != nullptr) ? lsp::SymbolKind::Function : lsp::SymbolKind::Method;
-	r_symbol.detail = "func";
+	r_symbol->name = is_named ? p_func->identifier->name : "";
+	r_symbol->kind = (p_func->is_static || p_func->source_lambda != nullptr) ? lsp::SymbolKind::Function : lsp::SymbolKind::Method;
+	r_symbol->detail = "func";
 	if (is_named) {
-		r_symbol.detail += " " + String(p_func->identifier->name);
+		r_symbol->detail += " " + String(p_func->identifier->name);
 	}
-	r_symbol.detail += "(";
-	r_symbol.deprecated = false;
-	r_symbol.range = range_of_node(p_func);
+	r_symbol->detail += "(";
+	r_symbol->deprecated = false;
+	r_symbol->range = range_of_node(p_func);
 	if (is_named) {
-		r_symbol.selectionRange = range_of_node(p_func->identifier);
+		r_symbol->selectionRange = range_of_node(p_func->identifier);
 	} else {
-		r_symbol.selectionRange.start = r_symbol.selectionRange.end = r_symbol.range.start;
+		r_symbol->selectionRange.start = r_symbol->selectionRange.end = r_symbol->range.start;
 	}
-	r_symbol.documentation = p_func->doc_data.description;
-	r_symbol.uri = uri;
-	r_symbol.script_path = path;
+	r_symbol->documentation = p_func->doc_data.description;
+	r_symbol->uri = uri;
+	r_symbol->script_path = path;
 
 	String parameters;
 	for (int i = 0; i < p_func->parameters.size(); i++) {
@@ -499,9 +521,13 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN
 			parameters += " = " + parameter->initializer->reduced_value.to_json_string();
 		}
 	}
-	r_symbol.detail += parameters + ")";
+	r_symbol->detail += parameters + ")";
+	r_symbol->reduced_detail = r_symbol->detail;
 	if (p_func->get_datatype().is_hard_type()) {
-		r_symbol.detail += " -> " + p_func->get_datatype().to_string();
+		r_symbol->detail += " -> " + p_func->get_datatype().to_string();
+
+		String return_type = r_symbol->name == "_init" ? "void" : p_func->get_datatype().to_string();
+		r_symbol->reduced_detail += " -> " + return_type;
 	}
 
 	List<GDScriptParser::SuiteNode *> function_nodes;
@@ -561,61 +587,66 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN
 		const GDScriptParser::SuiteNode *suite_node = N->get();
 		for (int i = 0; i < suite_node->locals.size(); i++) {
 			const SuiteNode::Local &local = suite_node->locals[i];
-			lsp::DocumentSymbol symbol;
-			symbol.name = local.name;
-			symbol.kind = local.type == SuiteNode::Local::CONSTANT ? lsp::SymbolKind::Constant : lsp::SymbolKind::Variable;
+			lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+			symbol->name = local.name;
+			symbol->kind = local.type == SuiteNode::Local::CONSTANT ? lsp::SymbolKind::Constant : lsp::SymbolKind::Variable;
 			switch (local.type) {
 				case SuiteNode::Local::CONSTANT:
-					symbol.range = range_of_node(local.constant);
-					symbol.selectionRange = range_of_node(local.constant->identifier);
+					symbol->range = range_of_node(local.constant);
+					symbol->selectionRange = range_of_node(local.constant->identifier);
 					break;
 				case SuiteNode::Local::VARIABLE:
-					symbol.range = range_of_node(local.variable);
-					symbol.selectionRange = range_of_node(local.variable->identifier);
+					symbol->range = range_of_node(local.variable);
+					symbol->selectionRange = range_of_node(local.variable->identifier);
 					if (local.variable->initializer && local.variable->initializer->type == GDScriptParser::Node::LAMBDA) {
 						GDScriptParser::LambdaNode *lambda_node = (GDScriptParser::LambdaNode *)local.variable->initializer;
-						lsp::DocumentSymbol lambda;
+						lsp::DocumentSymbol *lambda = memnew(lsp::DocumentSymbol);
 						parse_function_symbol(lambda_node->function, lambda);
 						// Merge lambda into current variable.
 						// -> Only interested in new variables, not lambda itself.
-						symbol.children.append_array(lambda.children);
+						for (lsp::DocumentSymbol *lambda_symbol : lambda->children) {
+							lambda_symbol->parent = symbol;
+							symbol->children.push_back(lambda_symbol);
+						}
 					}
 					break;
 				case SuiteNode::Local::PARAMETER:
-					symbol.range = range_of_node(local.parameter);
-					symbol.selectionRange = range_of_node(local.parameter->identifier);
+					symbol->range = range_of_node(local.parameter);
+					symbol->selectionRange = range_of_node(local.parameter->identifier);
 					break;
 				case SuiteNode::Local::FOR_VARIABLE:
 				case SuiteNode::Local::PATTERN_BIND:
-					symbol.range = range_of_node(local.bind);
-					symbol.selectionRange = range_of_node(local.bind);
+					symbol->range = range_of_node(local.bind);
+					symbol->selectionRange = range_of_node(local.bind);
 					break;
 				default:
 					// Fallback.
-					symbol.range.start = GodotPosition(local.start_line, local.start_column).to_lsp(get_lines());
-					symbol.range.end = GodotPosition(local.end_line, local.end_column).to_lsp(get_lines());
-					symbol.selectionRange = symbol.range;
+					symbol->range.start = GodotPosition(local.start_line, local.start_column).to_lsp(get_lines());
+					symbol->range.end = GodotPosition(local.end_line, local.end_column).to_lsp(get_lines());
+					symbol->selectionRange = symbol->range;
 					break;
 			}
-			symbol.local = true;
-			symbol.uri = uri;
-			symbol.script_path = path;
-			symbol.detail = local.type == SuiteNode::Local::CONSTANT ? "const " : "var ";
-			symbol.detail += symbol.name;
+			symbol->local = true;
+			symbol->uri = uri;
+			symbol->script_path = path;
+			symbol->detail = local.type == SuiteNode::Local::CONSTANT ? "const " : "var ";
+			symbol->detail += symbol->name;
 			if (local.get_datatype().is_hard_type()) {
-				symbol.detail += ": " + local.get_datatype().to_string();
+				symbol->detail += ": " + local.get_datatype().to_string();
 			}
+			symbol->reduced_detail = symbol->detail;
 			switch (local.type) {
 				case SuiteNode::Local::CONSTANT:
-					symbol.documentation = local.constant->doc_data.description;
+					symbol->documentation = local.constant->doc_data.description;
 					break;
 				case SuiteNode::Local::VARIABLE:
-					symbol.documentation = local.variable->doc_data.description;
+					symbol->documentation = local.variable->doc_data.description;
 					break;
 				default:
 					break;
 			}
-			r_symbol.children.push_back(symbol);
+			symbol->parent = r_symbol;
+			r_symbol->children.push_back(symbol);
 		}
 	}
 }
@@ -744,15 +775,15 @@ String ExtendGDScriptParser::get_uri() const {
 	return GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_uri(path);
 }
 
-const lsp::DocumentSymbol *ExtendGDScriptParser::search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent, const String &p_symbol_name) const {
+const lsp::DocumentSymbol *ExtendGDScriptParser::search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol *p_parent, const String &p_symbol_name) const {
 	const lsp::DocumentSymbol *ret = nullptr;
-	if (p_line < p_parent.range.start.line) {
+	if (p_line < p_parent->range.start.line) {
 		return ret;
-	} else if (p_parent.range.start.line == p_line && (p_symbol_name.is_empty() || p_parent.name == p_symbol_name)) {
-		return &p_parent;
+	} else if (p_parent->range.start.line == p_line && (p_symbol_name.is_empty() || p_parent->name == p_symbol_name)) {
+		return p_parent;
 	} else {
-		for (int i = 0; i < p_parent.children.size(); i++) {
-			ret = search_symbol_defined_at_line(p_line, p_parent.children[i], p_symbol_name);
+		for (int i = 0; i < p_parent->children.size(); i++) {
+			ret = search_symbol_defined_at_line(p_line, p_parent->children[i], p_symbol_name);
 			if (ret) {
 				break;
 			}
@@ -807,7 +838,7 @@ Error ExtendGDScriptParser::get_left_function_call(const lsp::Position &p_positi
 
 const lsp::DocumentSymbol *ExtendGDScriptParser::get_symbol_defined_at_line(int p_line, const String &p_symbol_name) const {
 	if (p_line <= 0) {
-		return &class_symbol;
+		return class_symbol;
 	}
 	return search_symbol_defined_at_line(p_line, class_symbol, p_symbol_name);
 }
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.h b/modules/gdscript/language_server/gdscript_extend_parser.h
index a808f19e5b53..3a74f4e4b750 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.h
+++ b/modules/gdscript/language_server/gdscript_extend_parser.h
@@ -115,7 +115,7 @@ class ExtendGDScriptParser : public GDScriptParser {
 	String path;
 	Vector<String> lines;
 
-	lsp::DocumentSymbol class_symbol;
+	lsp::DocumentSymbol *class_symbol = memnew(lsp::DocumentSymbol);
 	Vector<lsp::Diagnostic> diagnostics;
 	List<lsp::DocumentLink> document_links;
 	ClassMembers members;
@@ -127,20 +127,21 @@ 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_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol);
+	void parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol *r_symbol);
+	void parse_enum_value_symbol(const GDScriptParser::EnumNode::Value *p_value, 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_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;
+	const lsp::DocumentSymbol *search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol *p_parent, const String &p_symbol_name = "") const;
 
 	Array member_completions;
 
 public:
 	_FORCE_INLINE_ const String &get_path() const { return path; }
 	_FORCE_INLINE_ const Vector<String> &get_lines() const { return lines; }
-	_FORCE_INLINE_ const lsp::DocumentSymbol &get_symbols() const { return class_symbol; }
+	_FORCE_INLINE_ const lsp::DocumentSymbol *get_symbols() const { return class_symbol; }
 	_FORCE_INLINE_ const Vector<lsp::Diagnostic> &get_diagnostics() const { return diagnostics; }
 	_FORCE_INLINE_ const ClassMembers &get_members() const { return members; }
 	_FORCE_INLINE_ const HashMap<String, ClassMembers> &get_inner_classes() const { return inner_classes; }
diff --git a/modules/gdscript/language_server/gdscript_text_document.cpp b/modules/gdscript/language_server/gdscript_text_document.cpp
index 9bf458e031cd..e873063f861d 100644
--- a/modules/gdscript/language_server/gdscript_text_document.cpp
+++ b/modules/gdscript/language_server/gdscript_text_document.cpp
@@ -165,8 +165,8 @@ Array GDScriptTextDocument::documentSymbol(const Dictionary &p_params) {
 	String path = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_path(uri);
 	Array arr;
 	if (HashMap<String, ExtendGDScriptParser *>::ConstIterator parser = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(path)) {
-		lsp::DocumentSymbol symbol = parser->value->get_symbols();
-		arr.push_back(symbol.to_json(true));
+		const lsp::DocumentSymbol *symbol = parser->value->get_symbols();
+		arr.push_back(symbol->to_json(true));
 	}
 	return arr;
 }
@@ -258,7 +258,7 @@ Variant GDScriptTextDocument::prepareRename(const Dictionary &p_params) {
 	lsp::TextDocumentPositionParams params;
 	params.load(p_params);
 
-	lsp::DocumentSymbol symbol;
+	lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
 	lsp::Range range;
 	if (GDScriptLanguageProtocol::get_singleton()->get_workspace()->can_rename(params, symbol, range)) {
 		return Variant(range.to_json());
@@ -276,7 +276,7 @@ Array GDScriptTextDocument::references(const Dictionary &p_params) {
 
 	const lsp::DocumentSymbol *symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace()->resolve_symbol(params);
 	if (symbol) {
-		Vector<lsp::Location> usages = GDScriptLanguageProtocol::get_singleton()->get_workspace()->find_all_usages(*symbol);
+		Vector<lsp::Location> usages = GDScriptLanguageProtocol::get_singleton()->get_workspace()->find_all_usages(symbol);
 		res.resize(usages.size());
 		int declaration_adjustment = 0;
 		for (int i = 0; i < usages.size(); i++) {
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index 81933c8c87a7..32165dcd0c9c 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -142,16 +142,16 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_
 	StringName empty;
 
 	while (class_name != empty) {
-		if (HashMap<StringName, lsp::DocumentSymbol>::ConstIterator E = native_symbols.find(class_name)) {
-			const lsp::DocumentSymbol &class_symbol = E->value;
+		if (HashMap<StringName, lsp::DocumentSymbol *>::ConstIterator E = native_symbols.find(class_name)) {
+			const lsp::DocumentSymbol *class_symbol = E->value;
 
 			if (p_member.is_empty()) {
-				return &class_symbol;
+				return class_symbol;
 			} else {
-				for (int i = 0; i < class_symbol.children.size(); i++) {
-					const lsp::DocumentSymbol &symbol = class_symbol.children[i];
-					if (symbol.name == p_member) {
-						return &symbol;
+				for (int i = 0; i < class_symbol->children.size(); i++) {
+					const lsp::DocumentSymbol *symbol = class_symbol->children[i];
+					if (symbol->name == p_member) {
+						return symbol;
 					}
 				}
 			}
@@ -165,14 +165,14 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_
 const lsp::DocumentSymbol *GDScriptWorkspace::get_script_symbol(const String &p_path) const {
 	HashMap<String, ExtendGDScriptParser *>::ConstIterator S = scripts.find(p_path);
 	if (S) {
-		return &(S->value->get_symbols());
+		return S->value->get_symbols();
 	}
 	return nullptr;
 }
 
 const lsp::DocumentSymbol *GDScriptWorkspace::get_parameter_symbol(const lsp::DocumentSymbol *p_parent, const String &symbol_identifier) {
 	for (int i = 0; i < p_parent->children.size(); ++i) {
-		const lsp::DocumentSymbol *parameter_symbol = &p_parent->children[i];
+		const lsp::DocumentSymbol *parameter_symbol = p_parent->children[i];
 		if (!parameter_symbol->detail.is_empty() && parameter_symbol->name == symbol_identifier) {
 			return parameter_symbol;
 		}
@@ -184,7 +184,7 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_parameter_symbol(const lsp::Do
 const lsp::DocumentSymbol *GDScriptWorkspace::get_local_symbol_at(const ExtendGDScriptParser *p_parser, const String &p_symbol_identifier, const lsp::Position p_position) {
 	// Go down and pick closest `DocumentSymbol` with `p_symbol_identifier`.
 
-	const lsp::DocumentSymbol *current = &p_parser->get_symbols();
+	const lsp::DocumentSymbol *current = p_parser->get_symbols();
 	const lsp::DocumentSymbol *best_match = nullptr;
 
 	while (current) {
@@ -199,9 +199,9 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_local_symbol_at(const ExtendGD
 
 		const lsp::DocumentSymbol *parent = current;
 		current = nullptr;
-		for (const lsp::DocumentSymbol &child : parent->children) {
-			if (child.range.contains(p_position)) {
-				current = &child;
+		for (const lsp::DocumentSymbol *child : parent->children) {
+			if (child->range.contains(p_position)) {
+				current = child;
 				break;
 			}
 		}
@@ -280,57 +280,60 @@ Error GDScriptWorkspace::initialize() {
 	DocTools *doc = EditorHelp::get_doc_data();
 	for (const KeyValue<String, DocData::ClassDoc> &E : doc->class_list) {
 		const DocData::ClassDoc &class_data = E.value;
-		lsp::DocumentSymbol class_symbol;
+		lsp::DocumentSymbol *class_symbol = memnew(lsp::DocumentSymbol);
 		String class_name = E.key;
-		class_symbol.name = class_name;
-		class_symbol.native_class = class_name;
-		class_symbol.kind = lsp::SymbolKind::Class;
-		class_symbol.detail = String("<Native> class ") + class_name;
+		class_symbol->name = class_name;
+		class_symbol->native_class = class_name;
+		class_symbol->kind = lsp::SymbolKind::Class;
+		class_symbol->detail = String("<Native> class ") + class_name;
 		if (!class_data.inherits.is_empty()) {
-			class_symbol.detail += " extends " + class_data.inherits;
+			class_symbol->detail += " extends " + class_data.inherits;
 		}
-		class_symbol.documentation = class_data.brief_description + "\n" + class_data.description;
+		class_symbol->documentation = class_data.brief_description + "\n" + class_data.description;
 
 		for (int i = 0; i < class_data.constants.size(); i++) {
 			const DocData::ConstantDoc &const_data = class_data.constants[i];
-			lsp::DocumentSymbol symbol;
-			symbol.name = const_data.name;
-			symbol.native_class = class_name;
-			symbol.kind = lsp::SymbolKind::Constant;
-			symbol.detail = "const " + class_name + "." + const_data.name;
+			lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+			symbol->name = const_data.name;
+			symbol->native_class = class_name;
+			symbol->kind = lsp::SymbolKind::Constant;
+			symbol->detail = "const " + class_name + "." + const_data.name;
 			if (const_data.enumeration.length()) {
-				symbol.detail += ": " + const_data.enumeration;
+				symbol->detail += ": " + const_data.enumeration;
 			}
-			symbol.detail += " = " + const_data.value;
-			symbol.documentation = const_data.description;
-			class_symbol.children.push_back(symbol);
+			symbol->detail += " = " + const_data.value;
+			symbol->documentation = const_data.description;
+			symbol->parent = class_symbol;
+			class_symbol->children.push_back(symbol);
 		}
 
 		for (int i = 0; i < class_data.properties.size(); i++) {
 			const DocData::PropertyDoc &data = class_data.properties[i];
-			lsp::DocumentSymbol symbol;
-			symbol.name = data.name;
-			symbol.native_class = class_name;
-			symbol.kind = lsp::SymbolKind::Property;
-			symbol.detail = "var " + class_name + "." + data.name;
+			lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+			symbol->name = data.name;
+			symbol->native_class = class_name;
+			symbol->kind = lsp::SymbolKind::Property;
+			symbol->detail = "var " + class_name + "." + data.name;
 			if (data.enumeration.length()) {
-				symbol.detail += ": " + data.enumeration;
+				symbol->detail += ": " + data.enumeration;
 			} else {
-				symbol.detail += ": " + data.type;
+				symbol->detail += ": " + data.type;
 			}
-			symbol.documentation = data.description;
-			class_symbol.children.push_back(symbol);
+			symbol->documentation = data.description;
+			symbol->parent = class_symbol;
+			class_symbol->children.push_back(symbol);
 		}
 
 		for (int i = 0; i < class_data.theme_properties.size(); i++) {
 			const DocData::ThemeItemDoc &data = class_data.theme_properties[i];
-			lsp::DocumentSymbol symbol;
-			symbol.name = data.name;
-			symbol.native_class = class_name;
-			symbol.kind = lsp::SymbolKind::Property;
-			symbol.detail = "<Theme> var " + class_name + "." + data.name + ": " + data.type;
-			symbol.documentation = data.description;
-			class_symbol.children.push_back(symbol);
+			lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+			symbol->name = data.name;
+			symbol->native_class = class_name;
+			symbol->kind = lsp::SymbolKind::Property;
+			symbol->detail = "<Theme> var " + class_name + "." + data.name + ": " + data.type;
+			symbol->documentation = data.description;
+			symbol->parent = class_symbol;
+			class_symbol->children.push_back(symbol);
 		}
 
 		Vector<DocData::MethodDoc> methods_signals;
@@ -343,20 +346,20 @@ Error GDScriptWorkspace::initialize() {
 		for (int i = 0; i < methods_signals.size(); i++) {
 			const DocData::MethodDoc &data = methods_signals[i];
 
-			lsp::DocumentSymbol symbol;
-			symbol.name = data.name;
-			symbol.native_class = class_name;
-			symbol.kind = i >= signal_start_idx ? lsp::SymbolKind::Event : lsp::SymbolKind::Method;
+			lsp::DocumentSymbol *symbol = memnew(lsp::DocumentSymbol);
+			symbol->name = data.name;
+			symbol->native_class = class_name;
+			symbol->kind = i >= signal_start_idx ? lsp::SymbolKind::Event : lsp::SymbolKind::Method;
 
 			String params = "";
 			bool arg_default_value_started = false;
 			for (int j = 0; j < data.arguments.size(); j++) {
 				const DocData::ArgumentDoc &arg = data.arguments[j];
 
-				lsp::DocumentSymbol symbol_arg;
-				symbol_arg.name = arg.name;
-				symbol_arg.kind = lsp::SymbolKind::Variable;
-				symbol_arg.detail = arg.type;
+				lsp::DocumentSymbol *symbol_arg = memnew(lsp::DocumentSymbol);
+				symbol_arg->name = arg.name;
+				symbol_arg->kind = lsp::SymbolKind::Variable;
+				symbol_arg->detail = arg.type;
 
 				if (!arg_default_value_started && !arg.default_value.is_empty()) {
 					arg_default_value_started = true;
@@ -370,7 +373,8 @@ Error GDScriptWorkspace::initialize() {
 				}
 				params += arg_str;
 
-				symbol.children.push_back(symbol_arg);
+				symbol_arg->parent = symbol;
+				symbol->children.push_back(symbol_arg);
 			}
 			if (data.qualifiers.contains("vararg")) {
 				params += params.is_empty() ? "..." : ", ...";
@@ -380,9 +384,10 @@ Error GDScriptWorkspace::initialize() {
 			if (return_type.is_empty()) {
 				return_type = "void";
 			}
-			symbol.detail = "func " + class_name + "." + data.name + "(" + params + ") -> " + return_type;
-			symbol.documentation = data.description;
-			class_symbol.children.push_back(symbol);
+			symbol->detail = "func " + class_name + "." + data.name + "(" + params + ") -> " + return_type;
+			symbol->documentation = data.description;
+			symbol->parent = class_symbol;
+			class_symbol->children.push_back(symbol);
 		}
 
 		native_symbols.insert(class_name, class_symbol);
@@ -391,12 +396,12 @@ Error GDScriptWorkspace::initialize() {
 	reload_all_workspace_scripts();
 
 	if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
-		for (const KeyValue<StringName, lsp::DocumentSymbol> &E : native_symbols) {
+		for (const KeyValue<StringName, lsp::DocumentSymbol *> &E : native_symbols) {
 			ClassMembers members;
-			const lsp::DocumentSymbol &class_symbol = E.value;
-			for (int i = 0; i < class_symbol.children.size(); i++) {
-				const lsp::DocumentSymbol &symbol = class_symbol.children[i];
-				members.insert(symbol.name, &symbol);
+			const lsp::DocumentSymbol *class_symbol = E.value;
+			for (int i = 0; i < class_symbol->children.size(); i++) {
+				const lsp::DocumentSymbol *symbol = class_symbol->children[i];
+				members.insert(symbol->name, symbol);
 			}
 			native_members.insert(E.key, members);
 		}
@@ -460,7 +465,7 @@ Dictionary GDScriptWorkspace::rename(const lsp::TextDocumentPositionParams &p_do
 
 	const lsp::DocumentSymbol *reference_symbol = resolve_symbol(p_doc_pos);
 	if (is_valid_rename_target(reference_symbol)) {
-		Vector<lsp::Location> usages = find_all_usages(*reference_symbol);
+		Vector<lsp::Location> usages = find_all_usages(reference_symbol);
 		for (int i = 0; i < usages.size(); ++i) {
 			lsp::Location loc = usages[i];
 
@@ -471,7 +476,7 @@ Dictionary GDScriptWorkspace::rename(const lsp::TextDocumentPositionParams &p_do
 	return edit.to_json();
 }
 
-bool GDScriptWorkspace::can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::DocumentSymbol &r_symbol, lsp::Range &r_range) {
+bool GDScriptWorkspace::can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, const lsp::DocumentSymbol *r_symbol, lsp::Range &r_range) {
 	const lsp::DocumentSymbol *reference_symbol = resolve_symbol(p_doc_pos);
 	if (!is_valid_rename_target(reference_symbol)) {
 		return false;
@@ -480,17 +485,17 @@ bool GDScriptWorkspace::can_rename(const lsp::TextDocumentPositionParams &p_doc_
 	String path = get_file_path(p_doc_pos.textDocument.uri);
 	if (const ExtendGDScriptParser *parser = get_parse_result(path)) {
 		parser->get_identifier_under_position(p_doc_pos.position, r_range);
-		r_symbol = *reference_symbol;
+		r_symbol = reference_symbol;
 		return true;
 	}
 
 	return false;
 }
 
-Vector<lsp::Location> GDScriptWorkspace::find_usages_in_file(const lsp::DocumentSymbol &p_symbol, const String &p_file_path) {
+Vector<lsp::Location> GDScriptWorkspace::find_usages_in_file(const lsp::DocumentSymbol *p_symbol, const String &p_file_path) {
 	Vector<lsp::Location> usages;
 
-	String identifier = p_symbol.name;
+	String identifier = p_symbol->name;
 	if (const ExtendGDScriptParser *parser = get_parse_result(p_file_path)) {
 		const PackedStringArray &content = parser->get_lines();
 		for (int i = 0; i < content.size(); ++i) {
@@ -509,7 +514,7 @@ Vector<lsp::Location> GDScriptWorkspace::find_usages_in_file(const lsp::Document
 
 				const lsp::DocumentSymbol *other_symbol = resolve_symbol(params);
 
-				if (other_symbol == &p_symbol) {
+				if (other_symbol == p_symbol) {
 					lsp::Location loc;
 					loc.uri = text_doc.uri;
 					loc.range.start = params.position;
@@ -526,10 +531,10 @@ Vector<lsp::Location> GDScriptWorkspace::find_usages_in_file(const lsp::Document
 	return usages;
 }
 
-Vector<lsp::Location> GDScriptWorkspace::find_all_usages(const lsp::DocumentSymbol &p_symbol) {
-	if (p_symbol.local) {
+Vector<lsp::Location> GDScriptWorkspace::find_all_usages(const lsp::DocumentSymbol *p_symbol) {
+	if (p_symbol->local) {
 		// Only search in current document.
-		return find_usages_in_file(p_symbol, p_symbol.script_path);
+		return find_usages_in_file(p_symbol, p_symbol->script_path);
 	}
 	// Search in all documents.
 	List<String> paths;
@@ -766,15 +771,15 @@ void GDScriptWorkspace::resolve_related_symbols(const lsp::TextDocumentPositionP
 }
 
 const lsp::DocumentSymbol *GDScriptWorkspace::resolve_native_symbol(const lsp::NativeSymbolInspectParams &p_params) {
-	if (HashMap<StringName, lsp::DocumentSymbol>::Iterator E = native_symbols.find(p_params.native_class)) {
-		const lsp::DocumentSymbol &symbol = E->value;
-		if (p_params.symbol_name.is_empty() || p_params.symbol_name == symbol.name) {
-			return &symbol;
+	if (HashMap<StringName, lsp::DocumentSymbol *>::Iterator E = native_symbols.find(p_params.native_class)) {
+		const lsp::DocumentSymbol *symbol = E->value;
+		if (p_params.symbol_name.is_empty() || p_params.symbol_name == symbol->name) {
+			return symbol;
 		}
 
-		for (int i = 0; i < symbol.children.size(); ++i) {
-			if (symbol.children[i].name == p_params.symbol_name) {
-				return &(symbol.children[i]);
+		for (int i = 0; i < symbol->children.size(); ++i) {
+			if (symbol->children[i]->name == p_params.symbol_name) {
+				return symbol->children[i];
 			}
 		}
 	}
@@ -820,9 +825,9 @@ Error GDScriptWorkspace::resolve_signature(const lsp::TextDocumentPositionParams
 					signature_info.documentation = symbol->render();
 
 					for (int i = 0; i < symbol->children.size(); i++) {
-						const lsp::DocumentSymbol &arg = symbol->children[i];
+						const lsp::DocumentSymbol *arg = symbol->children[i];
 						lsp::ParameterInformation arg_info;
-						arg_info.label = arg.name;
+						arg_info.label = arg->name;
 						signature_info.parameters.push_back(arg_info);
 					}
 					r_signature.signatures.push_back(signature_info);
diff --git a/modules/gdscript/language_server/gdscript_workspace.h b/modules/gdscript/language_server/gdscript_workspace.h
index 0b2d43b81748..06e043247690 100644
--- a/modules/gdscript/language_server/gdscript_workspace.h
+++ b/modules/gdscript/language_server/gdscript_workspace.h
@@ -49,7 +49,7 @@ class GDScriptWorkspace : public RefCounted {
 	static void _bind_methods();
 	void remove_cache_parser(const String &p_path);
 	bool initialized = false;
-	HashMap<StringName, lsp::DocumentSymbol> native_symbols;
+	HashMap<StringName, lsp::DocumentSymbol *> native_symbols;
 
 	const lsp::DocumentSymbol *get_native_symbol(const String &p_class, const String &p_member = "") const;
 	const lsp::DocumentSymbol *get_script_symbol(const String &p_path) const;
@@ -93,9 +93,9 @@ class GDScriptWorkspace : public RefCounted {
 	Error resolve_signature(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::SignatureHelp &r_signature);
 	void did_delete_files(const Dictionary &p_params);
 	Dictionary rename(const lsp::TextDocumentPositionParams &p_doc_pos, const String &new_name);
-	bool can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::DocumentSymbol &r_symbol, lsp::Range &r_range);
-	Vector<lsp::Location> find_usages_in_file(const lsp::DocumentSymbol &p_symbol, const String &p_file_path);
-	Vector<lsp::Location> find_all_usages(const lsp::DocumentSymbol &p_symbol);
+	bool can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, const lsp::DocumentSymbol *r_symbol, lsp::Range &r_range);
+	Vector<lsp::Location> find_usages_in_file(const lsp::DocumentSymbol *p_symbol, const String &p_file_path);
+	Vector<lsp::Location> find_all_usages(const lsp::DocumentSymbol *p_symbol);
 
 	GDScriptWorkspace();
 	~GDScriptWorkspace();
diff --git a/modules/gdscript/language_server/godot_lsp.h b/modules/gdscript/language_server/godot_lsp.h
index e09adb74bd89..f846b0ed1a5b 100644
--- a/modules/gdscript/language_server/godot_lsp.h
+++ b/modules/gdscript/language_server/godot_lsp.h
@@ -83,10 +83,22 @@ struct Position {
 	 */
 	int character = 0;
 
-	_FORCE_INLINE_ bool operator==(const Position &p_other) const {
+	_FORCE_INLINE_ bool operator == (const Position &p_other) const {
 		return line == p_other.line && character == p_other.character;
 	}
 
+	_FORCE_INLINE_ bool operator >= (const Position &p_other) const {
+		if (line > p_other.line) return true;
+		if (line == p_other.line && character >= p_other.character) return true;
+		return false;
+	}
+
+	_FORCE_INLINE_ bool operator <= (const Position &p_other) const {
+		if (line < p_other.line) return true;
+		if (line == p_other.line && character <= p_other.character) return true;
+		return false;
+	}
+
 	String to_string() const {
 		return vformat("(%d,%d)", line, character);
 	}
@@ -120,10 +132,14 @@ struct Range {
 	 */
 	Position end;
 
-	_FORCE_INLINE_ bool operator==(const Range &p_other) const {
+	_FORCE_INLINE_ bool operator == (const Range &p_other) const {
 		return start == p_other.start && end == p_other.end;
 	}
 
+	bool is_within(const Range& other) const {
+		return start >= other.start && end <= other.end;
+	}
+
 	bool contains(const Position &p_pos) const {
 		// Inside line range.
 		if (start.line <= p_pos.line && p_pos.line <= end.line) {
@@ -1161,6 +1177,11 @@ struct DocumentSymbol {
 	 */
 	String detail;
 
+	/**
+	 * More detail for this symbol - without values, e.g the signature of a function.
+	 */
+	String reduced_detail;
+
 	/**
 	 * Documentation for this symbol.
 	 */
@@ -1204,10 +1225,12 @@ struct DocumentSymbol {
 	DocumentUri uri;
 	String script_path;
 
+	DocumentSymbol *parent = nullptr;
+
 	/**
 	 * Children of this symbol, e.g. properties of a class.
 	 */
-	Vector<DocumentSymbol> children;
+	Vector<DocumentSymbol *> children;
 
 	Dictionary to_json(bool with_doc = false) const {
 		Dictionary dict;
@@ -1224,10 +1247,10 @@ struct DocumentSymbol {
 		if (!children.is_empty()) {
 			Array arr;
 			for (int i = 0; i < children.size(); i++) {
-				if (children[i].local) {
+				if (children[i]->local) {
 					continue;
 				}
-				arr.push_back(children[i].to_json(with_doc));
+				arr.push_back(children[i]->to_json(with_doc));
 			}
 			if (!children.is_empty()) {
 				dict["children"] = arr;
diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp
index f8bd65ae0685..de02f319b410 100644
--- a/scene/gui/text_edit.cpp
+++ b/scene/gui/text_edit.cpp
@@ -5396,6 +5396,14 @@ HScrollBar *TextEdit::get_h_scroll_bar() const {
 	return h_scroll;
 }
 
+void TextEdit::set_v_scroll_visibility(bool p_visible) {
+	v_scroll_enabled = p_visible;
+}
+
+void TextEdit::set_h_scroll_visibility(bool p_visible) {
+	h_scroll_enabled = p_visible;
+}
+
 void TextEdit::set_v_scroll(double p_scroll) {
 	v_scroll->set_value(p_scroll);
 	int max_v_scroll = v_scroll->get_max() - v_scroll->get_page();
@@ -7377,7 +7385,7 @@ void TextEdit::_update_scrollbars() {
 
 	updating_scrolls = true;
 
-	if (total_rows > visible_rows) {
+	if (total_rows > visible_rows && v_scroll_enabled) {
 		v_scroll->show();
 		v_scroll->set_max(total_rows + _get_visible_lines_offset());
 		v_scroll->set_page(visible_rows + _get_visible_lines_offset());
@@ -7391,7 +7399,7 @@ void TextEdit::_update_scrollbars() {
 		v_scroll->hide();
 	}
 
-	if (total_width > visible_width) {
+	if (total_width > visible_width && h_scroll_enabled) {
 		h_scroll->show();
 		h_scroll->set_max(total_width);
 		h_scroll->set_page(visible_width);
diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h
index d49be860a9c7..c47452d46e17 100644
--- a/scene/gui/text_edit.h
+++ b/scene/gui/text_edit.h
@@ -478,6 +478,9 @@ class TextEdit : public Control {
 	HScrollBar *h_scroll = nullptr;
 	VScrollBar *v_scroll = nullptr;
 
+	bool h_scroll_enabled = true;
+	bool v_scroll_enabled = true;
+
 	float content_height_cache = 0.0;
 	bool fit_content_height = false;
 	bool scroll_past_end_of_file_enabled = false;
@@ -924,9 +927,11 @@ class TextEdit : public Control {
 	VScrollBar *get_v_scroll_bar() const;
 	HScrollBar *get_h_scroll_bar() const;
 
+	void set_v_scroll_visibility(bool p_enabled);
 	void set_v_scroll(double p_scroll);
 	double get_v_scroll() const;
 
+	void set_h_scroll_visibility(bool p_enabled);
 	void set_h_scroll(int p_scroll);
 	int get_h_scroll() const;