From 4405e9ddbc9e12619d475b76aa670144755059b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Pedro=20Braz?= <brazjoaopedro@ymail.com>
Date: Wed, 3 May 2023 19:19:30 -0300
Subject: [PATCH] [Nullable] Implement Nullable Types for GDScript

This PR aims to add a feature-set to GDScript tailored
towards the safe usage of potentially-null expressions.
It was initially based off godotengine/godot-proposals#162
and through several discussions over RocketChat it grew to be what it is currently.
---
 core/core_constants.cpp                       |   1 +
 core/object/object.h                          |   1 +
 core/variant/array.cpp                        |  27 +-
 core/variant/array.h                          |   5 +-
 core/variant/container_type_validate.h        |  12 +-
 core/variant/variant_op.cpp                   |   4 +-
 doc/classes/@GlobalScope.xml                  |   3 +
 modules/gdscript/gdscript_analyzer.cpp        | 978 +++++++++++++++++-
 modules/gdscript/gdscript_analyzer.h          |  55 +-
 modules/gdscript/gdscript_byte_codegen.cpp    | 126 ++-
 modules/gdscript/gdscript_byte_codegen.h      |  27 +-
 modules/gdscript/gdscript_codegen.h           |  21 +-
 modules/gdscript/gdscript_compiler.cpp        |  52 +-
 modules/gdscript/gdscript_disassembler.cpp    |  30 +-
 modules/gdscript/gdscript_function.h          |   9 +
 modules/gdscript/gdscript_parser.cpp          | 151 ++-
 modules/gdscript/gdscript_parser.h            |  57 +-
 modules/gdscript/gdscript_tokenizer.cpp       |  13 +-
 modules/gdscript/gdscript_tokenizer.h         |   7 +
 modules/gdscript/gdscript_vm.cpp              |  95 +-
 .../errors/nullable_access_operator.gd        |   5 +
 .../errors/nullable_access_operator.out       |   2 +
 .../errors/nullable_access_operator_index.gd  |   8 +
 .../errors/nullable_access_operator_index.out |   2 +
 .../nullable_access_operator_method_call.gd   |   7 +
 .../nullable_access_operator_method_call.out  |   2 +
 .../nullable_assignment_to_non_nullable.gd    |   3 +
 .../nullable_assignment_to_non_nullable.out   |   2 +
 ...ment_to_non_nullable_from_method_return.gd |   6 +
 ...ent_to_non_nullable_from_method_return.out |   2 +
 .../errors/nullable_attribute_access.gd       |   6 +
 .../errors/nullable_attribute_access.out      |   2 +
 .../nullable_attribute_access_nested.gd       |   9 +
 .../nullable_attribute_access_nested.out      |   2 +
 .../errors/nullable_binary_operator.gd        |   3 +
 .../errors/nullable_binary_operator.out       |   2 +
 .../nullable_binary_operator_both_operands.gd |   4 +
 ...nullable_binary_operator_both_operands.out |   2 +
 .../errors/nullable_cast_attribute_access.gd  |   6 +
 .../errors/nullable_cast_attribute_access.out |   2 +
 .../errors/nullable_cast_method_call.gd       |   4 +
 .../errors/nullable_cast_method_call.out      |   2 +
 .../analyzer/errors/nullable_class_member.gd  |   5 +
 .../analyzer/errors/nullable_class_member.out |   2 +
 .../errors/nullable_elif_narrowing.gd         |   8 +
 .../errors/nullable_elif_narrowing.out        |   2 +
 .../analyzer/errors/nullable_for_on_call.gd   |   6 +
 .../analyzer/errors/nullable_for_on_call.out  |   2 +
 .../errors/nullable_for_on_identifier.gd      |   4 +
 .../errors/nullable_for_on_identifier.out     |   2 +
 .../errors/nullable_for_on_subscript.gd       |   6 +
 .../errors/nullable_for_on_subscript.out      |   2 +
 ...assigment_with_nullable_access_operator.gd |   5 +
 ...ssigment_with_nullable_access_operator.out |   2 +
 .../analyzer/errors/nullable_index_access.gd  |   3 +
 .../analyzer/errors/nullable_index_access.out |   2 +
 .../errors/nullable_index_access_nested.gd    |   9 +
 .../errors/nullable_index_access_nested.out   |   2 +
 ..._index_access_nested_on_nullable_return.gd |   8 +
 ...index_access_nested_on_nullable_return.out |   2 +
 .../nullable_index_access_with_nullable.gd    |   4 +
 .../nullable_index_access_with_nullable.out   |   2 +
 .../errors/nullable_is_instance_of.gd         |   5 +
 .../errors/nullable_is_instance_of.out        |   2 +
 .../errors/nullable_match_narrowing.gd        |   7 +
 .../errors/nullable_match_narrowing.out       |   2 +
 .../analyzer/errors/nullable_method_call.gd   |   7 +
 .../analyzer/errors/nullable_method_call.out  |   2 +
 .../errors/nullable_method_call_nested.gd     |  10 +
 .../errors/nullable_method_call_nested.out    |   2 +
 .../nullable_method_call_nested_index.gd      |  10 +
 .../nullable_method_call_nested_index.out     |   2 +
 ...e_method_call_nested_on_nullable_return.gd |   9 +
 ..._method_call_nested_on_nullable_return.out |   2 +
 .../analyzer/errors/nullable_method_return.gd |   7 +
 .../errors/nullable_method_return.out         |   2 +
 .../errors/nullable_narrowed_assignment.gd    |   6 +
 .../errors/nullable_narrowed_assignment.out   |   1 +
 .../analyzer/errors/nullable_narrowing.gd     |   4 +
 .../analyzer/errors/nullable_narrowing.out    |   2 +
 .../analyzer/errors/nullable_parameters.gd    |   7 +
 .../analyzer/errors/nullable_parameters.out   |   2 +
 ...le_qualifier_forbidden_for_native_types.gd |   2 +
 ...e_qualifier_forbidden_for_native_types.out |   2 +
 .../analyzer/errors/nullable_return.gd        |   6 +
 .../analyzer/errors/nullable_return.out       |   2 +
 .../nullable_return_on_non_nullable_method.gd |   8 +
 ...nullable_return_on_non_nullable_method.out |   2 +
 .../errors/nullable_subscript_as_index.gd     |   8 +
 .../errors/nullable_subscript_as_index.out    |   2 +
 .../analyzer/errors/nullable_ternary.gd       |   3 +
 .../analyzer/errors/nullable_ternary.out      |   2 +
 .../errors/nullable_type_inference.gd         |   7 +
 .../errors/nullable_type_inference.out        |   2 +
 .../errors/nullable_while_narrowing.gd        |   4 +
 .../errors/nullable_while_narrowing.out       |   2 +
 .../nullable_and_binary_operator_narrowing.gd |   5 +
 ...nullable_and_binary_operator_narrowing.out |   2 +
 .../analyzer/features/nullable_cast.gd        |   5 +
 .../analyzer/features/nullable_cast.out       |   3 +
 .../features/nullable_cast_narrowing.gd       |   4 +
 .../features/nullable_cast_narrowing.out      |   2 +
 .../analyzer/features/nullable_coalesce.gd    |   3 +
 .../analyzer/features/nullable_coalesce.out   |   2 +
 .../features/nullable_coalesce_narrowing.gd   |   3 +
 .../features/nullable_coalesce_narrowing.out  |   2 +
 .../features/nullable_complex_narrowing.gd    |   9 +
 .../features/nullable_complex_narrowing.out   |   1 +
 .../features/nullable_is_instance_of.gd       |   6 +
 .../features/nullable_is_instance_of.out      |   2 +
 .../features/nullable_is_instance_valid.gd    |   4 +
 .../features/nullable_is_instance_valid.out   |   1 +
 .../analyzer/features/nullable_is_same.gd     |   4 +
 .../analyzer/features/nullable_is_same.out    |   1 +
 .../features/nullable_match_narrowing.gd      |  13 +
 .../features/nullable_match_narrowing.out     |   2 +
 ...lable_method_return_with_container_type.gd |   8 +
 ...able_method_return_with_container_type.out |   2 +
 .../nullable_method_return_with_narrowing.gd  |   9 +
 .../nullable_method_return_with_narrowing.out |   2 +
 .../features/nullable_nested_narrowing.gd     |   5 +
 .../features/nullable_nested_narrowing.out    |   6 +
 .../features/nullable_setter_getter.gd        |  11 +
 .../features/nullable_setter_getter.out       |   4 +
 .../features/nullable_ternary_narrowing.gd    |   4 +
 .../features/nullable_ternary_narrowing.out   |   2 +
 .../analyzer/features/nullable_type_test.gd   |   5 +
 .../analyzer/features/nullable_type_test.out  |   2 +
 .../features/nullable_unary_operator.gd       |  14 +
 .../features/nullable_unary_operator.out      |   4 +
 .../features/nullable_variant_parameter.gd    |   4 +
 .../features/nullable_variant_parameter.out   |   2 +
 .../features/nullable_while_narrowing.gd      |   4 +
 .../features/nullable_while_narrowing.out     |   1 +
 ...lable_qualifier_forbidden_for_constants.gd |   2 +
 ...able_qualifier_forbidden_for_constants.out |   2 +
 .../nullable_access_on_freed_instance.gd      |   4 +
 .../nullable_access_on_freed_instance.out     |   2 +
 .../nullable_assignment_with_object.gd        |  10 +
 .../nullable_assignment_with_object.out       |   2 +
 .../nullable_binary_op_short_circuit.gd       |   5 +
 .../nullable_binary_op_short_circuit.out      |   1 +
 .../nullable_coalescing_on_freed_instance.gd  |   6 +
 .../nullable_coalescing_on_freed_instance.out |   2 +
 ...licit_narrowing_with_function_parameter.gd |   7 +
 ...icit_narrowing_with_function_parameter.out |   1 +
 146 files changed, 2014 insertions(+), 171 deletions(-)
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_return.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_return.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_cast.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_cast.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.out
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.gd
 create mode 100644 modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.out
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.gd
 create mode 100644 modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.out
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.out

diff --git a/core/core_constants.cpp b/core/core_constants.cpp
index 5322e39ec0de..1c60dbda11f5 100644
--- a/core/core_constants.cpp
+++ b/core/core_constants.cpp
@@ -710,6 +710,7 @@ void register_global_constants() {
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_EDITOR_BASIC_SETTING);
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_READ_ONLY);
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_SECRET);
+	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_NULLABLE);
 
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_DEFAULT);
 	BIND_CORE_BITFIELD_FLAG(PROPERTY_USAGE_NO_EDITOR);
diff --git a/core/object/object.h b/core/object/object.h
index adb50268d2ad..626c27d6e9f0 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -120,6 +120,7 @@ enum PropertyUsageFlags {
 	PROPERTY_USAGE_EDITOR_BASIC_SETTING = 1 << 27, //for project or editor settings, show when basic settings are selected.
 	PROPERTY_USAGE_READ_ONLY = 1 << 28, // Mark a property as read-only in the inspector.
 	PROPERTY_USAGE_SECRET = 1 << 29, // Export preset credentials that should be stored separately from the rest of the export config.
+	PROPERTY_USAGE_NULLABLE = 1 << 30, // When the property's type has the nullable qualifier.
 
 	PROPERTY_USAGE_DEFAULT = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR,
 	PROPERTY_USAGE_NO_EDITOR = PROPERTY_USAGE_STORAGE,
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index 3685515db5b0..f04b75b863a8 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -234,7 +234,7 @@ void Array::assign(const Array &p_array) {
 		// from base classes to subclasses
 		for (int i = 0; i < size; i++) {
 			const Variant &element = source[i];
-			if (element.get_type() != Variant::NIL && (element.get_type() != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
+			if ((element.get_type() != Variant::NIL && !_p->typed.is_nullable) && (element.get_type() != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
 				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %i from "%s" to "%s".)", i, Variant::get_type_name(element.get_type()), Variant::get_type_name(typed.type)));
 			}
 		}
@@ -253,7 +253,8 @@ void Array::assign(const Array &p_array) {
 		// from variants to primitives
 		for (int i = 0; i < size; i++) {
 			const Variant *value = source + i;
-			if (value->get_type() == typed.type) {
+			// Force-assign the current value if it's null, and we're nullable
+			if (value->get_type() == typed.type || (value->get_type() == Variant::NIL && _p->typed.is_nullable)) {
 				data[i] = *value;
 				continue;
 			}
@@ -264,13 +265,16 @@ void Array::assign(const Array &p_array) {
 			Variant::construct(typed.type, data[i], &value, 1, ce);
 			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %i from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
 		}
-	} else if (Variant::can_convert_strict(source_typed.type, typed.type)) {
+	} else if (Variant::can_convert_strict(source_typed.type, typed.type) && (source_typed.type != Variant::NIL || _p->typed.is_nullable)) {
 		// from primitives to different convertible primitives
 		for (int i = 0; i < size; i++) {
 			const Variant *value = source + i;
-			Callable::CallError ce;
-			Variant::construct(typed.type, data[i], &value, 1, ce);
-			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %i from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
+			// Avoid constructing the variant if it's null, and we're nullable
+			if (value->get_type() != Variant::NIL && !_p->typed.is_nullable) {
+				Callable::CallError ce;
+				Variant::construct(typed.type, data[i], &value, 1, ce);
+				ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %i from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
+			}
 		}
 	} else {
 		ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Array[%s]" to "Array[%s]".)", Variant::get_type_name(source_typed.type), Variant::get_type_name(typed.type)));
@@ -773,14 +777,14 @@ const void *Array::id() const {
 	return _p;
 }
 
-Array::Array(const Array &p_from, uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
+Array::Array(const Array &p_from, uint32_t p_type, const StringName &p_class_name, const Variant &p_script, bool p_is_nullable) {
 	_p = memnew(ArrayPrivate);
 	_p->refcount.init();
-	set_typed(p_type, p_class_name, p_script);
+	set_typed(p_type, p_class_name, p_script, p_is_nullable);
 	assign(p_from);
 }
 
-void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script) {
+void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script, bool p_is_nullable) {
 	ERR_FAIL_COND_MSG(_p->read_only, "Array is in read-only state.");
 	ERR_FAIL_COND_MSG(_p->array.size() > 0, "Type can only be set when array is empty.");
 	ERR_FAIL_COND_MSG(_p->refcount.get() > 1, "Type can only be set when array has no more than one user.");
@@ -792,6 +796,7 @@ void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Var
 	_p->typed.type = Variant::Type(p_type);
 	_p->typed.class_name = p_class_name;
 	_p->typed.script = script;
+	_p->typed.is_nullable = p_is_nullable;
 	_p->typed.where = "TypedArray";
 }
 
@@ -815,6 +820,10 @@ Variant Array::get_typed_script() const {
 	return _p->typed.script;
 }
 
+bool Array::is_nullable() const {
+	return _p->typed.is_nullable;
+}
+
 void Array::make_read_only() {
 	if (_p->read_only == nullptr) {
 		_p->read_only = memnew(Variant);
diff --git a/core/variant/array.h b/core/variant/array.h
index 3aa957b31268..e2b4477d2a9a 100644
--- a/core/variant/array.h
+++ b/core/variant/array.h
@@ -183,17 +183,18 @@ class Array {
 
 	const void *id() const;
 
-	void set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
+	void set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script, bool p_is_nullable = false);
 	bool is_typed() const;
 	bool is_same_typed(const Array &p_other) const;
 	uint32_t get_typed_builtin() const;
 	StringName get_typed_class_name() const;
 	Variant get_typed_script() const;
+	bool is_nullable() const;
 
 	void make_read_only();
 	bool is_read_only() const;
 
-	Array(const Array &p_base, uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
+	Array(const Array &p_base, uint32_t p_type, const StringName &p_class_name, const Variant &p_script, bool p_is_nullable = false);
 	Array(const Array &p_from);
 	Array();
 	~Array();
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index 0a23c69cb4bd..d4f9f35546ad 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -38,13 +38,15 @@ struct ContainerTypeValidate {
 	Variant::Type type = Variant::NIL;
 	StringName class_name;
 	Ref<Script> script;
+	bool is_nullable = false;
 	const char *where = "container";
 
 	_FORCE_INLINE_ bool can_reference(const ContainerTypeValidate &p_type) const {
 		if (type != p_type.type) {
 			return false;
 		} else if (type != Variant::OBJECT) {
-			return true;
+			// If this is not nullable, it can't safely be replaced by a nullable one.
+			return is_nullable || !p_type.is_nullable;
 		}
 
 		if (class_name == StringName()) {
@@ -67,10 +69,10 @@ struct ContainerTypeValidate {
 	}
 
 	_FORCE_INLINE_ bool operator==(const ContainerTypeValidate &p_type) const {
-		return type == p_type.type && class_name == p_type.class_name && script == p_type.script;
+		return type == p_type.type && class_name == p_type.class_name && script == p_type.script && is_nullable == p_type.is_nullable;
 	}
 	_FORCE_INLINE_ bool operator!=(const ContainerTypeValidate &p_type) const {
-		return type != p_type.type || class_name != p_type.class_name || script != p_type.script;
+		return type != p_type.type || class_name != p_type.class_name || script != p_type.script || is_nullable != p_type.is_nullable;
 	}
 
 	// Coerces String and StringName into each other and int into float when needed.
@@ -79,6 +81,10 @@ struct ContainerTypeValidate {
 			return true;
 		}
 
+		if (inout_variant.get_type() == Variant::NIL && is_nullable) {
+			return true;
+		}
+
 		if (type != inout_variant.get_type()) {
 			if (inout_variant.get_type() == Variant::NIL && type == Variant::OBJECT) {
 				return true;
diff --git a/core/variant/variant_op.cpp b/core/variant/variant_op.cpp
index d2c1cde970fb..874ba8bf62e3 100644
--- a/core/variant/variant_op.cpp
+++ b/core/variant/variant_op.cpp
@@ -1063,6 +1063,8 @@ void Variant::_register_variant_operators() {
 
 	register_op<OperatorEvaluatorObjectHasPropertyString>(Variant::OP_IN, Variant::STRING, Variant::OBJECT);
 	register_op<OperatorEvaluatorObjectHasPropertyStringName>(Variant::OP_IN, Variant::STRING_NAME, Variant::OBJECT);
+
+	register_op<OperatorEvaluatorObjectHasPropertyStringName>(Variant::OP_IN, Variant::STRING_NAME, Variant::OBJECT);
 }
 
 #undef register_string_op
@@ -1136,7 +1138,7 @@ static const char *_op_names[Variant::OP_MAX] = {
 	"or",
 	"xor",
 	"not",
-	"in"
+	"in",
 };
 
 String Variant::get_operator_name(Operator p_op) {
diff --git a/doc/classes/@GlobalScope.xml b/doc/classes/@GlobalScope.xml
index bcab80ea9426..f5c64bc32131 100644
--- a/doc/classes/@GlobalScope.xml
+++ b/doc/classes/@GlobalScope.xml
@@ -3023,6 +3023,9 @@
 		<constant name="PROPERTY_USAGE_SECRET" value="536870912" enum="PropertyUsageFlags" is_bitfield="true">
 			An export preset property with this flag contains confidential information and is stored separately from the rest of the export preset configuration.
 		</constant>
+		<constant name="PROPERTY_USAGE_NULLABLE" value="1073741824" enum="PropertyUsageFlags" is_bitfield="true">
+			The property has the nullable qualifier and therefore can be null.
+		</constant>
 		<constant name="PROPERTY_USAGE_DEFAULT" value="6" enum="PropertyUsageFlags" is_bitfield="true">
 			Default usage (storage and editor).
 		</constant>
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 8f37f4376c6b..e13e0c764b3f 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -33,6 +33,9 @@
 #include "gdscript.h"
 #include "gdscript_utility_callable.h"
 #include "gdscript_utility_functions.h"
+#ifdef TOOLS_ENABLED
+#include "editor/editor_settings.h"
+#endif
 
 #include "core/config/engine.h"
 #include "core/config/project_settings.h"
@@ -612,10 +615,12 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 
 	GDScriptParser::DataType resolving_datatype;
 	resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
+	bool is_nullable = p_type->datatype.is_nullable;
 	p_type->set_datatype(resolving_datatype);
 
 	GDScriptParser::DataType result;
 	result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+	result.is_nullable = is_nullable;
 
 	if (p_type->type_chain.is_empty()) {
 		// void.
@@ -671,6 +676,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				StringName qualified_name = String(first) + ENUM_SEPARATOR + String(p_type->type_chain[1]->name);
 				if (CoreConstants::is_global_enum(qualified_name)) {
 					result = make_global_enum_type(enum_name, first, true);
+					result.is_nullable = is_nullable;
 					return result;
 				} else {
 					push_error(vformat(R"(Name "%s" is not a nested type of "Variant".)", enum_name), p_type->type_chain[1]);
@@ -719,6 +725,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 					result = make_script_meta_type(ResourceLoader::load(path, "Script"));
 				}
 			}
+			result.is_nullable = is_nullable;
 		} else if (ProjectSettings::get_singleton()->has_autoload(first) && ProjectSettings::get_singleton()->get_autoload(first).is_singleton) {
 			const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(first);
 			String script_path;
@@ -750,15 +757,18 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				return bad_type;
 			}
 			result = ref->get_parser()->head->get_datatype();
+			result.is_nullable = is_nullable;
 		} else if (ClassDB::has_enum(parser->current_class->base_type.native_type, first)) {
 			// Native enum in current class.
 			result = make_native_enum_type(first, parser->current_class->base_type.native_type);
+			result.is_nullable = is_nullable;
 		} else if (CoreConstants::is_global_enum(first)) {
 			if (p_type->type_chain.size() > 1) {
 				push_error(R"(Enums cannot contain nested types.)", p_type->type_chain[1]);
 				return bad_type;
 			}
 			result = make_global_enum_type(first, StringName());
+			result.is_nullable = is_nullable;
 		} else {
 			// Classes in current scope.
 			List<GDScriptParser::ClassNode *> script_classes;
@@ -814,6 +824,9 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				}
 			}
 		}
+
+		// Unless we return a bad type, we should have a valid result to nullify (if needed)
+		result.is_nullable = is_nullable;
 	}
 
 	if (!result.is_set()) {
@@ -834,6 +847,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 					push_error(vformat(R"(Member "%s" under base "%s" is not a valid type.)", p_type->type_chain[i]->name, base.to_string()), p_type->type_chain[1]);
 					return bad_type;
 				}
+				result.is_nullable = is_nullable;
 			}
 		} else if (result.kind == GDScriptParser::DataType::NATIVE) {
 			// Only enums allowed for native.
@@ -853,6 +867,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 			return bad_type;
 		}
 	}
+	result.is_nullable = is_nullable;
 
 	if (!p_type->container_types.is_empty()) {
 		if (result.builtin_type == Variant::ARRAY) {
@@ -1937,6 +1952,11 @@ void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assi
 			}
 		}
 
+		if (!p_assignable->infer_datatype && is_effectively_non_nullable(p_assignable->initializer)) {
+			// This is a narrow nullable being assigned to a temporary variable, let's drop the "is_nullable" qualifier from the current variable
+			initializer_type.is_nullable = false;
+		}
+
 		if (!has_specified_type) {
 			type = initializer_type;
 
@@ -2005,6 +2025,12 @@ void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assi
 	type.is_constant = is_constant;
 	type.is_read_only = false;
 	p_assignable->set_datatype(type);
+	// Makes it easier to figure out whether this assignment is nullable or not
+	p_assignable->identifier->datatype.is_nullable = p_assignable->get_datatype().is_nullable;
+
+	if (!p_assignable->infer_datatype && has_specified_type) {
+		assignable_nullity_guard(p_assignable->identifier, p_assignable->initializer, p_assignable);
+	}
 }
 
 void GDScriptAnalyzer::resolve_variable(GDScriptParser::VariableNode *p_variable, bool p_is_local) {
@@ -2043,12 +2069,31 @@ void GDScriptAnalyzer::resolve_parameter(GDScriptParser::ParameterNode *p_parame
 void GDScriptAnalyzer::resolve_if(GDScriptParser::IfNode *p_if) {
 	reduce_expression(p_if->condition);
 
+	Vector<GDScriptParser::IdentifierNode *> identifiers = deduce_nullable_narrowing(p_if->condition);
+	push_narrowed_nullables(identifiers);
 	resolve_suite(p_if->true_block);
 	p_if->set_datatype(p_if->true_block->get_datatype());
+	pop_narrowed_nullables(identifiers);
 
 	if (p_if->false_block != nullptr) {
+		// Look for other if-nodes
+		GDScriptParser::IfNode *next_if_node = nullptr;
+		for (GDScriptParser::Node *node : p_if->false_block->statements) {
+			if (node->type == GDScriptParser::Node::IF) {
+				next_if_node = static_cast<GDScriptParser::IfNode *>(node);
+				break;
+			}
+		}
+		// If we don't have a next if node it means this false block is an else
+		if (!next_if_node) {
+			identifiers = deduce_nullable_narrowing(p_if->condition, true);
+			push_narrowed_nullables(identifiers);
+		}
 		resolve_suite(p_if->false_block);
 		decide_suite_type(p_if, p_if->false_block);
+		if (!next_if_node) {
+			pop_narrowed_nullables(identifiers);
+		}
 	}
 }
 
@@ -2222,6 +2267,7 @@ void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) {
 		}
 	}
 
+	for_nullity_guard(p_for);
 	resolve_suite(p_for->loop);
 	p_for->set_datatype(p_for->loop->get_datatype());
 #ifdef DEBUG_ENABLED
@@ -2231,11 +2277,53 @@ void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) {
 #endif
 }
 
+bool GDScriptAnalyzer::for_nullity_guard(GDScriptParser::ForNode *p_for) {
+	if (!p_for->list || p_for->list->is_constant) {
+		// Nothing to do here
+		return true;
+	}
+
+	switch (p_for->list->type) {
+		case GDScriptParser::Node::IDENTIFIER: {
+			GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(p_for->list);
+			if (is_effectively_non_nullable(identifier)) {
+				return true;
+			}
+
+			push_nullable_error(R"*(Potentially unsafe for nullable "%s" to be used in a for-loop.)*", { identifier }, identifier, identifier->name);
+			return false;
+		} break;
+		case GDScriptParser::Node::SUBSCRIPT: {
+			GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_for->list);
+			if (is_effectively_nullable(subscript)) {
+				push_nullable_error(R"*(Potentially unsafe for the nullable expression "%s" to be used in a for-loop.)*", {}, subscript, print_expression(subscript));
+				return false;
+			}
+
+			return true;
+		} break;
+		case GDScriptParser::Node::CALL: {
+			GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(p_for->list);
+			if (call->get_datatype().is_nullable) {
+				push_nullable_error(R"*(Potentially unsafe for the nullable return of "%s()" to be used in a for-loop.)*", {}, call, call->function_name);
+				return false;
+			}
+			return true;
+		} break;
+		default: {
+			return true;
+		}
+	}
+}
+
 void GDScriptAnalyzer::resolve_while(GDScriptParser::WhileNode *p_while) {
 	resolve_node(p_while->condition, false);
 
+	Vector<GDScriptParser::IdentifierNode *> identifiers = deduce_nullable_narrowing(p_while->condition);
+	push_narrowed_nullables(identifiers);
 	resolve_suite(p_while->loop);
 	p_while->set_datatype(p_while->loop->get_datatype());
+	pop_narrowed_nullables(identifiers);
 }
 
 void GDScriptAnalyzer::resolve_assert(GDScriptParser::AssertNode *p_assert) {
@@ -2263,14 +2351,17 @@ void GDScriptAnalyzer::resolve_assert(GDScriptParser::AssertNode *p_assert) {
 void GDScriptAnalyzer::resolve_match(GDScriptParser::MatchNode *p_match) {
 	reduce_expression(p_match->test);
 
+	Vector<GDScriptParser::IdentifierNode *> identifiers = deduce_nullable_narrowing(p_match->test);
+	push_narrowed_nullables(identifiers);
 	for (int i = 0; i < p_match->branches.size(); i++) {
-		resolve_match_branch(p_match->branches[i], p_match->test);
+		resolve_match_branch(p_match->branches[i], p_match->test, identifiers);
 
 		decide_suite_type(p_match, p_match->branches[i]);
 	}
+	pop_narrowed_nullables(identifiers);
 }
 
-void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test) {
+void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test, Vector<GDScriptParser::IdentifierNode *> p_nullable_identifier) {
 	// Apply annotations.
 	for (GDScriptParser::AnnotationNode *&E : p_match_branch->annotations) {
 		resolve_annotation(E);
@@ -2278,7 +2369,11 @@ void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_m
 	}
 
 	for (int i = 0; i < p_match_branch->patterns.size(); i++) {
-		resolve_match_pattern(p_match_branch->patterns[i], p_match_test);
+		bool is_nullable = false;
+		resolve_match_pattern(p_match_branch->patterns[i], p_match_test, &is_nullable);
+		if (is_nullable) {
+			pop_narrowed_nullables(p_nullable_identifier);
+		}
 	}
 
 	if (p_match_branch->guard_body) {
@@ -2288,13 +2383,20 @@ void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_m
 	resolve_suite(p_match_branch->block);
 
 	decide_suite_type(p_match_branch, p_match_branch->block);
+
+	// Re-push our nullable identifiers so the next branch has access to it
+	push_narrowed_nullables(p_nullable_identifier);
 }
 
-void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test) {
+void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test, bool *p_is_nullable) {
 	if (p_match_pattern == nullptr) {
 		return;
 	}
-
+#define SET_NULLABLE(value)         \
+	if (p_is_nullable != nullptr) { \
+		*p_is_nullable = value;     \
+	}
+	SET_NULLABLE(false);
 	GDScriptParser::DataType result;
 
 	switch (p_match_pattern->pattern_type) {
@@ -2302,6 +2404,7 @@ void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_matc
 			if (p_match_pattern->literal) {
 				reduce_literal(p_match_pattern->literal);
 				result = p_match_pattern->literal->get_datatype();
+				SET_NULLABLE(p_match_pattern->literal->reduced_value.get_type() == Variant::NIL)
 			}
 			break;
 		case GDScriptParser::PatternNode::PT_EXPRESSION:
@@ -2321,6 +2424,12 @@ void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_matc
 					if (!expr || expr->type != GDScriptParser::Node::IDENTIFIER) {
 						push_error(R"(Expression in match pattern must be a constant expression, an identifier, or an attribute access ("A.B").)", expr);
 					}
+
+					if (is_effectively_nullable(p_match_pattern->expression)) {
+						SET_NULLABLE(true);
+					}
+				} else {
+					SET_NULLABLE(expr->reduced_value.get_type() == Variant::NIL);
 				}
 			}
 			break;
@@ -2331,6 +2440,7 @@ void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_matc
 				result.kind = GDScriptParser::DataType::VARIANT;
 			}
 			p_match_pattern->bind->set_datatype(result);
+			SET_NULLABLE(true);
 #ifdef DEBUG_ENABLED
 			is_shadowing(p_match_pattern->bind, "pattern bind", true);
 			if (p_match_pattern->bind->usages == 0 && !String(p_match_pattern->bind->name).begins_with("_")) {
@@ -2364,10 +2474,13 @@ void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_matc
 		case GDScriptParser::PatternNode::PT_WILDCARD:
 		case GDScriptParser::PatternNode::PT_REST:
 			result.kind = GDScriptParser::DataType::VARIANT;
+			SET_NULLABLE(true);
 			break;
 	}
 
 	p_match_pattern->set_datatype(result);
+
+#undef SET_NULLABLE
 }
 
 void GDScriptAnalyzer::resolve_return(GDScriptParser::ReturnNode *p_return) {
@@ -2441,6 +2554,16 @@ void GDScriptAnalyzer::resolve_return(GDScriptParser::ReturnNode *p_return) {
 	}
 
 	p_return->set_datatype(result);
+	return_nullity_guard(p_return, expected_type);
+}
+
+bool GDScriptAnalyzer::return_nullity_guard(GDScriptParser::ReturnNode *p_return, GDScriptParser::DataType p_expected_type) {
+	GDScriptParser::DataType result = p_return->get_datatype();
+	if ((result.is_nullable && is_effectively_nullable(p_return->return_value) && !p_expected_type.is_nullable) || (is_deeply_nullable(result, true) && !is_deeply_nullable(p_expected_type, true))) {
+		push_nullable_error(R"(Cannot return nullable value of type "%s" because the function return type is "%s".)", {}, p_return, result.to_string(), p_expected_type.to_string());
+		return false;
+	}
+	return true;
 }
 
 void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expression, bool p_is_root) {
@@ -2606,11 +2729,14 @@ void GDScriptAnalyzer::update_const_expression_builtin_type(GDScriptParser::Expr
 
 	Variant converted_to;
 	const Variant *converted_from = &p_expression->reduced_value;
-	Callable::CallError call_error;
-	Variant::construct(p_type.builtin_type, converted_to, &converted_from, 1, call_error);
-	if (call_error.error) {
-		push_error(vformat(R"(Failed to convert a value of type "%s" to "%s".)", value_type.to_string(), p_type.to_string()), p_expression);
-		return;
+	// If our source is null and our target is nullable, no conversion is needed
+	if (!p_type.is_nullable || converted_from->get_type() != Variant::NIL) {
+		Callable::CallError call_error;
+		Variant::construct(p_type.builtin_type, converted_to, &converted_from, 1, call_error);
+		if (call_error.error) {
+			push_error(vformat(R"(Failed to convert a value of type "%s" to "%s".)", value_type.to_string(), p_type.to_string()), p_expression);
+			return;
+		}
 	}
 
 #ifdef DEBUG_ENABLED
@@ -2674,6 +2800,15 @@ void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assig
 		return;
 	}
 
+	// Nullable access ("?." syntax) is not allowed for assignments
+	if (p_assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT) {
+		GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee);
+		if (subscript->is_nullable) {
+			push_error(vformat(R"*(The left-hand side of an assignment expression may not contain a nullable access operator ("?.").)*"), p_assignment);
+			return;
+		}
+	}
+
 	GDScriptParser::DataType assignee_type = p_assignment->assignee->get_datatype();
 
 	if (assignee_type.is_constant) {
@@ -2802,6 +2937,7 @@ void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assig
 		downgrade_node_type_source(p_assignment->assigned_value);
 	}
 
+	assignment_nullity_guard(p_assignment);
 #ifdef DEBUG_ENABLED
 	if (assignee_type.is_hard_type() && assignee_type.builtin_type == Variant::INT && assigned_value_type.builtin_type == Variant::FLOAT) {
 		parser->push_warning(p_assignment->assigned_value, GDScriptWarning::NARROWING_CONVERSION);
@@ -2817,6 +2953,119 @@ void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assig
 #endif
 }
 
+bool GDScriptAnalyzer::assignment_nullity_guard(GDScriptParser::AssignmentNode *p_assignment) {
+	if (!p_assignment) {
+		return true;
+	}
+
+	// Type-check the assignment for nullables
+	assignable_nullity_guard(p_assignment->assignee, p_assignment->assigned_value, p_assignment);
+
+	// Treat the assignment as a binary operation for the sake of nullity-safety-check, except if the assignment is a "plain" one
+	GDScriptParser::BinaryOpNode *binary_op = parser->alloc_node<GDScriptParser::BinaryOpNode>();
+	switch (p_assignment->operation) {
+		case GDScriptParser::AssignmentNode::OP_NONE: {
+			return true; // Already taken care of above
+		} break;
+		case GDScriptParser::AssignmentNode::OP_ADDITION: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_ADDITION;
+			binary_op->variant_op = Variant::OP_ADD;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_SUBTRACTION: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_SUBTRACTION;
+			binary_op->variant_op = Variant::OP_SUBTRACT;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_MULTIPLICATION: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_MULTIPLICATION;
+			binary_op->variant_op = Variant::OP_MULTIPLY;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_DIVISION: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_DIVISION;
+			binary_op->variant_op = Variant::OP_DIVIDE;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_MODULO: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_MODULO;
+			binary_op->variant_op = Variant::OP_MODULE;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_POWER: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_POWER;
+			binary_op->variant_op = Variant::OP_POWER;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_BIT_SHIFT_LEFT: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_BIT_LEFT_SHIFT;
+			binary_op->variant_op = Variant::OP_SHIFT_LEFT;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_BIT_SHIFT_RIGHT: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_BIT_RIGHT_SHIFT;
+			binary_op->variant_op = Variant::OP_SHIFT_RIGHT;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_BIT_AND: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_BIT_AND;
+			binary_op->variant_op = Variant::OP_BIT_AND;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_BIT_OR: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_BIT_OR;
+			binary_op->variant_op = Variant::OP_BIT_OR;
+		} break;
+		case GDScriptParser::AssignmentNode::OP_BIT_XOR: {
+			binary_op->operation = GDScriptParser::BinaryOpNode::OP_BIT_XOR;
+			binary_op->variant_op = Variant::OP_BIT_XOR;
+		} break;
+	}
+	binary_op->start_line = p_assignment->start_line;
+	binary_op->end_line = p_assignment->end_line;
+	binary_op->start_column = p_assignment->start_column;
+	binary_op->end_column = p_assignment->end_column;
+	binary_op->leftmost_column = p_assignment->leftmost_column;
+	binary_op->rightmost_column = p_assignment->rightmost_column;
+	binary_op->left_operand = p_assignment->assignee;
+	binary_op->right_operand = p_assignment->assigned_value;
+	reduce_binary_op(binary_op);
+	return false;
+}
+
+bool GDScriptAnalyzer::assignable_nullity_guard(GDScriptParser::ExpressionNode *p_assignee, GDScriptParser::ExpressionNode *p_assigned_value, GDScriptParser::Node *p_origin) {
+	if (!p_assignee || !p_assigned_value || !p_origin) {
+		return true;
+	}
+
+	if (p_assignee->type != GDScriptParser::Node::IDENTIFIER) {
+		return true;
+	}
+
+	GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(p_assignee);
+	// Assigning null or variant to a narrowed identifier should broaden it for safety
+	if (identifier->get_datatype().is_nullable && is_effectively_non_nullable(identifier)) {
+		GDScriptParser::DataType data_type = p_assigned_value->get_datatype();
+		if (is_potentially_null_value(p_assigned_value)) {
+			pop_narrowed_nullables({ identifier });
+		}
+	}
+
+	// Forbid nullables being assigned to non-nullables, unless the non-nullable is an object
+	if (identifier->get_datatype().builtin_type != Variant::OBJECT && !identifier->get_datatype().is_nullable && p_assigned_value->get_datatype().is_nullable && is_effectively_nullable(p_assigned_value)) {
+		// Single out calls to have a more accurate error message
+		if (p_assigned_value->type == GDScriptParser::Node::CALL) {
+			push_nullable_error(R"*(Potentially unsafe to assign the nullable return of "%s()" to non-nullable "%s".)*", {}, p_origin, static_cast<GDScriptParser::CallNode *>(p_assigned_value)->function_name, identifier->name);
+		} else {
+			push_nullable_error(R"*(Potentially unsafe to assign nullable "%s" to non-nullable "%s".)*", {}, p_origin, print_expression(p_assigned_value), identifier->name);
+		}
+		return false;
+	}
+
+	// Special case for container types, forbid assigning a nullable typed array to a non-nullable one (Like assigning an "Array[int?]" to an "Array[int]")
+	if (p_origin->get_datatype().has_container_element_type(0) && p_assigned_value->get_datatype().has_container_element_type(0)) {
+		GDScriptParser::DataType identifier_data_type = p_origin->get_datatype().get_container_element_type(0);
+		GDScriptParser::DataType assigned_data_type = p_assigned_value->get_datatype().get_container_element_type(0);
+		if (identifier_data_type.builtin_type != Variant::OBJECT && !identifier_data_type.is_nullable && assigned_data_type.is_nullable) {
+			push_nullable_error(R"*(Value of type "%s" cannot be assigned to a variable of type "%s".)*", {}, p_origin, p_assigned_value->get_datatype().to_string(), p_origin->get_datatype().to_string());
+			return false;
+		}
+	}
+
+	return true;
+}
+
 void GDScriptAnalyzer::reduce_await(GDScriptParser::AwaitNode *p_await) {
 	if (p_await->to_await == nullptr) {
 		GDScriptParser::DataType await_type;
@@ -2853,6 +3102,13 @@ void GDScriptAnalyzer::reduce_await(GDScriptParser::AwaitNode *p_await) {
 
 void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op) {
 	reduce_expression(p_binary_op->left_operand);
+
+	Vector<GDScriptParser::IdentifierNode *> narrowed_identifiers;
+	if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_LOGIC_AND) {
+		// Special handling of the "and" operator that allows us to have "short-circuit" for nullable checks
+		narrowed_identifiers = deduce_nullable_narrowing(p_binary_op->left_operand, false);
+		push_narrowed_nullables(narrowed_identifiers);
+	}
 	reduce_expression(p_binary_op->right_operand);
 
 	GDScriptParser::DataType left_type;
@@ -2865,9 +3121,16 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 	}
 
 	if (!left_type.is_set() || !right_type.is_set()) {
+		pop_narrowed_nullables(narrowed_identifiers);
 		return;
 	}
 
+	// Coalescing is handled differently than the other operators
+	if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_COALESCE) {
+		pop_narrowed_nullables(narrowed_identifiers);
+		return reduce_coalesce_op(p_binary_op);
+	}
+
 #ifdef DEBUG_ENABLED
 	if (p_binary_op->variant_op == Variant::OP_DIVIDE && left_type.builtin_type == Variant::INT && right_type.builtin_type == Variant::INT) {
 		parser->push_warning(p_binary_op, GDScriptWarning::INTEGER_DIVISION);
@@ -2895,6 +3158,7 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 		}
 		p_binary_op->set_datatype(type_from_variant(p_binary_op->reduced_value, p_binary_op));
 
+		pop_narrowed_nullables(narrowed_identifiers);
 		return;
 	}
 
@@ -2913,6 +3177,7 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 		result.builtin_type = Variant::STRING;
 	} else if (left_type.is_variant() || right_type.is_variant()) {
 		// Cannot infer type because one operand can be anything.
+
 		result.kind = GDScriptParser::DataType::VARIANT;
 		mark_node_unsafe(p_binary_op);
 	} else if (p_binary_op->variant_op < Variant::OP_MAX) {
@@ -2928,6 +3193,61 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 	}
 
 	p_binary_op->set_datatype(result);
+	binary_op_nullity_guard(p_binary_op);
+	pop_narrowed_nullables(narrowed_identifiers);
+}
+
+void GDScriptAnalyzer::reduce_coalesce_op(GDScriptParser::BinaryOpNode *p_coalesce_op) {
+	GDScriptParser::DataType left_type = p_coalesce_op->left_operand->get_datatype();
+	GDScriptParser::DataType right_type = p_coalesce_op->right_operand->get_datatype();
+
+	if (left_type.is_variant() || right_type.is_variant()) {
+		return;
+	}
+
+	GDScriptParser::DataType non_nullable_left_type = left_type;
+	non_nullable_left_type.is_nullable = false;
+	if (!is_type_compatible(non_nullable_left_type, right_type, false, p_coalesce_op)) {
+		push_error(vformat(R"(Invalid operands "%s" and "%s" for "??" operator.)", left_type.to_string(), right_type.to_string()), p_coalesce_op);
+	}
+
+	p_coalesce_op->set_datatype(left_type);
+	p_coalesce_op->datatype.is_nullable = (left_type.is_nullable || left_type.builtin_type == Variant::OBJECT) && right_type.is_nullable;
+}
+
+bool GDScriptAnalyzer::binary_op_nullity_guard(GDScriptParser::BinaryOpNode *p_binary_op) {
+	GDScriptParser::ExpressionNode *left_operand = p_binary_op->left_operand, *right_operand = p_binary_op->right_operand;
+	GDScriptParser::DataType left_type = left_operand->get_datatype(), right_type = right_operand->get_datatype();
+
+	if (!left_type.is_nullable && !right_type.is_nullable) {
+		return true;
+	}
+	if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_COMP_EQUAL || p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_COMP_NOT_EQUAL || p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_LOGIC_AND || p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_LOGIC_OR || p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_COALESCE) {
+		// We don't need to check those operators for which null is a valid operand
+		return true;
+	}
+	if (is_effectively_non_nullable(p_binary_op->left_operand) && is_effectively_non_nullable(p_binary_op->right_operand)) {
+		return true;
+	}
+
+	if (left_type.is_nullable && right_type.is_nullable) {
+		push_nullable_error(
+				R"*(Both operands for the "%s" operator are nullable and as such, might be unsafe to be operated together.)*",
+				{ p_binary_op->left_operand, p_binary_op->right_operand },
+				p_binary_op,
+				Variant::get_operator_name(p_binary_op->variant_op));
+	} else {
+		String nullable_type = (left_type.is_nullable ? left_type : right_type).to_string();
+		String operand_side = left_type.is_nullable ? "left-side" : "right-side";
+		GDScriptParser::ExpressionNode *nullable_operand = left_type.is_nullable ? p_binary_op->left_operand : p_binary_op->right_operand;
+		push_nullable_error(
+				R"*(Potentially unsafe for nullable %s operand, of type "%s", to be used with the "%s" operator.)*",
+				{ nullable_operand },
+				p_binary_op,
+				operand_side, nullable_type, Variant::get_operator_name(p_binary_op->variant_op));
+	}
+
+	return false;
 }
 
 #ifdef SUGGEST_GODOT4_RENAMES
@@ -3349,6 +3669,10 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a
 			base_type = subscript->base->get_datatype();
 			is_self = subscript->base->type == GDScriptParser::Node::SELF;
 		}
+
+		if (!is_self) {
+			call_nullity_guard(p_call);
+		}
 	} else {
 		// Invalid call. Error already sent in parser.
 		// TODO: Could check if Callable here too.
@@ -3497,6 +3821,104 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a
 	p_call->set_datatype(call_type);
 }
 
+bool GDScriptAnalyzer::call_nullity_guard(GDScriptParser::CallNode *p_call) {
+	if (p_call->callee->type != GDScriptParser::Node::SUBSCRIPT) {
+		// Nothing to do here
+		return true;
+	}
+
+	GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee);
+	if (subscript->is_nullable || !subscript->base->get_datatype().is_nullable) {
+		return true;
+	}
+
+#define IDENTIFIER_CLAUSE                                                    \
+	if (is_effectively_nullable(identifier)) {                               \
+		push_nullable_error(                                                 \
+				R"*(Potentially unsafe for nullable "%s" to call "%s()".)*", \
+				{ identifier },                                              \
+				identifier,                                                  \
+				identifier->name, p_call->function_name);                    \
+		return false;                                                        \
+	}
+
+	switch (subscript->base->type) {
+		case GDScriptParser::Node::IDENTIFIER: {
+			GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(subscript->base);
+			// The current call is being called off this identifier
+			IDENTIFIER_CLAUSE
+		} break;
+		case GDScriptParser::Node::CALL: {
+			GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(subscript->base);
+			// The current call is being called off this inner call
+			if (call->get_datatype().is_nullable) {
+				push_nullable_error(
+						R"*(Potentially unsafe for the nullable return of "%s" to call "%s()".)*",
+						{},
+						call,
+						call->function_name, p_call->function_name);
+				return false;
+			}
+		} break;
+		case GDScriptParser::Node::SUBSCRIPT: {
+			GDScriptParser::SubscriptNode *inner_subscript = static_cast<GDScriptParser::SubscriptNode *>(subscript->base);
+			if (inner_subscript->is_nullable) {
+				push_nullable_error(
+						R"*(Potentially unsafe for nullable "%s" to call "%s()".)*",
+						{ inner_subscript->is_attribute ? inner_subscript->attribute : inner_subscript->index },
+						inner_subscript,
+						print_expression(inner_subscript), p_call->function_name);
+				return false;
+			}
+
+			if (inner_subscript->is_attribute) {
+				GDScriptParser::IdentifierNode *identifier = inner_subscript->attribute;
+				// This identifier is being used a base to the current subscript
+				IDENTIFIER_CLAUSE
+			} else {
+				GDScriptParser::ExpressionNode *index = inner_subscript->index;
+				if (is_deeply_nullable(inner_subscript->get_datatype())) {
+					push_nullable_error(
+							R"*(Potentially unsafe for nullable "%s" to call "%s()".)*",
+							{},
+							index,
+							print_expression(inner_subscript), p_call->function_name);
+					return false;
+				} else if (!inner_subscript->base->get_datatype().is_nullable) {
+					return subscript_nullity_guard(inner_subscript);
+				}
+			}
+
+			return true;
+		} break;
+		case GDScriptParser::Node::CAST: {
+			GDScriptParser::CastNode *cast = static_cast<GDScriptParser::CastNode *>(subscript->base);
+			if (cast->get_datatype().is_nullable) {
+				push_nullable_error(
+						R"*(Potentially unsafe for the nullable cast expression "%s" to call "%s()".)*",
+						{},
+						cast,
+						print_expression(cast), p_call->function_name);
+				return false;
+			}
+		} break;
+		default: {
+			// Ideally we would like to support every case for specific messages, but this is better than nothing
+			if (subscript->base->get_datatype().is_nullable) {
+				push_nullable_error(
+						R"*(Potentially unsafe to call "%s()" on a nullable base.)*",
+						{},
+						subscript->base,
+						p_call->function_name);
+				return false;
+			}
+			return true; // Shouldn't happen
+		}
+	}
+	return true;
+#undef IDENTIFIER_CLAUSE
+}
+
 void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
 	reduce_expression(p_cast->operand);
 
@@ -4653,13 +5075,182 @@ void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscri
 		}
 	}
 
+	if (p_subscript->base->get_datatype().is_nullable) {
+		result_type.is_nullable = true;
+	}
+
 	p_subscript->set_datatype(result_type);
+
+	subscript_nullity_guard(p_subscript);
+}
+
+bool GDScriptAnalyzer::subscript_nullity_guard(GDScriptParser::SubscriptNode *p_subscript) {
+	if (!p_subscript->attribute || !p_subscript->index || p_subscript->is_nullable) {
+		return true;
+	}
+
+#define IDENTIFIER_CLAUSE                                                                                                                                                                               \
+	if (is_effectively_nullable(identifier)) {                                                                                                                                                          \
+		if (is_subscript_key) {                                                                                                                                                                         \
+			push_nullable_error(                                                                                                                                                                        \
+					R"*(Potentially unsafe to use nullable "%s" as an %s.)*",                                                                                                                           \
+					{ identifier },                                                                                                                                                                     \
+					identifier,                                                                                                                                                                         \
+					identifier->name, p_subscript->is_attribute ? "attribute" : "index");                                                                                                               \
+		} else {                                                                                                                                                                                        \
+			push_nullable_error(                                                                                                                                                                        \
+					R"*(Potentially unsafe to access nullable "%s" with %s "%s".)*",                                                                                                                    \
+					{ identifier },                                                                                                                                                                     \
+					identifier,                                                                                                                                                                         \
+					identifier->name, p_subscript->is_attribute ? "attribute" : "index", p_subscript->is_attribute ? String(p_subscript->attribute->name) : String(p_subscript->index->reduced_value)); \
+		}                                                                                                                                                                                               \
+                                                                                                                                                                                                        \
+		return false;                                                                                                                                                                                   \
+	}
+
+	GDScriptParser::ExpressionNode *expression = p_subscript->base;
+	bool is_subscript_key = false;
+
+	// Address the subscript key itself being nullable
+	if (!p_subscript->is_attribute && p_subscript->index && is_deeply_nullable(p_subscript->index->get_datatype())) {
+		expression = p_subscript->index;
+		is_subscript_key = true;
+	}
+
+	switch (expression->type) {
+		case GDScriptParser::Node::IDENTIFIER: {
+			GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(expression);
+			// This identifier is being used a base to the current subscript
+			IDENTIFIER_CLAUSE
+		} break;
+		case GDScriptParser::Node::CALL: {
+			GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(expression);
+			// The return of this call is being used as a base to the current subscript
+			if (call->get_datatype().is_nullable) {
+				if (is_subscript_key) {
+					push_nullable_error(
+							R"*(Potentially unsafe for the nullable return of "%s()" to be used as an index.)*",
+							{},
+							call,
+							call->function_name);
+				} else {
+					if (p_subscript->is_attribute) {
+						push_nullable_error(
+								R"*(Potentially unsafe for the nullable return of "%s()" to access "%s".)*",
+								{},
+								call,
+								call->function_name, String(p_subscript->attribute->name));
+					} else {
+						push_nullable_error(
+								R"*(Potentially unsafe for the nullable return of "%s()" to be indexed with "%s".)*",
+								{},
+								call,
+								call->function_name, String(p_subscript->index->reduced_value));
+					}
+				}
+				return false;
+			}
+		} break;
+		case GDScriptParser::Node::SUBSCRIPT: {
+			GDScriptParser::SubscriptNode *inner_subscript = static_cast<GDScriptParser::SubscriptNode *>(expression);
+			if (inner_subscript->is_nullable) {
+				if (is_subscript_key) {
+					push_nullable_error(
+							R"*(Potentially unsafe for the nullable expression "%s" to be used as an index.)*",
+							{ inner_subscript->is_attribute ? inner_subscript->attribute : inner_subscript->index },
+							inner_subscript,
+							print_expression(inner_subscript));
+				} else {
+					push_nullable_error(
+							R"*(Potentially unsafe to access nullable "%s" with %s "%s".)*",
+							{ inner_subscript->is_attribute ? inner_subscript->attribute : inner_subscript->index },
+							inner_subscript,
+							print_expression(inner_subscript), p_subscript->is_attribute ? "attribute" : "index", p_subscript->is_attribute ? String(p_subscript->attribute->name) : String(p_subscript->index->reduced_value));
+				}
+				return false;
+			}
+
+			if (inner_subscript->is_attribute) {
+				GDScriptParser::IdentifierNode *identifier = inner_subscript->attribute;
+				// This identifier is being used a base to the current subscript
+				IDENTIFIER_CLAUSE
+			} else {
+				GDScriptParser::ExpressionNode *index = inner_subscript->index;
+				if (is_deeply_nullable(inner_subscript->get_datatype())) {
+					if (is_subscript_key) {
+						push_nullable_error(
+								R"*(Potentially unsafe to use nullable "%s" as an index.)*",
+								{},
+								index,
+								print_expression(inner_subscript));
+					} else {
+						push_nullable_error(
+								R"*(Potentially unsafe to access nullable "%s" with %s "%s".)*",
+								{},
+								index,
+								print_expression(inner_subscript), p_subscript->is_attribute ? "attribute" : "index", p_subscript->is_attribute ? String(p_subscript->attribute->name) : String(p_subscript->index->reduced_value));
+					}
+					return false;
+				} else if (!inner_subscript->base->get_datatype().is_nullable) {
+					return subscript_nullity_guard(inner_subscript);
+				}
+			}
+
+			return true;
+		} break;
+		case GDScriptParser::Node::CAST: {
+			GDScriptParser::CastNode *cast = static_cast<GDScriptParser::CastNode *>(expression);
+			if (cast->get_datatype().is_nullable) {
+				if (is_subscript_key) {
+					push_nullable_error(
+							R"*(Potentially unsafe to use nullable cast expression "%s" as an %s.)*",
+							{},
+							cast,
+							print_expression(cast), p_subscript->is_attribute ? "attribute" : "index");
+				} else {
+					push_nullable_error(
+							R"*(Potentially unsafe to access nullable cast expression "%s" with %s "%s".)*",
+							{},
+							cast,
+							print_expression(cast), p_subscript->is_attribute ? "attribute" : "index", p_subscript->is_attribute ? String(p_subscript->attribute->name) : String(p_subscript->index->reduced_value));
+				}
+				return false;
+			}
+		} break;
+		default: {
+			// Ideally we would like to support every case for specific messages, but this is better than nothing
+			if (expression->get_datatype().is_nullable) {
+				push_nullable_error(
+						R"*(Potentially unsafe to access "%s" on a nullable base.)*",
+						{},
+						expression,
+						print_expression(expression));
+				return false;
+			}
+			return true;
+		}
+	}
+#undef IDENTIFIER_CLAUSE
+	return true;
 }
 
 void GDScriptAnalyzer::reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternary_op, bool p_is_root) {
 	reduce_expression(p_ternary_op->condition);
+
+	// Allow us to determine whether this ternary results in a nullable expression or not
+	bool is_result_nullable = false;
+
+	Vector<GDScriptParser::IdentifierNode *> identifiers = deduce_nullable_narrowing(p_ternary_op->condition);
+	push_narrowed_nullables(identifiers);
 	reduce_expression(p_ternary_op->true_expr, p_is_root);
+	is_result_nullable |= is_effectively_nullable(p_ternary_op->true_expr);
+	pop_narrowed_nullables(identifiers);
+
+	identifiers = deduce_nullable_narrowing(p_ternary_op->condition, true);
+	push_narrowed_nullables(identifiers);
 	reduce_expression(p_ternary_op->false_expr, p_is_root);
+	is_result_nullable |= is_effectively_nullable(p_ternary_op->false_expr);
+	pop_narrowed_nullables(identifiers);
 
 	GDScriptParser::DataType result;
 
@@ -4700,6 +5291,7 @@ void GDScriptAnalyzer::reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternar
 		}
 	}
 	result.type_source = true_type.is_hard_type() && false_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
+	result.is_nullable = is_result_nullable;
 
 	p_ternary_op->set_datatype(result);
 }
@@ -4771,15 +5363,359 @@ void GDScriptAnalyzer::reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op)
 	} else {
 		bool valid = false;
 		result = get_operation_type(p_unary_op->variant_op, operand_type, valid, p_unary_op);
-
 		if (!valid) {
 			push_error(vformat(R"(Invalid operand of type "%s" for unary operator "%s".)", operand_type.to_string(), Variant::get_operator_name(p_unary_op->variant_op)), p_unary_op);
 		}
+		unary_op_nullity_guard(p_unary_op);
 	}
 
 	p_unary_op->set_datatype(result);
 }
 
+bool GDScriptAnalyzer::unary_op_nullity_guard(GDScriptParser::UnaryOpNode *p_unary_op) {
+	if (!p_unary_op->operand->get_datatype().is_nullable || p_unary_op->operation == GDScriptParser::UnaryOpNode::OP_LOGIC_NOT) {
+		// Nullable verification only makes sense for unary operators if the operator is not the logic negation (!foo)
+		return true;
+	}
+
+	GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(p_unary_op->operand);
+	push_nullable_error(
+			R"*(Potentially unsafe for nullable "%s" to be used with the "%s" unary operator.)*",
+			{ p_unary_op->operand },
+			identifier,
+			p_unary_op->operand->type == GDScriptParser::Node::IDENTIFIER ? String(identifier->name) : p_unary_op->operand->get_datatype().to_string(),
+			Variant::get_operator_name(p_unary_op->variant_op));
+	return false;
+}
+
+Vector<GDScriptParser::IdentifierNode *> GDScriptAnalyzer::deduce_nullable_narrowing(GDScriptParser::ExpressionNode *p_node, bool p_should_be_false) {
+	if (p_node == nullptr) {
+		return {};
+	}
+
+	switch (p_node->type) {
+		case GDScriptParser::Node::BINARY_OPERATOR: {
+			// This deduces that "!=" and "==" can be used to narrow nullables.
+			GDScriptParser::BinaryOpNode *binary_op = static_cast<GDScriptParser::BinaryOpNode *>(p_node);
+			GDScriptParser::ExpressionNode *left = binary_op->left_operand;
+			GDScriptParser::ExpressionNode *right = binary_op->right_operand;
+
+			if (!left || !right) {
+				break;
+			}
+			switch (binary_op->variant_op) {
+				case Variant::OP_NOT_EQUAL:
+				case Variant::OP_EQUAL: {
+					if ((left->type != GDScriptParser::Node::LITERAL && left->type != GDScriptParser::Node::IDENTIFIER) && (right->type != GDScriptParser::Node::LITERAL && right->type != GDScriptParser::Node::IDENTIFIER)) {
+						// At least one of the operands must be a literal or an identifier
+						break;
+					}
+					if (left->get_datatype().is_nullable && right->get_datatype().is_nullable) {
+						// If both operands are nullable, we can't narrow them
+						break;
+					}
+
+					return find_nullable_identifier(left, right, (p_should_be_false ^ (binary_op->variant_op == Variant::OP_EQUAL)));
+				} break;
+				case Variant::OP_AND: {
+					// For the AND operator we can try deducing each side and then combining the resulting identifiers.
+					// That way we can support situations like: "if foo and bar:", where both foo and bar will be narrowed
+					Vector<GDScriptParser::IdentifierNode *> left_identifiers = deduce_nullable_narrowing(left, p_should_be_false);
+					Vector<GDScriptParser::IdentifierNode *> right_identifiers = deduce_nullable_narrowing(right, p_should_be_false);
+					// This might end up repeating identifiers, but given they will ultimately be stored in a HashSet it should be fine
+					left_identifiers.append_array(right_identifiers);
+					return left_identifiers;
+				} break;
+				default: {
+					return {}; // Not supported
+				}
+			}
+
+		} break;
+		case GDScriptParser::Node::IDENTIFIER: {
+			// This deduces that any sole identifier must be narrowed.
+			if (!p_should_be_false) {
+				return { static_cast<GDScriptParser::IdentifierNode *>(p_node) };
+			}
+		} break;
+		case GDScriptParser::Node::UNARY_OPERATOR: {
+			// This deduces that, except for the "!" operator (logic not), unary operators will always narrow nullables.
+			GDScriptParser::UnaryOpNode *unary_op = static_cast<GDScriptParser::UnaryOpNode *>(p_node);
+
+			if (!unary_op->operand) {
+				break;
+			}
+
+			if (!unary_op->operand->get_datatype().is_nullable) {
+				break;
+			}
+
+			if (unary_op->operation != GDScriptParser::UnaryOpNode::OP_LOGIC_NOT) {
+				break;
+			}
+
+			if (p_should_be_false) {
+				return { static_cast<GDScriptParser::IdentifierNode *>(unary_op->operand) };
+			}
+		} break;
+		case GDScriptParser::Node::CALL: {
+			// This deduces that certain "special" functions implicitly narrows one of its arguments
+			// Currently this applies to:
+			//   - if is_instance_valid(foo) -> foo will be narrowed
+			//   - if is_same(foo, bar) -> foo will be narrowed, if bar is not null
+			//   - is_instance_of(foo, Array) -> foo will be narrowed, if the type isn't TYPE_NIL
+			GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(p_node);
+			if (call->function_name == "is_instance_valid") {
+				if (call->arguments.size() != 1) {
+					break;
+				}
+
+				GDScriptParser::ExpressionNode *might_be_identifier = call->arguments.get(0);
+				if (might_be_identifier->type != GDScriptParser::Node::IDENTIFIER) {
+					break;
+				}
+				GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(might_be_identifier);
+				if (!identifier->get_datatype().is_nullable) {
+					break;
+				}
+
+				if (!p_should_be_false) {
+					return { identifier };
+				}
+			} else if (call->function_name == "is_same" || call->function_name == "is_instance_of") {
+				if (call->arguments.size() != 2) {
+					break;
+				}
+
+				GDScriptParser::ExpressionNode *first = call->arguments.get(0);
+				GDScriptParser::ExpressionNode *second = call->arguments.get(1);
+				if (call->function_name == "is_instance_of" && first->type == GDScriptParser::Node::IDENTIFIER && second->type == GDScriptParser::Node::IDENTIFIER) {
+					GDScriptParser::IdentifierNode *second_identifier = static_cast<GDScriptParser::IdentifierNode *>(second);
+					if (second_identifier->name == "TYPE_NIL") {
+						if (p_should_be_false) {
+							// If instance checking against null, no need to call 'find_nullable_identifier'
+							return { static_cast<GDScriptParser::IdentifierNode *>(first) };
+						}
+						break;
+					}
+				}
+				if ((first->type != GDScriptParser::Node::LITERAL && first->type != GDScriptParser::Node::IDENTIFIER) && (second->type != GDScriptParser::Node::LITERAL && second->type != GDScriptParser::Node::IDENTIFIER)) {
+					// At least one of the arguments must be a literal or an identifier
+					break;
+				}
+				if (first->get_datatype().is_nullable && second->get_datatype().is_nullable) {
+					// If both operands are nullable, we can't narrow them
+					break;
+				}
+				return find_nullable_identifier(first, second, !p_should_be_false);
+			}
+		} break;
+		case GDScriptParser::Node::TYPE_TEST: {
+			// This deduces expressions like "if foo is Array".
+			// Given that a type test can't be against null, foo will be narrowed.
+			GDScriptParser::TypeTestNode *type_test = static_cast<GDScriptParser::TypeTestNode *>(p_node);
+			if (!type_test->operand || type_test->operand->type != GDScriptParser::Node::IDENTIFIER) {
+				break;
+			}
+			if (!p_should_be_false) {
+				return { static_cast<GDScriptParser::IdentifierNode *>(type_test->operand) };
+			}
+		} break;
+		case GDScriptParser::Node::SUBSCRIPT: {
+			// This deduces that expressions like "if foo.bar.foobar" implicitly narrow foo, bar and foobar.
+			// Property nullable access rules apply elsewhere, during the safety checks.
+			GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_node);
+			Vector<GDScriptParser::IdentifierNode *> identifiers;
+			do {
+				if (subscript->is_attribute) {
+					identifiers.append(subscript->attribute);
+				}
+
+				switch (subscript->base->type) {
+					case GDScriptParser::Node::SUBSCRIPT: {
+						subscript = static_cast<GDScriptParser::SubscriptNode *>(subscript->base);
+					} break;
+					case GDScriptParser::Node::CALL: {
+						GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(subscript->base);
+						if (call->callee->type == GDScriptParser::Node::SUBSCRIPT) {
+							subscript = static_cast<GDScriptParser::SubscriptNode *>(call->callee);
+							break;
+						}
+
+						if (!p_should_be_false) {
+							return identifiers;
+						}
+						return {};
+					} break;
+					case GDScriptParser::Node::IDENTIFIER: {
+						identifiers.append(static_cast<GDScriptParser::IdentifierNode *>(subscript->base));
+					}
+						[[fallthrough]];
+					default: {
+						if (!p_should_be_false) {
+							return identifiers;
+						}
+						return {};
+					}
+				}
+			} while (true);
+		} break;
+		case GDScriptParser::Node::CAST: {
+			GDScriptParser::CastNode *cast = static_cast<GDScriptParser::CastNode *>(p_node);
+			return deduce_nullable_narrowing(cast->operand, p_should_be_false);
+		} break;
+		default: {
+		}
+	}
+
+	return {};
+}
+
+void GDScriptAnalyzer::push_narrowed_nullables(Vector<GDScriptParser::IdentifierNode *> p_identifiers) {
+	for (GDScriptParser::IdentifierNode *identifier : p_identifiers) {
+		if (identifier) {
+			narrowed_nullables_stack.insert(identifier);
+		}
+	}
+}
+
+void GDScriptAnalyzer::pop_narrowed_nullables(Vector<GDScriptParser::IdentifierNode *> p_identifiers) {
+	for (GDScriptParser::IdentifierNode *identifier : p_identifiers) {
+		if (identifier == nullptr) {
+			continue;
+		}
+
+		if (!narrowed_nullables_stack.has(identifier)) {
+			continue;
+		}
+
+		narrowed_nullables_stack.erase(identifier);
+	}
+}
+
+bool GDScriptAnalyzer::is_effectively_non_nullable(GDScriptParser::ExpressionNode *p_expression) const {
+	if (!p_expression || !p_expression->get_datatype().is_nullable) {
+		return true;
+	}
+
+	if (p_expression->type == GDScriptParser::Node::IDENTIFIER) {
+		return narrowed_nullables_stack.has(static_cast<GDScriptParser::IdentifierNode *>(p_expression));
+	} else if (p_expression->type == GDScriptParser::Node::SUBSCRIPT) {
+		GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_expression);
+
+		bool all_narrow = true;
+		do {
+			if (subscript->is_attribute) {
+				if (is_effectively_nullable(subscript->attribute)) {
+					all_narrow = false;
+					break;
+				}
+			}
+
+			if (subscript->base->type == GDScriptParser::Node::SUBSCRIPT) {
+				subscript = static_cast<GDScriptParser::SubscriptNode *>(subscript->base);
+			} else if (subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
+				if (is_effectively_nullable(static_cast<GDScriptParser::IdentifierNode *>(subscript->base))) {
+					all_narrow = false;
+				}
+				break;
+			} else {
+				break;
+			}
+		} while (all_narrow);
+
+		return all_narrow;
+	}
+
+	// Sane default
+	return !p_expression->get_datatype().is_nullable;
+}
+
+bool GDScriptAnalyzer::is_deeply_nullable(GDScriptParser::DataType p_data_type, bool p_strict) const {
+	return (!p_strict && p_data_type.is_nullable) || (p_data_type.has_container_element_type(0) && p_data_type.get_container_element_type(0).is_nullable);
+}
+
+bool GDScriptAnalyzer::is_potentially_null_value(GDScriptParser::ExpressionNode *p_expression) {
+	return is_effectively_nullable(p_expression) || p_expression->get_datatype().is_variant() || (p_expression->is_constant && p_expression->reduced_value.get_type() == Variant::NIL) || (p_expression->get_datatype().kind == GDScriptParser::DataType::BUILTIN && p_expression->get_datatype().builtin_type == Variant::NIL);
+}
+
+template <typename... Symbols>
+void GDScriptAnalyzer::push_nullable_error(const String &p_message, Vector<GDScriptParser::ExpressionNode *> p_expressions, const GDScriptParser::Node *p_origin, const Symbols &...p_symbols) {
+	bool are_all_expressions_nullable = true;
+	for (GDScriptParser::ExpressionNode *expression : p_expressions) {
+		if (expression->type == GDScriptParser::Node::IDENTIFIER && narrowed_nullables_stack.has(static_cast<GDScriptParser::IdentifierNode *>(expression))) {
+			are_all_expressions_nullable = false;
+			break;
+		}
+	}
+
+	if (!are_all_expressions_nullable) {
+		return;
+	}
+
+	push_error(vformat(p_message, p_symbols...), p_origin);
+}
+
+Vector<GDScriptParser::IdentifierNode *> GDScriptAnalyzer::find_nullable_identifier(GDScriptParser::ExpressionNode *left, GDScriptParser::ExpressionNode *right, bool should_be_false) {
+	GDScriptParser::ExpressionNode *nullable_to_narrow, *value_to_match_against;
+	if (left->type == GDScriptParser::Node::LITERAL || (left->is_constant && left->reduced_value.get_type() == Variant::NIL)) {
+		value_to_match_against = left;
+		nullable_to_narrow = right;
+	} else {
+		value_to_match_against = right;
+		nullable_to_narrow = left;
+	}
+	return deduce_nullable_narrowing(nullable_to_narrow, should_be_false ^ !is_potentially_null_value(value_to_match_against));
+};
+
+String GDScriptAnalyzer::print_expression(GDScriptParser::ExpressionNode *p_expression) {
+	// Slight optimization, if the expression is an identifier, just return its name
+	if (p_expression->type == GDScriptParser::Node::IDENTIFIER) {
+		return static_cast<GDScriptParser::IdentifierNode *>(p_expression)->name;
+	}
+
+	DEV_ASSERT(parser->tokenizer != nullptr);
+
+	const String source = parser->tokenizer->get_source();
+	const char32_t *_source = source.get_data();
+	String result;
+	int line = 0, column = 0;
+	for (int i = 0, start = -1; i < source.length(); i++) {
+		if (_source[i] == '\n') {
+			line += 1;
+			column = 0;
+		} else if (_source[i] == '\t') {
+#ifdef TOOLS_ENABLED
+			if (EditorSettings::get_singleton()) {
+				int tab_size = EditorSettings::get_singleton()->get_setting("text_editor/behavior/indent/size");
+				column += tab_size;
+			} else {
+				column += 4;
+			}
+#else
+			column += 4;
+#endif // TOOLS_ENABLED
+		} else {
+			column += 1;
+		}
+
+		if (start < 0) {
+			// Look for the start of our expression
+			if (line == (p_expression->start_line - 1) && column == (p_expression->start_column)) {
+				start = i;
+			}
+		} else {
+			// Look for the end of it
+			if (line == (p_expression->end_line - 1) && column == (p_expression->end_column - 1)) {
+				result = String(&_source[start], i - start + 1);
+				break;
+			}
+		}
+	}
+
+	return result.strip_edges();
+}
+
 Variant GDScriptAnalyzer::make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced) {
 	Variant value;
 
@@ -5301,6 +6237,7 @@ void GDScriptAnalyzer::validate_call_arg(const List<GDScriptParser::DataType> &p
 		}
 		GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
 
+		bool argument_is_nullable = par_type.builtin_type != Variant::OBJECT && arg_type.is_nullable && !par_type.is_nullable && !par_type.is_variant() && is_effectively_nullable(p_call->arguments[i]);
 		if (arg_type.is_variant() || !arg_type.is_hard_type()) {
 #ifdef DEBUG_ENABLED
 			// Argument can be anything, so this is unsafe (unless the parameter is a hard variant).
@@ -5309,7 +6246,15 @@ void GDScriptAnalyzer::validate_call_arg(const List<GDScriptParser::DataType> &p
 				parser->push_warning(p_call->arguments[i], GDScriptWarning::UNSAFE_CALL_ARGUMENT, itos(i + 1), "function", p_call->function_name, par_type.to_string(), arg_type.to_string_strict());
 			}
 #endif
-		} else if (par_type.is_hard_type() && !is_type_compatible(par_type, arg_type, true)) {
+		} else if ((par_type.is_hard_type() && !is_type_compatible(par_type, arg_type, true)) || argument_is_nullable) {
+			if (argument_is_nullable) {
+				// We need to ensure "!par_type.is_variant()" because Variants can also be null, even though they might not have the nullable qualifier (which is the case for internal APIs)
+				push_nullable_error(
+						R"*(Invalid argument for "%s()" function: argument %s must not be null, but "%s" is nullable.)*",
+						{ p_call->arguments[i] },
+						p_call->arguments[i],
+						p_call->function_name, String::num(i + 1), arg_type.to_string());
+			}
 			if (!is_type_compatible(arg_type, par_type)) {
 				push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*",
 								   p_call->function_name, i + 1, par_type.to_string(), arg_type.to_string()),
@@ -5491,6 +6436,11 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 		return true;
 	}
 
+	if (p_target.builtin_type != Variant::OBJECT && !p_target.is_nullable && p_source.is_nullable) {
+		// If the target is not nullable, but the source type is, they're incompatible
+		return false;
+	}
+
 	if (p_target.kind == GDScriptParser::DataType::BUILTIN) {
 		bool valid = p_source.kind == GDScriptParser::DataType::BUILTIN && p_target.builtin_type == p_source.builtin_type;
 		if (!valid && p_allow_implicit_conversion) {
@@ -5506,6 +6456,10 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 				valid = p_target.get_container_element_type(0) == p_source.get_container_element_type(0);
 			}
 		}
+		if (!valid && p_target.is_nullable && p_source.builtin_type == Variant::NIL) {
+			// If the target is nullable and the source type is null, we're good...
+			valid = true;
+		}
 		return valid;
 	}
 
diff --git a/modules/gdscript/gdscript_analyzer.h b/modules/gdscript/gdscript_analyzer.h
index 922000df520e..8faf9c5ebbd6 100644
--- a/modules/gdscript/gdscript_analyzer.h
+++ b/modules/gdscript/gdscript_analyzer.h
@@ -39,7 +39,33 @@
 #include "core/templates/hash_set.h"
 
 class GDScriptAnalyzer {
+	// Allows us to include the identifier's scope for the nullable narrowing computation
+	struct NullableNarrowingIdentifier {
+		StringName identifier;
+		StringName source_function;
+
+		bool operator==(const NullableNarrowingIdentifier &p_identifier) const {
+			return this->identifier == p_identifier.identifier && this->source_function == p_identifier.source_function;
+		}
+
+		NullableNarrowingIdentifier(GDScriptParser::IdentifierNode *p_identifier) {
+			identifier = p_identifier->name;
+			if (p_identifier->source_function && p_identifier->source_function->identifier) {
+				source_function = p_identifier->source_function->identifier->name;
+			}
+		}
+	};
+
+	struct HashMapHasherNullableNarrowingIdentifier : HashMapHasherDefault {
+		static _FORCE_INLINE_ uint32_t hash(const NullableNarrowingIdentifier &p_identifier) {
+			uint32_t h = p_identifier.identifier.hash();
+			h = hash_murmur3_one_32(p_identifier.source_function.hash(), h);
+			return hash_fmix32(h);
+		}
+	};
+
 	GDScriptParser *parser = nullptr;
+	HashSet<NullableNarrowingIdentifier, HashMapHasherNullableNarrowingIdentifier> narrowed_nullables_stack;
 
 	const GDScriptParser::EnumNode *current_enum = nullptr;
 	GDScriptParser::LambdaNode *current_lambda = nullptr;
@@ -80,8 +106,8 @@ class GDScriptAnalyzer {
 	void resolve_while(GDScriptParser::WhileNode *p_while);
 	void resolve_assert(GDScriptParser::AssertNode *p_assert);
 	void resolve_match(GDScriptParser::MatchNode *p_match);
-	void resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test);
-	void resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test);
+	void resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test, Vector<GDScriptParser::IdentifierNode *> p_nullable_identifiers = {});
+	void resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test, bool *p_is_nullable = nullptr);
 	void resolve_return(GDScriptParser::ReturnNode *p_return);
 
 	// Reduction functions.
@@ -90,6 +116,7 @@ class GDScriptAnalyzer {
 	void reduce_assignment(GDScriptParser::AssignmentNode *p_assignment);
 	void reduce_await(GDScriptParser::AwaitNode *p_await);
 	void reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op);
+	void reduce_coalesce_op(GDScriptParser::BinaryOpNode *p_coalesce_op);
 	void reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await = false, bool p_is_root = false);
 	void reduce_cast(GDScriptParser::CastNode *p_cast);
 	void reduce_dictionary(GDScriptParser::DictionaryNode *p_dictionary);
@@ -132,6 +159,30 @@ class GDScriptAnalyzer {
 	void resolve_pending_lambda_bodies();
 	bool class_exists(const StringName &p_class) const;
 	void reduce_identifier_from_base_set_class(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType p_identifier_datatype);
+	String print_expression(GDScriptParser::ExpressionNode *p_expression);
+
+	// Nullity guards.
+	bool binary_op_nullity_guard(GDScriptParser::BinaryOpNode *p_binary_op);
+	bool subscript_nullity_guard(GDScriptParser::SubscriptNode *p_subscript);
+	bool call_nullity_guard(GDScriptParser::CallNode *p_call);
+	bool assignable_nullity_guard(GDScriptParser::ExpressionNode *p_assignee, GDScriptParser::ExpressionNode *p_assigned_value, GDScriptParser::Node *p_origin);
+	bool assignment_nullity_guard(GDScriptParser::AssignmentNode *p_assignment);
+	bool unary_op_nullity_guard(GDScriptParser::UnaryOpNode *p_unary_op);
+	bool for_nullity_guard(GDScriptParser::ForNode *p_for);
+	bool return_nullity_guard(GDScriptParser::ReturnNode *p_return, GDScriptParser::DataType p_expected_type);
+
+	// Nullable helpers.
+	Vector<GDScriptParser::IdentifierNode *> deduce_nullable_narrowing(GDScriptParser::ExpressionNode *p_node, bool p_should_be_false = false);
+	void push_narrowed_nullables(Vector<GDScriptParser::IdentifierNode *> p_identifiers);
+	void pop_narrowed_nullables(Vector<GDScriptParser::IdentifierNode *> p_identifiers);
+	bool is_effectively_non_nullable(GDScriptParser::ExpressionNode *p_expression) const;
+	bool is_effectively_nullable(GDScriptParser::ExpressionNode *p_expression) const { return !is_effectively_non_nullable(p_expression); }
+	bool is_deeply_nullable(GDScriptParser::DataType p_data_type, bool p_strict = false) const;
+	bool is_potentially_null_value(GDScriptParser::ExpressionNode *p_expression);
+	template <typename... Symbols>
+	void push_nullable_error(const String &p_message, Vector<GDScriptParser::ExpressionNode *> p_expressions, const GDScriptParser::Node *p_origin = nullptr, const Symbols &...p_symbols);
+	Vector<GDScriptParser::IdentifierNode *> find_nullable_identifier(GDScriptParser::ExpressionNode *left, GDScriptParser::ExpressionNode *right, bool should_be_false);
+
 #ifdef DEBUG_ENABLED
 	void is_shadowing(GDScriptParser::IdentifierNode *p_identifier, const String &p_context, const bool p_in_local_scope);
 #endif
diff --git a/modules/gdscript/gdscript_byte_codegen.cpp b/modules/gdscript/gdscript_byte_codegen.cpp
index 4cda3d303753..d4b2abbd394c 100644
--- a/modules/gdscript/gdscript_byte_codegen.cpp
+++ b/modules/gdscript/gdscript_byte_codegen.cpp
@@ -586,7 +586,8 @@ void GDScriptByteCodeGenerator::write_unary_operator(const Address &p_target, Va
 
 void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) {
 	// Avoid validated evaluator for modulo and division when operands are int, since there's no check for division by zero.
-	if (HAS_BUILTIN_TYPE(p_left_operand) && HAS_BUILTIN_TYPE(p_right_operand) && ((p_operator != Variant::OP_DIVIDE && p_operator != Variant::OP_MODULE) || p_left_operand.type.builtin_type != Variant::INT || p_right_operand.type.builtin_type != Variant::INT)) {
+	// Also avoid for nullable types.
+	if (!p_left_operand.type.is_nullable && !p_right_operand.type.is_nullable && HAS_BUILTIN_TYPE(p_left_operand) && HAS_BUILTIN_TYPE(p_right_operand) && ((p_operator != Variant::OP_DIVIDE && p_operator != Variant::OP_MODULE) || p_left_operand.type.builtin_type != Variant::INT || p_right_operand.type.builtin_type != Variant::INT)) {
 		if (p_target.mode == Address::TEMPORARY) {
 			Variant::Type result_type = Variant::get_operator_return_type(p_operator, p_left_operand.type.builtin_type, p_right_operand.type.builtin_type);
 			Variant::Type temp_type = temporaries[p_target.address].type;
@@ -623,6 +624,26 @@ void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, V
 	}
 }
 
+void GDScriptByteCodeGenerator::write_coalesce_operand(const Address &p_target, const Address &p_left_operand) {
+	// Allows us to both check if the left operand is null and if so to skip it
+	write_jump_if_null(p_left_operand, p_target, true);
+	// If here, left operand is not null
+	write_assign(p_target, p_left_operand);
+	append_opcode(GDScriptFunction::OPCODE_JUMP);
+	coalesce_op_jump.push_back(opcodes.size());
+	append(0); // will be patched
+	// Where to jump if left operand is null
+	write_end_jump_if_null(true);
+}
+
+void GDScriptByteCodeGenerator::write_end_coalesce_operand(const Address &p_target, const Address &p_right_operand) {
+	// If here, left operand is null, therefore the right operand will be evaluated and used as the result
+	write_assign(p_target, p_right_operand);
+	// Patch the left operand jump to allow it to skip the right operand related instructions
+	patch_jump(coalesce_op_jump.back()->get());
+	coalesce_op_jump.pop_back();
+}
+
 void GDScriptByteCodeGenerator::write_type_test(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) {
 	switch (p_type.kind) {
 		case GDScriptDataType::BUILTIN: {
@@ -788,7 +809,8 @@ void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address
 	append(p_source);
 }
 
-void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address &p_index, const Address &p_source) {
+void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address &p_index, const Address &p_source, bool p_is_nullable) {
+	write_jump_if_null(p_source, p_target, p_is_nullable);
 	if (HAS_BUILTIN_TYPE(p_source)) {
 		if (IS_BUILTIN_TYPE(p_index, Variant::INT) && Variant::get_member_validated_indexed_getter(p_source.type.builtin_type)) {
 			// Use indexed getter instead.
@@ -798,6 +820,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
 			append(p_index);
 			append(p_target);
 			append(getter);
+			write_end_jump_if_null(p_is_nullable);
 			return;
 		} else if (Variant::get_member_validated_keyed_getter(p_source.type.builtin_type)) {
 			Variant::ValidatedKeyedGetter getter = Variant::get_member_validated_keyed_getter(p_source.type.builtin_type);
@@ -806,6 +829,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
 			append(p_index);
 			append(p_target);
 			append(getter);
+			write_end_jump_if_null(p_is_nullable);
 			return;
 		}
 	}
@@ -813,6 +837,7 @@ void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address
 	append(p_source);
 	append(p_index);
 	append(p_target);
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const StringName &p_name, const Address &p_source) {
@@ -834,7 +859,8 @@ void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const S
 	append(p_name);
 }
 
-void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) {
+void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source, bool p_is_nullable) {
+	write_jump_if_null(p_source, p_target, p_is_nullable);
 	if (HAS_BUILTIN_TYPE(p_source) && Variant::get_member_validated_getter(p_source.type.builtin_type, p_name)) {
 		Variant::ValidatedGetter getter = Variant::get_member_validated_getter(p_source.type.builtin_type, p_name);
 		append_opcode(GDScriptFunction::OPCODE_GET_NAMED_VALIDATED);
@@ -844,12 +870,14 @@ void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const S
 #ifdef DEBUG_ENABLED
 		add_debug_name(getter_names, get_getter_pos(getter), p_name);
 #endif
+		write_end_jump_if_null(p_is_nullable);
 		return;
 	}
 	append_opcode(GDScriptFunction::OPCODE_GET_NAMED);
 	append(p_source);
 	append(p_target);
 	append(p_name);
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_set_member(const Address &p_value, const StringName &p_name) {
@@ -883,17 +911,22 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
 		case GDScriptDataType::BUILTIN: {
 			if (p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type(0)) {
 				const GDScriptDataType &element_type = p_target.type.get_container_element_type(0);
+				write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 				append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
 				append(p_target);
 				append(p_source);
 				append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
 				append(element_type.builtin_type);
 				append(element_type.native_type);
+				append(element_type.is_nullable);
+				write_end_jump_if_null(p_target.type.is_nullable);
 			} else {
+				write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 				append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
 				append(p_target);
 				append(p_source);
 				append(p_target.type.builtin_type);
+				write_end_jump_if_null(p_target.type.is_nullable);
 			}
 		} break;
 		case GDScriptDataType::NATIVE: {
@@ -909,11 +942,12 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
 		case GDScriptDataType::GDSCRIPT: {
 			Variant script = p_target.type.script_type;
 			int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
-
+			write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 			append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT);
 			append(p_target);
 			append(p_source);
 			append(idx);
+			write_end_jump_if_null(p_target.type.is_nullable);
 		} break;
 		default: {
 			ERR_PRINT("Compiler bug: unresolved assign.");
@@ -929,18 +963,23 @@ void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_ta
 void GDScriptByteCodeGenerator::write_assign(const Address &p_target, const Address &p_source) {
 	if (p_target.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type(0)) {
 		const GDScriptDataType &element_type = p_target.type.get_container_element_type(0);
+		write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 		append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
 		append(p_target);
 		append(p_source);
 		append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
 		append(element_type.builtin_type);
 		append(element_type.native_type);
+		append(element_type.is_nullable);
+		write_end_jump_if_null(p_target.type.is_nullable);
 	} else if (p_target.type.kind == GDScriptDataType::BUILTIN && p_source.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type != p_source.type.builtin_type) {
+		write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 		// Need conversion.
 		append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
 		append(p_target);
 		append(p_source);
 		append(p_target.type.builtin_type);
+		write_end_jump_if_null(p_target.type.is_nullable);
 	} else {
 		append_opcode(GDScriptFunction::OPCODE_ASSIGN);
 		append(p_target);
@@ -989,6 +1028,7 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
 
 	switch (p_type.kind) {
 		case GDScriptDataType::BUILTIN: {
+			write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 			append_opcode(GDScriptFunction::OPCODE_CAST_TO_BUILTIN);
 			index = p_type.builtin_type;
 		} break;
@@ -1000,6 +1040,7 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
 		} break;
 		case GDScriptDataType::SCRIPT:
 		case GDScriptDataType::GDSCRIPT: {
+			write_jump_if_null(p_source, p_target, p_target.type.is_nullable);
 			Variant script = p_type.script_type;
 			int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
 			append_opcode(GDScriptFunction::OPCODE_CAST_TO_SCRIPT);
@@ -1013,6 +1054,8 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
 	append(p_source);
 	append(p_target);
 	append(index);
+
+	write_end_jump_if_null(p_type.kind != GDScriptDataType::NATIVE && p_target.type.is_nullable);
 }
 
 GDScriptByteCodeGenerator::CallTarget GDScriptByteCodeGenerator::get_call_target(const GDScriptCodeGenerator::Address &p_target, Variant::Type p_type) {
@@ -1030,7 +1073,8 @@ GDScriptByteCodeGenerator::CallTarget GDScriptByteCodeGenerator::get_call_target
 	}
 }
 
-void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_jump_if_null(p_base, p_target.mode == Address::NIL ? p_base : p_target, p_is_nullable);
 	append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
 	for (int i = 0; i < p_arguments.size(); i++) {
 		append(p_arguments[i]);
@@ -1041,6 +1085,7 @@ void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Addres
 	append(p_arguments.size());
 	append(p_function_name);
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
@@ -1055,7 +1100,8 @@ void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const
 	ct.cleanup();
 }
 
-void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_jump_if_null(p_base, p_target, p_is_nullable);
 	append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
 	for (int i = 0; i < p_arguments.size(); i++) {
 		append(p_arguments[i]);
@@ -1066,6 +1112,7 @@ void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const
 	append(p_arguments.size());
 	append(p_function_name);
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_call_gdscript_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) {
@@ -1131,7 +1178,7 @@ void GDScriptByteCodeGenerator::write_call_utility(const Address &p_target, cons
 	}
 }
 
-void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments, bool p_is_nullable) {
 	bool is_validated = false;
 
 	// Check if all types are correct.
@@ -1163,7 +1210,7 @@ void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target,
 			append(p_arguments.size());
 			ct.cleanup();
 		} else {
-			write_call(p_target, p_base, p_method, p_arguments);
+			write_call(p_target, p_base, p_method, p_arguments, p_is_nullable);
 		}
 		return;
 	}
@@ -1175,8 +1222,8 @@ void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target,
 		write_type_adjust(ct.target, result_type);
 	}
 
+	write_jump_if_null(p_base, p_target, p_is_nullable);
 	append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
-
 	for (int i = 0; i < p_arguments.size(); i++) {
 		append(p_arguments[i]);
 	}
@@ -1185,14 +1232,15 @@ void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target,
 	append(p_arguments.size());
 	append(Variant::get_validated_builtin_method(p_type, p_method));
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 
 #ifdef DEBUG_ENABLED
 	add_debug_name(builtin_methods_names, get_builtin_method_pos(Variant::get_validated_builtin_method(p_type, p_method)), p_method);
 #endif
 }
 
-void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) {
-	write_call_builtin_type(p_target, p_base, p_type, p_method, false, p_arguments);
+void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_call_builtin_type(p_target, p_base, p_type, p_method, false, p_arguments, p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_call_builtin_type_static(const Address &p_target, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) {
@@ -1245,7 +1293,8 @@ void GDScriptByteCodeGenerator::write_call_native_static_validated(const GDScrip
 	ct.cleanup();
 }
 
-void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_jump_if_null(p_base, p_target, p_is_nullable);
 	append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
 	for (int i = 0; i < p_arguments.size(); i++) {
 		append(p_arguments[i]);
@@ -1256,9 +1305,12 @@ void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target,
 	append(p_arguments.size());
 	append(p_method);
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 }
 
-void GDScriptByteCodeGenerator::write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_jump_if_null(p_base, p_target, p_is_nullable);
+
 	Variant::Type return_type = Variant::NIL;
 	bool has_return = p_method->has_return();
 
@@ -1287,6 +1339,7 @@ void GDScriptByteCodeGenerator::write_call_method_bind_validated(const Address &
 	append(p_arguments.size());
 	append(p_method);
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
@@ -1315,7 +1368,8 @@ void GDScriptByteCodeGenerator::write_call_self_async(const Address &p_target, c
 	ct.cleanup();
 }
 
-void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
+void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable) {
+	write_jump_if_null(p_base, p_target, p_is_nullable);
 	append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
 	for (int i = 0; i < p_arguments.size(); i++) {
 		append(p_arguments[i]);
@@ -1326,6 +1380,7 @@ void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_targ
 	append(p_arguments.size());
 	append(p_function_name);
 	ct.cleanup();
+	write_end_jump_if_null(p_is_nullable);
 }
 
 void GDScriptByteCodeGenerator::write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) {
@@ -1420,6 +1475,7 @@ void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_tar
 	append(p_arguments.size());
 	append(p_element_type.builtin_type);
 	append(p_element_type.native_type);
+	append(p_element_type.is_nullable);
 	ct.cleanup();
 }
 
@@ -1706,12 +1762,19 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
 			if (function->return_type.kind == GDScriptDataType::BUILTIN && function->return_type.builtin_type == Variant::ARRAY && function->return_type.has_container_element_type(0)) {
 				// Typed array.
 				const GDScriptDataType &element_type = function->return_type.get_container_element_type(0);
+				if (function->return_type.is_nullable) {
+					write_exit_if_null(p_return_value);
+				}
 				append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
 				append(p_return_value);
 				append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
 				append(element_type.builtin_type);
 				append(element_type.native_type);
+				append(element_type.is_nullable);
 			} else if (function->return_type.kind == GDScriptDataType::BUILTIN && p_return_value.type.kind == GDScriptDataType::BUILTIN && function->return_type.builtin_type != p_return_value.type.builtin_type) {
+				if (function->return_type.is_nullable) {
+					write_exit_if_null(p_return_value);
+				}
 				// Add conversion.
 				append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
 				append(p_return_value);
@@ -1730,12 +1793,19 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
 			case GDScriptDataType::BUILTIN: {
 				if (function->return_type.builtin_type == Variant::ARRAY && function->return_type.has_container_element_type(0)) {
 					const GDScriptDataType &element_type = function->return_type.get_container_element_type(0);
+					if (function->return_type.is_nullable) {
+						write_exit_if_null(p_return_value);
+					}
 					append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
 					append(p_return_value);
 					append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
 					append(element_type.builtin_type);
 					append(element_type.native_type);
+					append(element_type.is_nullable);
 				} else {
+					if (function->return_type.is_nullable) {
+						write_exit_if_null(p_return_value);
+					}
 					append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
 					append(p_return_value);
 					append(function->return_type.builtin_type);
@@ -1753,7 +1823,9 @@ void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
 			case GDScriptDataType::SCRIPT: {
 				Variant script = function->return_type.script_type;
 				int script_idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
-
+				if (function->return_type.is_nullable) {
+					write_exit_if_null(p_return_value);
+				}
 				append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_SCRIPT);
 				append(p_return_value);
 				append(script_idx);
@@ -1775,6 +1847,30 @@ void GDScriptByteCodeGenerator::write_assert(const Address &p_test, const Addres
 	append(p_message);
 }
 
+void GDScriptByteCodeGenerator::write_jump_if_null(const Address &p_source, const Address &p_target, bool p_is_nullable) {
+	if (!p_is_nullable) {
+		return;
+	}
+	append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NULL);
+	append(p_source);
+	append(p_target);
+	if_null_jmp_addrs.push_back(opcodes.size());
+	append(0); // Jump destination, will be patched.
+}
+
+void GDScriptByteCodeGenerator::write_end_jump_if_null(bool p_is_nullable) {
+	if (!p_is_nullable) {
+		return;
+	}
+	patch_jump(if_null_jmp_addrs.back()->get());
+	if_null_jmp_addrs.pop_back();
+}
+
+void GDScriptByteCodeGenerator::write_exit_if_null(const Address &p_source) {
+	append_opcode(GDScriptFunction::OPCODE_EXIT_IF_NULL);
+	append(p_source);
+}
+
 void GDScriptByteCodeGenerator::start_block() {
 	push_stack_identifiers();
 }
diff --git a/modules/gdscript/gdscript_byte_codegen.h b/modules/gdscript/gdscript_byte_codegen.h
index 34f56a2f5c02..791388c45da8 100644
--- a/modules/gdscript/gdscript_byte_codegen.h
+++ b/modules/gdscript/gdscript_byte_codegen.h
@@ -142,6 +142,7 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 
 	// Lists since these can be nested.
 	List<int> if_jmp_addrs;
+	List<int> if_null_jmp_addrs;
 	List<int> for_jmp_addrs;
 	List<Address> for_counter_variables;
 	List<Address> for_container_variables;
@@ -156,6 +157,9 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	List<int> ternary_jump_fail_pos;
 	List<int> ternary_jump_skip_pos;
 
+	// Used to patch the left operand jump over the right operand for short-circuit.
+	List<int> coalesce_op_jump;
+
 	List<List<int>> current_breaks_to_patch;
 
 	void add_stack_identifier(const StringName &p_id, int p_stackpos) {
@@ -480,6 +484,8 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	virtual void write_type_adjust(const Address &p_target, Variant::Type p_new_type) override;
 	virtual void write_unary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand) override;
 	virtual void write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) override;
+	virtual void write_coalesce_operand(const Address &p_target, const Address &p_left_operand) override;
+	virtual void write_end_coalesce_operand(const Address &p_target, const Address &p_right_operand) override;
 	virtual void write_type_test(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) override;
 	virtual void write_and_left_operand(const Address &p_left_operand) override;
 	virtual void write_and_right_operand(const Address &p_right_operand) override;
@@ -493,9 +499,9 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	virtual void write_ternary_false_expr(const Address &p_expr) override;
 	virtual void write_end_ternary() override;
 	virtual void write_set(const Address &p_target, const Address &p_index, const Address &p_source) override;
-	virtual void write_get(const Address &p_target, const Address &p_index, const Address &p_source) override;
+	virtual void write_get(const Address &p_target, const Address &p_index, const Address &p_source, bool p_is_nullable = false) override;
 	virtual void write_set_named(const Address &p_target, const StringName &p_name, const Address &p_source) override;
-	virtual void write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) override;
+	virtual void write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source, bool p_is_nullable = false) override;
 	virtual void write_set_member(const Address &p_value, const StringName &p_name) override;
 	virtual void write_get_member(const Address &p_target, const StringName &p_name) override;
 	virtual void write_set_static_variable(const Address &p_value, const Address &p_class, int p_index) override;
@@ -509,21 +515,21 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	virtual void write_store_global(const Address &p_dst, int p_global_index) override;
 	virtual void write_store_named_global(const Address &p_dst, const StringName &p_global) override;
 	virtual void write_cast(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) override;
-	virtual void write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
+	virtual void write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
 	virtual void write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
-	virtual void write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
+	virtual void write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
 	virtual void write_call_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) override;
-	void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments);
+	void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments, bool p_is_nullable = false);
 	virtual void write_call_gdscript_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) override;
-	virtual void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) override;
+	virtual void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
 	virtual void write_call_builtin_type_static(const Address &p_target, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) override;
 	virtual void write_call_native_static(const Address &p_target, const StringName &p_class, const StringName &p_method, const Vector<Address> &p_arguments) override;
 	virtual void write_call_native_static_validated(const Address &p_target, MethodBind *p_method, const Vector<Address> &p_arguments) override;
-	virtual void write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) override;
-	virtual void write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) override;
+	virtual void write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
+	virtual void write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
 	virtual void write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
 	virtual void write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
-	virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
+	virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) override;
 	virtual void write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) override;
 	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;
@@ -548,6 +554,9 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	virtual void write_newline(int p_line) override;
 	virtual void write_return(const Address &p_return_value) override;
 	virtual void write_assert(const Address &p_test, const Address &p_message) override;
+	virtual void write_jump_if_null(const Address &p_source, const Address &p_target, bool p_is_nullable) override;
+	virtual void write_end_jump_if_null(bool p_is_nullable) override;
+	virtual void write_exit_if_null(const Address &p_source) override;
 
 	virtual ~GDScriptByteCodeGenerator();
 };
diff --git a/modules/gdscript/gdscript_codegen.h b/modules/gdscript/gdscript_codegen.h
index c1c0b61395d5..58784136462f 100644
--- a/modules/gdscript/gdscript_codegen.h
+++ b/modules/gdscript/gdscript_codegen.h
@@ -94,6 +94,8 @@ class GDScriptCodeGenerator {
 	virtual void write_type_adjust(const Address &p_target, Variant::Type p_new_type) = 0;
 	virtual void write_unary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand) = 0;
 	virtual void write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) = 0;
+	virtual void write_coalesce_operand(const Address &p_target, const Address &p_left_operand) = 0;
+	virtual void write_end_coalesce_operand(const Address &p_target, const Address &p_right_operand) = 0;
 	virtual void write_type_test(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) = 0;
 	virtual void write_and_left_operand(const Address &p_left_operand) = 0;
 	virtual void write_and_right_operand(const Address &p_right_operand) = 0;
@@ -107,9 +109,9 @@ class GDScriptCodeGenerator {
 	virtual void write_ternary_false_expr(const Address &p_expr) = 0;
 	virtual void write_end_ternary() = 0;
 	virtual void write_set(const Address &p_target, const Address &p_index, const Address &p_source) = 0;
-	virtual void write_get(const Address &p_target, const Address &p_index, const Address &p_source) = 0;
+	virtual void write_get(const Address &p_target, const Address &p_index, const Address &p_source, bool p_is_nullable = false) = 0;
 	virtual void write_set_named(const Address &p_target, const StringName &p_name, const Address &p_source) = 0;
-	virtual void write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) = 0;
+	virtual void write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source, bool p_is_nullable = false) = 0;
 	virtual void write_set_member(const Address &p_value, const StringName &p_name) = 0;
 	virtual void write_get_member(const Address &p_target, const StringName &p_name) = 0;
 	virtual void write_set_static_variable(const Address &p_value, const Address &p_class, int p_index) = 0;
@@ -123,20 +125,20 @@ class GDScriptCodeGenerator {
 	virtual void write_store_global(const Address &p_dst, int p_global_index) = 0;
 	virtual void write_store_named_global(const Address &p_dst, const StringName &p_global) = 0;
 	virtual void write_cast(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) = 0;
-	virtual void write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
+	virtual void write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
 	virtual void write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
-	virtual void write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
+	virtual void write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
 	virtual void write_call_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) = 0;
 	virtual void write_call_gdscript_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) = 0;
-	virtual void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) = 0;
+	virtual void write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
 	virtual void write_call_builtin_type_static(const Address &p_target, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) = 0;
 	virtual void write_call_native_static(const Address &p_target, const StringName &p_class, const StringName &p_method, const Vector<Address> &p_arguments) = 0;
 	virtual void write_call_native_static_validated(const Address &p_target, MethodBind *p_method, const Vector<Address> &p_arguments) = 0;
-	virtual void write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) = 0;
-	virtual void write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) = 0;
+	virtual void write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
+	virtual void write_call_method_bind_validated(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
 	virtual void write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
 	virtual void write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
-	virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
+	virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments, bool p_is_nullable = false) = 0;
 	virtual void write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) = 0;
 	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;
@@ -161,6 +163,9 @@ class GDScriptCodeGenerator {
 	virtual void write_newline(int p_line) = 0;
 	virtual void write_return(const Address &p_return_value) = 0;
 	virtual void write_assert(const Address &p_test, const Address &p_message) = 0;
+	virtual void write_jump_if_null(const Address &p_source, const Address &p_target, bool p_is_nullable) = 0;
+	virtual void write_end_jump_if_null(bool p_is_nullable) = 0;
+	virtual void write_exit_if_null(const Address &p_source) = 0;
 
 	virtual ~GDScriptCodeGenerator() {}
 };
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index eeffc13a1004..bb182c279610 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -93,6 +93,7 @@ GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::D
 
 	GDScriptDataType result;
 	result.has_type = true;
+	result.is_nullable = p_datatype.is_nullable;
 
 	switch (p_datatype.kind) {
 		case GDScriptParser::DataType::VARIANT: {
@@ -689,7 +690,7 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 									return GDScriptCodeGenerator::Address();
 								}
 								if (is_awaited) {
-									gen->write_call_async(result, base, call->function_name, arguments);
+									gen->write_call_async(result, base, call->function_name, arguments, subscript->is_nullable);
 								} else if (base.type.has_type && base.type.kind != GDScriptDataType::BUILTIN) {
 									// Native method, use faster path.
 									StringName class_name;
@@ -702,18 +703,18 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 										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);
+											gen->write_call_method_bind_validated(result, base, method, arguments, subscript->is_nullable);
 										} else {
 											// Not exact arguments, but still can use method bind call.
-											gen->write_call_method_bind(result, base, method, arguments);
+											gen->write_call_method_bind(result, base, method, arguments, subscript->is_nullable);
 										}
 									} else {
-										gen->write_call(result, base, call->function_name, arguments);
+										gen->write_call(result, base, call->function_name, arguments, subscript->is_nullable);
 									}
 								} 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);
+									gen->write_call_builtin_type(result, base, base.type.builtin_type, call->function_name, arguments, subscript->is_nullable);
 								} else {
-									gen->write_call(result, base, call->function_name, arguments);
+									gen->write_call(result, base, call->function_name, arguments, subscript->is_nullable);
 								}
 								if (base.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
 									gen->pop_temporary();
@@ -829,9 +830,9 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 			}
 
 			if (named) {
-				gen->write_get_named(result, name, base);
+				gen->write_get_named(result, name, base, subscript->is_nullable);
 			} else {
-				gen->write_get(result, index, base);
+				gen->write_get(result, index, base, subscript->is_nullable);
 			}
 
 			if (index.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
@@ -899,6 +900,27 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 						gen->pop_temporary();
 					}
 				} break;
+				case GDScriptParser::BinaryOpNode::OP_COALESCE: {
+					// ?? operator with early out if left operand is not null.
+					GDScriptCodeGenerator::Address left_operand = _parse_expression(codegen, r_error, binary->left_operand);
+
+					if (!binary->left_operand->get_datatype().is_nullable && binary->left_operand->reduced_value.get_type() != Variant::NIL && binary->left_operand->reduced_value.get_type() != Variant::OBJECT) {
+						// OPTIMIZATION: A reduced constant expression that's not null and not an object can't possibly be null
+						gen->write_assign(result, left_operand);
+					} else {
+						gen->write_coalesce_operand(result, left_operand);
+						GDScriptCodeGenerator::Address right_operand = _parse_expression(codegen, r_error, binary->right_operand);
+						gen->write_end_coalesce_operand(result, right_operand);
+
+						if (right_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
+							gen->pop_temporary();
+						}
+					}
+
+					if (left_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
+						gen->pop_temporary();
+					}
+				} break;
 				default: {
 					GDScriptCodeGenerator::Address left_operand = _parse_expression(codegen, r_error, binary->left_operand);
 					GDScriptCodeGenerator::Address right_operand = _parse_expression(codegen, r_error, binary->right_operand);
@@ -1091,13 +1113,13 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 
 					if (subscript_elem->is_attribute) {
 						name = subscript_elem->attribute->name;
-						gen->write_get_named(value, name, prev_base);
+						gen->write_get_named(value, name, prev_base, subscript_elem->is_nullable);
 					} else {
 						key = _parse_expression(codegen, r_error, subscript_elem->index);
 						if (r_error) {
 							return GDScriptCodeGenerator::Address();
 						}
-						gen->write_get(value, key, prev_base);
+						gen->write_get(value, key, prev_base, subscript_elem->is_nullable);
 					}
 
 					// Store base and key for setting it back later.
@@ -1127,9 +1149,9 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 					GDScriptCodeGenerator::Address op_result = codegen.add_temporary(_gdtype_from_datatype(assignment->get_datatype(), codegen.script));
 					GDScriptCodeGenerator::Address value = codegen.add_temporary(_gdtype_from_datatype(subscript->get_datatype(), codegen.script));
 					if (subscript->is_attribute) {
-						gen->write_get_named(value, name, prev_base);
+						gen->write_get_named(value, name, prev_base, subscript->is_nullable);
 					} else {
-						gen->write_get(value, key, prev_base);
+						gen->write_get(value, key, prev_base, subscript->is_nullable);
 					}
 					gen->write_binary_operator(op_result, assignment->variant_op, value, assigned);
 					gen->pop_temporary();
@@ -1205,7 +1227,7 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 							Vector<GDScriptCodeGenerator::Address> args;
 							args.push_back(assigned);
 							GDScriptCodeGenerator::Address call_base = is_static ? GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::CLASS) : GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::SELF);
-							gen->write_call(GDScriptCodeGenerator::Address(), call_base, member_property_setter_function, args);
+							gen->write_call(GDScriptCodeGenerator::Address(), call_base, member_property_setter_function, args, subscript->is_nullable);
 						} else if (is_static) {
 							GDScriptCodeGenerator::Address temp = codegen.add_temporary(static_var_data_type);
 							gen->write_assign(temp, assigned);
@@ -2773,6 +2795,10 @@ Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptP
 				prop_info.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 				minfo.property_info = prop_info;
 
+				if (minfo.data_type.is_nullable) {
+					prop_info.usage |= PROPERTY_USAGE_NULLABLE;
+				}
+
 				if (variable->is_static) {
 					minfo.index = p_script->static_variables_indices.size();
 					p_script->static_variables_indices[name] = minfo;
diff --git a/modules/gdscript/gdscript_disassembler.cpp b/modules/gdscript/gdscript_disassembler.cpp
index 03310450780e..ec5041ff539b 100644
--- a/modules/gdscript/gdscript_disassembler.cpp
+++ b/modules/gdscript/gdscript_disassembler.cpp
@@ -397,7 +397,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 				text += " = ";
 				text += DADDR(2);
 
-				incr += 6;
+				incr += 7;
 			} break;
 			case OPCODE_ASSIGN_TYPED_NATIVE: {
 				text += "assign typed native (";
@@ -526,6 +526,10 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 					type_name = Variant::get_type_name(builtin_type);
 				}
 
+				if (_code_ptr[ip + 4]) {
+					type_name += "?";
+				}
+
 				text += " make_typed_array (";
 				text += type_name;
 				text += ") ";
@@ -542,7 +546,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 
 				text += "]";
 
-				incr += 6 + argc;
+				incr += 7 + argc;
 			} break;
 			case OPCODE_CONSTRUCT_DICTIONARY: {
 				int instr_var_args = _code_ptr[++ip];
@@ -958,6 +962,20 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 
 				incr = 3;
 			} break;
+			case OPCODE_JUMP_IF_NULL: {
+				text += "jump-if-null ";
+				text += DADDR(1);
+				text += " to ";
+				text += itos(_code_ptr[ip + 2]);
+
+				incr += 4;
+			} break;
+			case OPCODE_EXIT_IF_NULL: {
+				text += "exit-if-null ";
+				text += DADDR(1);
+
+				incr += 4;
+			} break;
 			case OPCODE_RETURN: {
 				text += "return ";
 				text += DADDR(1);
@@ -973,10 +991,14 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 				incr += 3;
 			} break;
 			case OPCODE_RETURN_TYPED_ARRAY: {
-				text += "return typed array ";
+				text += "return ";
+				if (_code_ptr[ip + 5]) {
+					text += "nullable ";
+				}
+				text += "typed array ";
 				text += DADDR(1);
 
-				incr += 5;
+				incr += 6;
 			} break;
 			case OPCODE_RETURN_TYPED_NATIVE: {
 				text += "return typed native (";
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index 759e92d68ce5..7fe01d19514a 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -59,6 +59,7 @@ class GDScriptDataType {
 	Kind kind = UNINITIALIZED;
 
 	bool has_type = false;
+	bool is_nullable = false;
 	Variant::Type builtin_type = Variant::NIL;
 	StringName native_type;
 	Script *script_type = nullptr;
@@ -69,6 +70,11 @@ class GDScriptDataType {
 			return true; // Can't type check
 		}
 
+		// Allows for nulls to be provided to setters and getters of nullable properties
+		if (is_nullable && p_variant.get_type() == Variant::NIL) {
+			return true;
+		}
+
 		switch (kind) {
 			case UNINITIALIZED:
 				break;
@@ -199,6 +205,7 @@ class GDScriptDataType {
 	void operator=(const GDScriptDataType &p_other) {
 		kind = p_other.kind;
 		has_type = p_other.has_type;
+		is_nullable = p_other.is_nullable;
 		builtin_type = p_other.builtin_type;
 		native_type = p_other.native_type;
 		script_type = p_other.script_type;
@@ -277,6 +284,8 @@ class GDScriptFunction {
 		OPCODE_JUMP_IF_NOT,
 		OPCODE_JUMP_TO_DEF_ARGUMENT,
 		OPCODE_JUMP_IF_SHARED,
+		OPCODE_JUMP_IF_NULL,
+		OPCODE_EXIT_IF_NULL,
 		OPCODE_RETURN,
 		OPCODE_RETURN_TYPED_BUILTIN,
 		OPCODE_RETURN_TYPED_ARRAY,
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index f1a35c84b7f2..47f43f245c89 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -1288,7 +1288,7 @@ GDScriptParser::ConstantNode *GDScriptParser::parse_constant(bool p_is_static) {
 			constant->infer_datatype = true;
 		} else {
 			// Parse type.
-			constant->datatype_specifier = parse_type();
+			constant->datatype_specifier = parse_type(false, false);
 		}
 	}
 
@@ -2449,7 +2449,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_precedence(Precedence p_pr
 
 	advance(); // Only consume the token if there's a valid rule.
 
-	ExpressionNode *previous_operand = (this->*prefix_rule)(nullptr, p_can_assign);
+	ExpressionNode *previous_operand = (this->*prefix_rule)(nullptr, p_can_assign, false);
 
 	while (p_precedence <= get_rule(current.type)->precedence) {
 		if (previous_operand == nullptr || (p_stop_on_assign && current.type == GDScriptTokenizer::Token::EQUAL) || lambda_ended) {
@@ -2467,7 +2467,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_precedence(Precedence p_pr
 		}
 		token = advance();
 		ParseFunction infix_rule = get_rule(token.type)->infix;
-		previous_operand = (this->*infix_rule)(previous_operand, p_can_assign);
+		previous_operand = (this->*infix_rule)(previous_operand, p_can_assign, false);
 	}
 
 	return previous_operand;
@@ -2488,7 +2488,7 @@ GDScriptParser::IdentifierNode *GDScriptParser::parse_identifier() {
 	return identifier;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_identifier(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_identifier(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	if (!previous.is_identifier()) {
 		ERR_FAIL_V_MSG(nullptr, "Parser bug: parsing identifier node without identifier token.");
 	}
@@ -2542,7 +2542,7 @@ GDScriptParser::LiteralNode *GDScriptParser::parse_literal() {
 	return static_cast<LiteralNode *>(parse_literal(nullptr, false));
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_literal(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_literal(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	if (previous.type != GDScriptTokenizer::Token::LITERAL) {
 		push_error("Parser bug: parsing literal node without literal token.");
 		ERR_FAIL_V_MSG(nullptr, "Parser bug: parsing literal node without literal token.");
@@ -2554,7 +2554,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_literal(ExpressionNode *p_
 	return literal;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_self(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_self(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	if (current_function && current_function->is_static) {
 		push_error(R"(Cannot use "self" inside a static function.)");
 	}
@@ -2564,7 +2564,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_self(ExpressionNode *p_pre
 	return self;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_builtin_constant(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_builtin_constant(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	GDScriptTokenizer::Token::Type op_type = previous.type;
 	LiteralNode *constant = alloc_node<LiteralNode>();
 	complete_extents(constant);
@@ -2589,7 +2589,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_builtin_constant(Expressio
 	return constant;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_unary_operator(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_unary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	GDScriptTokenizer::Token::Type op_type = previous.type;
 	UnaryOpNode *operation = alloc_node<UnaryOpNode>();
 
@@ -2636,7 +2636,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_unary_operator(ExpressionN
 	return operation;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_not_in_operator(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_not_in_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	// check that NOT is followed by IN by consuming it before calling parse_binary_operator which will only receive a plain IN
 	UnaryOpNode *operation = alloc_node<UnaryOpNode>();
 	reset_extents(operation, p_previous_operand);
@@ -2650,7 +2650,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_not_in_operator(Exp
 	return operation;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_operator(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	GDScriptTokenizer::Token op = previous;
 	BinaryOpNode *operation = alloc_node<BinaryOpNode>();
 	reset_extents(operation, p_previous_operand);
@@ -2749,6 +2749,9 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_operator(Expression
 			operation->operation = BinaryOpNode::OP_COMP_GREATER_EQUAL;
 			operation->variant_op = Variant::OP_GREATER_EQUAL;
 			break;
+		case GDScriptTokenizer::Token::COALESCE:
+			operation->operation = BinaryOpNode::OP_COALESCE;
+			break;
 		default:
 			return nullptr; // Unreachable.
 	}
@@ -2756,7 +2759,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_binary_operator(Expression
 	return operation;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_ternary_operator(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_ternary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	// Only one ternary operation exists, so no abstraction here.
 	TernaryOpNode *operation = alloc_node<TernaryOpNode>();
 	reset_extents(operation, p_previous_operand);
@@ -2781,7 +2784,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_ternary_operator(Expressio
 	return operation;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_assignment(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_assignment(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	if (!p_can_assign) {
 		push_error("Assignment is not allowed inside an expression.");
 		return parse_expression(false); // Return the following expression.
@@ -2890,7 +2893,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_assignment(ExpressionNode
 	return assignment;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_await(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_await(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	AwaitNode *await = alloc_node<AwaitNode>();
 	ExpressionNode *element = parse_precedence(PREC_AWAIT, false);
 	if (element == nullptr) {
@@ -2906,7 +2909,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_await(ExpressionNode *p_pr
 	return await;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_array(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_array(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	ArrayNode *array = alloc_node<ArrayNode>();
 
 	if (!check(GDScriptTokenizer::Token::BRACKET_CLOSE)) {
@@ -2931,7 +2934,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_array(ExpressionNode *p_pr
 	return array;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_dictionary(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_dictionary(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	DictionaryNode *dictionary = alloc_node<DictionaryNode>();
 
 	bool decided_style = false;
@@ -3023,7 +3026,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_dictionary(ExpressionNode
 	return dictionary;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_grouping(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_grouping(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	ExpressionNode *grouped = parse_expression(false);
 	pop_multiline();
 	if (grouped == nullptr) {
@@ -3034,7 +3037,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_grouping(ExpressionNode *p
 	return grouped;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_attribute(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_attribute(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	SubscriptNode *attribute = alloc_node<SubscriptNode>();
 	reset_extents(attribute, p_previous_operand);
 	update_extents(attribute);
@@ -3055,6 +3058,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_attribute(ExpressionNode *
 	}
 
 	attribute->base = p_previous_operand;
+	attribute->is_nullable = p_is_nullable;
 
 	if (current.is_node_name()) {
 		current.type = GDScriptTokenizer::Token::IDENTIFIER;
@@ -3071,7 +3075,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_attribute(ExpressionNode *
 	return attribute;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_subscript(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_subscript(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	SubscriptNode *subscript = alloc_node<SubscriptNode>();
 	reset_extents(subscript, p_previous_operand);
 	update_extents(subscript);
@@ -3080,6 +3084,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_subscript(ExpressionNode *
 
 	subscript->base = p_previous_operand;
 	subscript->index = parse_expression(false);
+	subscript->is_nullable = p_is_nullable;
 
 	if (subscript->index == nullptr) {
 		push_error(R"(Expected expression after "[".)");
@@ -3092,7 +3097,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_subscript(ExpressionNode *
 	return subscript;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_cast(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_cast(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	CastNode *cast = alloc_node<CastNode>();
 	reset_extents(cast, p_previous_operand);
 	update_extents(cast);
@@ -3109,7 +3114,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_cast(ExpressionNode *p_pre
 	return cast;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_call(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_call(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	CallNode *call = alloc_node<CallNode>();
 	reset_extents(call, p_previous_operand);
 
@@ -3202,7 +3207,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_call(ExpressionNode *p_pre
 	return call;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_get_node(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_get_node(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	// We want code completion after a DOLLAR even if the current code is invalid.
 	make_completion_context(COMPLETION_GET_NODE, nullptr, -1, true);
 
@@ -3311,7 +3316,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_get_node(ExpressionNode *p
 	return get_node;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_preload(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_preload(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	PreloadNode *preload = alloc_node<PreloadNode>();
 	preload->resolved_path = "<missing path>";
 
@@ -3336,7 +3341,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_preload(ExpressionNode *p_
 	return preload;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	LambdaNode *lambda = alloc_node<LambdaNode>();
 	lambda->parent_function = current_function;
 	lambda->parent_lambda = current_lambda;
@@ -3419,7 +3424,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_lambda(ExpressionNode *p_p
 	return lambda;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_type_test(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_type_test(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	// x is not int
 	// ^        ^^^ ExpressionNode, TypeNode
 	// ^^^^^^^^^^^^ TypeTestNode
@@ -3461,28 +3466,30 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_type_test(ExpressionNode *
 	return type_test;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_yield(ExpressionNode *p_previous_operand, bool p_can_assign) {
+GDScriptParser::ExpressionNode *GDScriptParser::parse_yield(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
 	push_error(R"("yield" was removed in Godot 4. Use "await" instead.)");
 	return nullptr;
 }
 
-GDScriptParser::ExpressionNode *GDScriptParser::parse_invalid_token(ExpressionNode *p_previous_operand, bool p_can_assign) {
-	// Just for better error messages.
-	GDScriptTokenizer::Token::Type invalid = previous.type;
+GDScriptParser::ExpressionNode *GDScriptParser::parse_nullable_access(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable) {
+	if (check(GDScriptTokenizer::Token::PERIOD)) {
+		advance();
+		return parse_attribute(p_previous_operand, false, true);
+	}
 
-	switch (invalid) {
-		case GDScriptTokenizer::Token::QUESTION_MARK:
-			push_error(R"(Unexpected "?" in source. If you want a ternary operator, use "truthy_value if true_condition else falsy_value".)");
-			break;
-		default:
-			return nullptr; // Unreachable.
+	if (check(GDScriptTokenizer::Token::BRACKET_OPEN)) {
+		push_multiline(true);
+		advance();
+		return parse_subscript(p_previous_operand, false, true);
 	}
 
+	push_error(R"(Unexpected "?" in source. If you want a ternary operator, use "truthy_value if true_condition else falsy_value".)");
+
 	// Return the previous expression.
 	return p_previous_operand;
 }
 
-GDScriptParser::TypeNode *GDScriptParser::parse_type(bool p_allow_void) {
+GDScriptParser::TypeNode *GDScriptParser::parse_type(bool p_allow_void, bool p_allow_nullable) {
 	TypeNode *type = alloc_node<TypeNode>();
 	make_completion_context(p_allow_void ? COMPLETION_TYPE_NAME_OR_VOID : COMPLETION_TYPE_NAME, type);
 	if (!match(GDScriptTokenizer::Token::IDENTIFIER)) {
@@ -3522,6 +3529,7 @@ GDScriptParser::TypeNode *GDScriptParser::parse_type(bool p_allow_void) {
 			first_pass = false;
 		} while (match(GDScriptTokenizer::Token::COMMA));
 		consume(GDScriptTokenizer::Token::BRACKET_CLOSE, R"(Expected closing "]" after collection type.)");
+		parse_nullable_type(type, p_allow_nullable);
 		if (type != nullptr) {
 			complete_extents(type);
 		}
@@ -3537,10 +3545,27 @@ GDScriptParser::TypeNode *GDScriptParser::parse_type(bool p_allow_void) {
 		}
 	}
 
+	parse_nullable_type(type, p_allow_nullable);
 	complete_extents(type);
 	return type;
 }
 
+void GDScriptParser::parse_nullable_type(TypeNode *p_type, bool p_allow_nullable) {
+	if (!p_type) {
+		return;
+	}
+
+	DataType data_type = p_type->get_datatype();
+	data_type.is_nullable = match(GDScriptTokenizer::Token::QUESTION_MARK);
+	if (data_type.is_nullable && !p_allow_nullable) {
+		push_error(R"(Nullable qualifier ("?") not allowed in this context)", p_type);
+		return;
+	}
+	p_type->set_datatype(data_type);
+
+	return;
+}
+
 #ifdef TOOLS_ENABLED
 enum DocLineState {
 	DOC_LINE_NORMAL,
@@ -3864,6 +3889,7 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
 		{ nullptr,                                          &GDScriptParser::parse_binary_operator,      	PREC_COMPARISON }, // GREATER_EQUAL,
 		{ nullptr,                                          &GDScriptParser::parse_binary_operator,      	PREC_COMPARISON }, // EQUAL_EQUAL,
 		{ nullptr,                                          &GDScriptParser::parse_binary_operator,      	PREC_COMPARISON }, // BANG_EQUAL,
+		{ nullptr,                                          &GDScriptParser::parse_binary_operator,        	PREC_TYPE_TEST }, // COALESCE,
 		// Logical
 		{ nullptr,                                          &GDScriptParser::parse_binary_operator,      	PREC_LOGIC_AND }, // AND,
 		{ nullptr,                                          &GDScriptParser::parse_binary_operator,      	PREC_LOGIC_OR }, // OR,
@@ -3960,7 +3986,7 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
 		// Error message improvement
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // VCS_CONFLICT_MARKER,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // BACKTICK,
-		{ nullptr,                                          &GDScriptParser::parse_invalid_token,        	PREC_CAST }, // QUESTION_MARK,
+		{ nullptr,                                          &GDScriptParser::parse_nullable_access,        	PREC_ATTRIBUTE }, // QUESTION_MARK,
 		// Special
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // ERROR,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // TK_EOF,
@@ -4715,49 +4741,71 @@ String GDScriptParser::SuiteNode::Local::get_name() const {
 }
 
 String GDScriptParser::DataType::to_string() const {
+	String result;
 	switch (kind) {
 		case VARIANT:
-			return "Variant";
+			result = "Variant";
+			break;
 		case BUILTIN:
 			if (builtin_type == Variant::NIL) {
-				return "null";
+				result = "null";
+				break;
 			}
 			if (builtin_type == Variant::ARRAY && has_container_element_type(0)) {
-				return vformat("Array[%s]", container_element_types[0].to_string());
+				result = vformat("Array[%s]", container_element_types[0].to_string());
+				break;
 			}
-			return Variant::get_type_name(builtin_type);
+			result = Variant::get_type_name(builtin_type);
+			break;
 		case NATIVE:
 			if (is_meta_type) {
-				return GDScriptNativeClass::get_class_static();
+				result = GDScriptNativeClass::get_class_static();
+				break;
 			}
-			return native_type.operator String();
+			result = native_type.operator String();
+			break;
 		case CLASS:
 			if (class_type->identifier != nullptr) {
-				return class_type->identifier->name.operator String();
+				result = class_type->identifier->name.operator String();
+				break;
 			}
-			return class_type->fqcn;
+			result = class_type->fqcn;
+			break;
 		case SCRIPT: {
 			if (is_meta_type) {
-				return script_type != nullptr ? script_type->get_class_name().operator String() : "";
+				result = script_type != nullptr ? script_type->get_class_name().operator String() : "";
 			}
 			String name = script_type != nullptr ? script_type->get_name() : "";
 			if (!name.is_empty()) {
-				return name;
+				result = name;
+				break;
 			}
 			name = script_path;
 			if (!name.is_empty()) {
-				return name;
+				result = name;
+				break;
 			}
-			return native_type.operator String();
+			result = native_type.operator String();
+			break;
 		}
 		case ENUM: {
 			// native_type contains either the native class defining the enum
 			// or the fully qualified class name of the script defining the enum
-			return String(native_type).get_file(); // Remove path, keep filename
+			result = String(native_type).get_file(); // Remove path, keep filename
+			break;
 		}
 		case RESOLVING:
 		case UNRESOLVED:
-			return "<unresolved type>";
+			result = "<unresolved type>";
+			break;
+	}
+
+	if (!result.is_empty()) {
+		if (is_nullable) {
+			result += "?";
+		}
+
+		return result;
 	}
 
 	ERR_FAIL_V_MSG("<unresolved type>", "Kind set outside the enum range.");
@@ -5134,6 +5182,9 @@ void GDScriptParser::TreePrinter::print_binary_op(BinaryOpNode *p_binary_op) {
 		case BinaryOpNode::OP_COMP_GREATER_EQUAL:
 			push_text(" >= ");
 			break;
+		case BinaryOpNode::OP_COALESCE:
+			push_text(" ?? ");
+			break;
 	}
 	print_expression(p_binary_op->right_operand);
 	// Surround in parenthesis for disambiguation.
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 96358165c0d0..7144c3d5e792 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -127,6 +127,7 @@ class GDScriptParser {
 		bool is_constant = false;
 		bool is_read_only = false;
 		bool is_meta_type = false;
+		bool is_nullable = false;
 		bool is_pseudo_type = false; // For global names that can't be used standalone.
 		bool is_coroutine = false; // For function calls.
 
@@ -232,6 +233,7 @@ class GDScriptParser {
 			is_read_only = p_other.is_read_only;
 			is_constant = p_other.is_constant;
 			is_meta_type = p_other.is_meta_type;
+			is_nullable = p_other.is_nullable;
 			is_pseudo_type = p_other.is_pseudo_type;
 			is_coroutine = p_other.is_coroutine;
 			builtin_type = p_other.builtin_type;
@@ -469,6 +471,7 @@ class GDScriptParser {
 			OP_COMP_LESS_EQUAL,
 			OP_COMP_GREATER,
 			OP_COMP_GREATER_EQUAL,
+			OP_COALESCE,
 		};
 
 		OpType operation = OpType::OP_ADDITION;
@@ -1068,6 +1071,7 @@ class GDScriptParser {
 		};
 
 		bool is_attribute = false;
+		bool is_nullable = false;
 
 		SubscriptNode() {
 			type = SUBSCRIPT;
@@ -1391,7 +1395,7 @@ class GDScriptParser {
 	static HashMap<StringName, AnnotationInfo> valid_annotations;
 	List<AnnotationNode *> annotation_stack;
 
-	typedef ExpressionNode *(GDScriptParser::*ParseFunction)(ExpressionNode *p_previous_operand, bool p_can_assign);
+	typedef ExpressionNode *(GDScriptParser::*ParseFunction)(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable);
 	// Higher value means higher precedence (i.e. is evaluated first).
 	enum Precedence {
 		PREC_NONE,
@@ -1524,32 +1528,35 @@ class GDScriptParser {
 	// Expressions.
 	ExpressionNode *parse_expression(bool p_can_assign, bool p_stop_on_assign = false);
 	ExpressionNode *parse_precedence(Precedence p_precedence, bool p_can_assign, bool p_stop_on_assign = false);
-	ExpressionNode *parse_literal(ExpressionNode *p_previous_operand, bool p_can_assign);
+	ExpressionNode *parse_literal(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
 	LiteralNode *parse_literal();
-	ExpressionNode *parse_self(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_identifier(ExpressionNode *p_previous_operand, bool p_can_assign);
+	ExpressionNode *parse_self(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_identifier(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
 	IdentifierNode *parse_identifier();
-	ExpressionNode *parse_builtin_constant(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_unary_operator(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_binary_operator(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_binary_not_in_operator(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_ternary_operator(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_assignment(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_array(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_dictionary(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_call(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_get_node(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_preload(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_grouping(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_cast(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_await(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_attribute(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_subscript(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_type_test(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_yield(ExpressionNode *p_previous_operand, bool p_can_assign);
-	ExpressionNode *parse_invalid_token(ExpressionNode *p_previous_operand, bool p_can_assign);
-	TypeNode *parse_type(bool p_allow_void = false);
+	ExpressionNode *parse_builtin_constant(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_unary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_binary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_coalesce_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_binary_not_in_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_ternary_operator(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_assignment(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_array(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_dictionary(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_call(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_get_node(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_preload(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_grouping(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_cast(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_await(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_attribute(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_subscript(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_type_test(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_yield(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	ExpressionNode *parse_nullable_access(ExpressionNode *p_previous_operand, bool p_can_assign, bool p_is_nullable = false);
+	TypeNode *parse_type(bool p_allow_void = false, bool p_allow_nullable = true);
+
+	void parse_nullable_type(TypeNode *p_type, bool p_allow_nullable);
 
 #ifdef TOOLS_ENABLED
 	int max_script_doc_line = INT_MAX;
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 5b1639e2505a..132222ccd9b5 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -54,6 +54,7 @@ static const char *token_names[] = {
 	">=", // GREATER_EQUAL,
 	"==", // EQUAL_EQUAL,
 	"!=", // BANG_EQUAL,
+	"??", // COALESCE,
 	// Logical
 	"and", // AND,
 	"or", // OR,
@@ -289,6 +290,10 @@ void GDScriptTokenizerText::pop_expression_indented_block() {
 	indent_stack_stack.pop_back();
 }
 
+String GDScriptTokenizerText::get_source() const {
+	return source;
+}
+
 int GDScriptTokenizerText::get_cursor_line() const {
 	return cursor_line;
 }
@@ -1496,7 +1501,13 @@ GDScriptTokenizer::Token GDScriptTokenizerText::scan() {
 		case '$':
 			return make_token(Token::DOLLAR);
 		case '?':
-			return make_token(Token::QUESTION_MARK);
+			if (_peek() == '?') {
+				_advance();
+
+				return make_token(Token::COALESCE);
+			} else {
+				return make_token(Token::QUESTION_MARK);
+			}
 		case '`':
 			return make_token(Token::BACKTICK);
 
diff --git a/modules/gdscript/gdscript_tokenizer.h b/modules/gdscript/gdscript_tokenizer.h
index 5d7637517381..a5d932b2e6cf 100644
--- a/modules/gdscript/gdscript_tokenizer.h
+++ b/modules/gdscript/gdscript_tokenizer.h
@@ -66,6 +66,7 @@ class GDScriptTokenizer {
 			GREATER_EQUAL,
 			EQUAL_EQUAL,
 			BANG_EQUAL,
+			COALESCE,
 			// Logical
 			AND,
 			OR,
@@ -203,10 +204,14 @@ class GDScriptTokenizer {
 		}
 	};
 	virtual const HashMap<int, CommentData> &get_comments() const = 0;
+
 #endif // TOOLS_ENABLED
 
 	static String get_token_name(Token::Type p_token_type);
 
+	virtual String get_source() const {
+		return "<not implemented>";
+	}
 	virtual int get_cursor_line() const = 0;
 	virtual int get_cursor_column() const = 0;
 	virtual void set_cursor_position(int p_line, int p_column) = 0;
@@ -293,6 +298,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
 
 	const Vector<int> &get_continuation_lines() const { return continuation_lines; }
 
+	virtual String get_source() const override;
 	virtual int get_cursor_line() const override;
 	virtual int get_cursor_column() const override;
 	virtual void set_cursor_position(int p_line, int p_column) override;
@@ -306,6 +312,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
 	virtual const HashMap<int, CommentData> &get_comments() const override {
 		return comments;
 	}
+
 #endif // TOOLS_ENABLED
 
 	virtual Token scan() override;
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 3333f1b6ae5d..489712cf603a 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -49,14 +49,19 @@ static bool _profile_count_as_native(const Object *p_base_obj, const StringName
 	return ClassDB::class_exists(cname) && ClassDB::has_method(cname, p_methodname, false);
 }
 
-static String _get_element_type(Variant::Type builtin_type, const StringName &native_type, const Ref<Script> &script_type) {
+static String _get_element_type(Variant::Type builtin_type, const StringName &native_type, const Ref<Script> &script_type, bool is_nullable = false) {
+	String result;
 	if (script_type.is_valid() && script_type->is_valid()) {
-		return GDScript::debug_get_script_name(script_type);
+		result = GDScript::debug_get_script_name(script_type);
 	} else if (native_type != StringName()) {
-		return native_type.operator String();
+		result = native_type.operator String();
 	} else {
-		return Variant::get_type_name(builtin_type);
+		result = Variant::get_type_name(builtin_type);
 	}
+	if (is_nullable) {
+		result += "?";
+	}
+	return result;
 }
 
 static String _get_var_type(const Variant *p_var) {
@@ -88,7 +93,7 @@ static String _get_var_type(const Variant *p_var) {
 			const Array *p_array = VariantInternal::get_array(p_var);
 			Variant::Type builtin_type = (Variant::Type)p_array->get_typed_builtin();
 			if (builtin_type != Variant::NIL) {
-				basestr += "[" + _get_element_type(builtin_type, p_array->get_typed_class_name(), p_array->get_typed_script()) + "]";
+				basestr += "[" + _get_element_type(builtin_type, p_array->get_typed_class_name(), p_array->get_typed_script(), p_array->is_nullable()) + "]";
 			}
 		} else {
 			basestr = Variant::get_type_name(p_var->get_type());
@@ -276,6 +281,8 @@ void (*type_init_function_table[])(Variant *) = {
 		&&OPCODE_JUMP_IF_NOT,                            \
 		&&OPCODE_JUMP_TO_DEF_ARGUMENT,                   \
 		&&OPCODE_JUMP_IF_SHARED,                         \
+		&&OPCODE_JUMP_IF_NULL,                           \
+		&&OPCODE_EXIT_IF_NULL,                           \
 		&&OPCODE_RETURN,                                 \
 		&&OPCODE_RETURN_TYPED_BUILTIN,                   \
 		&&OPCODE_RETURN_TYPED_ARRAY,                     \
@@ -1341,7 +1348,8 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			DISPATCH_OPCODE;
 
 			OPCODE(OPCODE_ASSIGN_TYPED_ARRAY) {
-				CHECK_SPACE(6);
+				CHECK_SPACE(7);
+
 				GET_VARIANT_PTR(dst, 0);
 				GET_VARIANT_PTR(src, 1);
 
@@ -1350,28 +1358,29 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				int native_type_idx = _code_ptr[ip + 5];
 				GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
 				const StringName native_type = _global_names_ptr[native_type_idx];
+				bool is_nullable = _code_ptr[ip + 6];
 
 				if (src->get_type() != Variant::ARRAY) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to assign a value of type "%s" to a variable of type "Array[%s]".)",
-							_get_var_type(src), _get_element_type(builtin_type, native_type, *script_type));
+							_get_var_type(src), _get_element_type(builtin_type, native_type, *script_type, is_nullable));
 #endif // DEBUG_ENABLED
 					OPCODE_BREAK;
 				}
 
 				Array *array = VariantInternal::get_array(src);
 
-				if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type) {
+				if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type || (array->is_nullable() && !is_nullable)) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to assign an array of type "%s" to a variable of type "Array[%s]".)",
-							_get_var_type(src), _get_element_type(builtin_type, native_type, *script_type));
+							_get_var_type(src), _get_element_type(builtin_type, native_type, *script_type, is_nullable));
 #endif // DEBUG_ENABLED
 					OPCODE_BREAK;
 				}
 
 				*dst = *src;
 
-				ip += 6;
+				ip += 7;
 			}
 			DISPATCH_OPCODE;
 
@@ -1651,7 +1660,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 			OPCODE(OPCODE_CONSTRUCT_TYPED_ARRAY) {
 				LOAD_INSTRUCTION_ARGS
-				CHECK_SPACE(3 + instr_arg_count);
+				CHECK_SPACE(4 + instr_arg_count);
 				ip += instr_arg_count;
 
 				int argc = _code_ptr[ip + 1];
@@ -1661,6 +1670,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				int native_type_idx = _code_ptr[ip + 3];
 				GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
 				const StringName native_type = _global_names_ptr[native_type_idx];
+				bool is_nullable = _code_ptr[ip + 4];
 
 				Array array;
 				array.resize(argc);
@@ -1671,9 +1681,9 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				GET_INSTRUCTION_ARG(dst, argc);
 				*dst = Variant(); // Clear potential previous typed array.
 
-				*dst = Array(array, builtin_type, native_type, *script_type);
+				*dst = Array(array, builtin_type, native_type, *script_type, is_nullable);
 
-				ip += 4;
+				ip += 5;
 			}
 			DISPATCH_OPCODE;
 
@@ -2568,6 +2578,56 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			}
 			DISPATCH_OPCODE;
 
+			OPCODE(OPCODE_JUMP_IF_NULL) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(src, 0);
+				GET_VARIANT_PTR(dst, 1);
+
+				bool should_skip = false;
+				if (src->get_type() == Variant::NIL) {
+					should_skip = true;
+				} else if (src->get_type() == Variant::OBJECT) {
+					Object *obj = src->get_validated_object_with_check(should_skip);
+					should_skip |= obj == nullptr;
+				}
+
+				if (should_skip) {
+					*dst = Variant();
+					int to = _code_ptr[ip + 3];
+					GD_ERR_BREAK(to < 0 || to > _code_size);
+					ip = to;
+				} else {
+					ip += 4;
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_EXIT_IF_NULL) {
+				CHECK_SPACE(2);
+
+				GET_VARIANT_PTR(src, 0);
+
+				bool should_skip = false;
+				if (src->get_type() == Variant::NIL) {
+					should_skip = true;
+				} else if (src->get_type() == Variant::OBJECT) {
+					Object *obj = src->get_validated_object_with_check(should_skip);
+					should_skip |= obj == nullptr;
+				}
+
+				if (should_skip) {
+					retvalue = Variant();
+#ifdef DEBUG_ENABLED
+					exit_ok = true;
+#endif
+					OPCODE_BREAK;
+				}
+
+				ip += 2;
+			}
+			DISPATCH_OPCODE;
+
 			OPCODE(OPCODE_RETURN) {
 				CHECK_SPACE(2);
 				GET_VARIANT_PTR(r, 0);
@@ -2610,7 +2670,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			}
 
 			OPCODE(OPCODE_RETURN_TYPED_ARRAY) {
-				CHECK_SPACE(5);
+				CHECK_SPACE(6);
 				GET_VARIANT_PTR(r, 0);
 
 				GET_VARIANT_PTR(script_type, 1);
@@ -2618,21 +2678,22 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				int native_type_idx = _code_ptr[ip + 4];
 				GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
 				const StringName native_type = _global_names_ptr[native_type_idx];
+				bool is_nullable = _code_ptr[ip + 5];
 
 				if (r->get_type() != Variant::ARRAY) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "Array[%s]".)",
-							Variant::get_type_name(r->get_type()), Variant::get_type_name(builtin_type));
+							_get_var_type(r), _get_element_type(builtin_type, native_type, *script_type, is_nullable));
 #endif
 					OPCODE_BREAK;
 				}
 
 				Array *array = VariantInternal::get_array(r);
 
-				if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type) {
+				if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type || (array->is_nullable() && !is_nullable)) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to return an array of type "%s" where expected return type is "Array[%s]".)",
-							_get_var_type(r), _get_element_type(builtin_type, native_type, *script_type));
+							_get_var_type(r), _get_element_type(builtin_type, native_type, *script_type, is_nullable));
 #endif // DEBUG_ENABLED
 					OPCODE_BREAK;
 				}
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.gd
new file mode 100644
index 000000000000..23176dc439e2
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.gd
@@ -0,0 +1,5 @@
+class A:
+    var b: A?
+func test():
+    var foo := A.new()
+    foo?.b.b
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.out
new file mode 100644
index 000000000000..05f5ed7717fc
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foo?.b" with attribute "b".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.gd
new file mode 100644
index 000000000000..465f1f6afcd0
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.gd
@@ -0,0 +1,8 @@
+class A:
+    var b: A?
+    var c: String?
+    func banana():
+        pass
+func test():
+    var foo := A.new()
+    foo.c?[0].begins_with("")
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.out
new file mode 100644
index 000000000000..0c85ed45e0e8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_index.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "foo.c?[0]" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.gd
new file mode 100644
index 000000000000..bdec4590f74b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.gd
@@ -0,0 +1,7 @@
+class A:
+    var b: A?
+    func banana():
+        pass
+func test():
+    var foo := A.new()
+    foo?.b.banana()
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.out
new file mode 100644
index 000000000000..e447386f5d6b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_access_operator_method_call.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "foo?.b" to call "banana()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.gd
new file mode 100644
index 000000000000..11b3d28b5645
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.gd
@@ -0,0 +1,3 @@
+func test():
+    var foo: Array[int]? = [1, 2]
+    var bar: Array[int] = foo
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.out
new file mode 100644
index 000000000000..8f5232fa39e5
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to assign nullable "foo" to non-nullable "bar".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.gd
new file mode 100644
index 000000000000..030209d6b67e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.gd
@@ -0,0 +1,6 @@
+func _get_result() -> Array[String]?:
+    var arr: Array[String]? = null
+    return arr
+
+func test():
+    var dict: Array[String] = _get_result()
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.out
new file mode 100644
index 000000000000..422d2cb6c835
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_assignment_to_non_nullable_from_method_return.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to assign the nullable return of "_get_result()" to non-nullable "dict".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.gd
new file mode 100644
index 000000000000..bf60ba182a85
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.gd
@@ -0,0 +1,6 @@
+class A:
+    var foo: String = "bar"
+
+func test():
+    var foo: A? = null
+    foo.foo
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.out
new file mode 100644
index 000000000000..2326ac1cfbaf
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foo" with attribute "foo".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.gd
new file mode 100644
index 000000000000..d57f429dbffe
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.gd
@@ -0,0 +1,9 @@
+class B:
+    var bar
+
+class A:
+    var foo: B?
+
+func test():
+    var foobar: A = A.new()
+    foobar.foo.bar
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.out
new file mode 100644
index 000000000000..d877c2ff90fe
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_attribute_access_nested.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foo" with attribute "bar".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.gd
new file mode 100644
index 000000000000..a88a6fc89331
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.gd
@@ -0,0 +1,3 @@
+func test():
+    var foo: int? = null
+    print(foo + 1) # Should error
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.out
new file mode 100644
index 000000000000..953d45868ba1
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable left-side operand, of type "int?", to be used with the "+" operator.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.gd
new file mode 100644
index 000000000000..0822e72fecae
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: int? = null
+    var bar: int? = null
+    print(foo + bar) # Should error
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.out
new file mode 100644
index 000000000000..d294f31e6b50
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_binary_operator_both_operands.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Both operands for the "+" operator are nullable and as such, might be unsafe to be operated together.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.gd
new file mode 100644
index 000000000000..8e5d01f24bed
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.gd
@@ -0,0 +1,6 @@
+class A:
+    var foo: String = ""
+func test():
+    var nullable_instance: A? = null
+    (nullable_instance as A).foo # Should not error
+    (nullable_instance as A?).foo # Should Error
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.out
new file mode 100644
index 000000000000..4ff3ab321401
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_attribute_access.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable cast expression "nullable_instance as A?" with attribute "foo".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.gd
new file mode 100644
index 000000000000..3a96991812a3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.gd
@@ -0,0 +1,4 @@
+func test():
+    var nullable_string: String? = null
+    (nullable_string as String).begins_with("") # Should not error
+    (nullable_string as String?).begins_with("") # Should error
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.out
new file mode 100644
index 000000000000..d22348dfdfa6
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_cast_method_call.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable cast expression "nullable_string as String?" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.gd
new file mode 100644
index 000000000000..5a6b2965f397
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.gd
@@ -0,0 +1,5 @@
+var foo: String? = null
+
+
+func test():
+    print(foo.begins_with("")) # Should error
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.out
new file mode 100644
index 000000000000..843de8ebb4bb
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_class_member.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "foo" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.gd
new file mode 100644
index 000000000000..3597d3d9a37e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.gd
@@ -0,0 +1,8 @@
+func test():
+    var nullable_string: String? = null
+    if nullable_string == "2134":
+        print(nullable_string.begins_with("asd")) # safe
+    elif nullable_string == null:
+        print(nullable_string.begins_with("asd")) # Not safe
+    else:
+        print(nullable_string.begins_with("asd")) # safe
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.out
new file mode 100644
index 000000000000..30f7463df041
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_elif_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "nullable_string" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.gd
new file mode 100644
index 000000000000..58f37db7319f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.gd
@@ -0,0 +1,6 @@
+func test():
+    for element in nullable_array(): # Should error
+        print(element)
+
+func nullable_array() -> Array?:
+    return null
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.out
new file mode 100644
index 000000000000..c519603f1c08
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_call.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable return of "nullable_array()" to be used in a for-loop.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.gd
new file mode 100644
index 000000000000..18426809914e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.gd
@@ -0,0 +1,4 @@
+func test():
+    var nullable_array: Array? = []
+    for element in nullable_array: # Should error
+        print(element)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.out
new file mode 100644
index 000000000000..b993f6d44c88
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_identifier.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "nullable_array" to be used in a for-loop.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.gd
new file mode 100644
index 000000000000..d95a87f34459
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.gd
@@ -0,0 +1,6 @@
+class A:
+    var arr: Array? = null
+func test():
+    var instance := A.new()
+    for element in instance.arr: # Should error
+        print(element)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.out
new file mode 100644
index 000000000000..9b644f2b3eda
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_for_on_subscript.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable expression "instance.arr" to be used in a for-loop.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.gd
new file mode 100644
index 000000000000..6da87fe5d7af
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.gd
@@ -0,0 +1,5 @@
+class A:
+    var b: String
+func test():
+    var a: A? = A.new()
+    a?.b = "123"
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.out
new file mode 100644
index 000000000000..67f37537772d
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_forbid_assigment_with_nullable_access_operator.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+The left-hand side of an assignment expression may not contain a nullable access operator ("?.").
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.gd
new file mode 100644
index 000000000000..da4d018d33b8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.gd
@@ -0,0 +1,3 @@
+func test():
+    var foo: Array[int]? = []
+    foo[0]
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.out
new file mode 100644
index 000000000000..03b9a2011dc3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foo" with index "0".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.gd
new file mode 100644
index 000000000000..8c5d474667f4
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.gd
@@ -0,0 +1,9 @@
+class B:
+    var bar
+
+class A:
+    var foo: B?
+
+func test():
+    var foobar: Array[A?] = [A.new()]
+    foobar[0].bar
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.out
new file mode 100644
index 000000000000..a75ddcfed0a1
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foobar[0]" with attribute "bar".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.gd
new file mode 100644
index 000000000000..e80d304421f9
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.gd
@@ -0,0 +1,8 @@
+class A:
+    var foo := A.new()
+    func nullable_return() -> String?:
+        return null
+
+func test():
+    var foobar := A.new()
+    foobar.foo.nullable_return()[0]
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.out
new file mode 100644
index 000000000000..ac18f64d1b84
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_nested_on_nullable_return.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable return of "nullable_return()" to be indexed with "0".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.gd
new file mode 100644
index 000000000000..da89a1261117
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: String? = null
+    var nullable_index: int? = null
+    foo[nullable_index]
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.out
new file mode 100644
index 000000000000..711f14d7629b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_index_access_with_nullable.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to use nullable "nullable_index" as an index.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.gd
new file mode 100644
index 000000000000..783ccca7a2e0
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.gd
@@ -0,0 +1,5 @@
+func test():
+    var foo: Array[int]? = null
+    foo = [1]
+    if is_instance_of(foo, TYPE_NIL):
+        print(foo[0])
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.out
new file mode 100644
index 000000000000..03b9a2011dc3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_is_instance_of.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe to access nullable "foo" with index "0".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.gd
new file mode 100644
index 000000000000..7564886538f6
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.gd
@@ -0,0 +1,7 @@
+func test():
+    var nullable_string: String? = null
+    match nullable_string:
+        "123":
+            print(nullable_string.begins_with("1")) # This is safe
+        null:
+            print(nullable_string.begins_with("asd")) # This is not
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.out
new file mode 100644
index 000000000000..30f7463df041
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_match_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "nullable_string" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.gd
new file mode 100644
index 000000000000..b1f6c4cb9693
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.gd
@@ -0,0 +1,7 @@
+class A:
+    func bar():
+        pass
+
+func test():
+    var foo: A? = null
+    foo.bar()
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.out
new file mode 100644
index 000000000000..4dd09534e2aa
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "foo" to call "bar()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.gd
new file mode 100644
index 000000000000..d09a64f91390
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.gd
@@ -0,0 +1,10 @@
+class B:
+    func hey():
+        pass
+
+class A:
+    var b: B?
+
+func test():
+    var foo: A = A.new()
+    foo.b.hey()
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.out
new file mode 100644
index 000000000000..b4a429b4099e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "b" to call "hey()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.gd
new file mode 100644
index 000000000000..2cb4928fa94e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.gd
@@ -0,0 +1,10 @@
+class B:
+    func hey():
+        pass
+
+class A:
+    var b: B?
+
+func test():
+    var foo: Array[A?] = [A.new()]
+    foo[0].hey()
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.out
new file mode 100644
index 000000000000..779c0bc40cb6
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_index.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "foo[0]" to call "hey()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.gd
new file mode 100644
index 000000000000..45535eaf20b7
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.gd
@@ -0,0 +1,9 @@
+class A:
+    var bar: String? = null
+    var baz: A? = null
+    var barz: A = null
+    func get_baz() -> A?:
+        return null
+func test():
+    var foo: A = null
+    foo.barz.get_baz().bar
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.out
new file mode 100644
index 000000000000..414ce42db5b8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_call_nested_on_nullable_return.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable return of "get_baz()" to access "bar".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.gd
new file mode 100644
index 000000000000..ef8be16756ce
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.gd
@@ -0,0 +1,7 @@
+func test():
+    print(_get_result())
+
+
+func _get_result() -> String:
+    var might_be_null: String? = null
+    return might_be_null
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.out
new file mode 100644
index 000000000000..4a53fbd15213
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_method_return.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Cannot return nullable value of type "String?" because the function return type is "String".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.gd
new file mode 100644
index 000000000000..5c173da709b8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.gd
@@ -0,0 +1,6 @@
+func test():
+    var foo: int? = null
+    if foo: # narrow
+        var bar: int = foo # explicit
+        bar = foo
+        print(bar)
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowed_assignment.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.gd
new file mode 100644
index 000000000000..ec8cbe1046ff
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: int? = 5
+    if !foo:
+        print(foo + 1) # Should error
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.out
new file mode 100644
index 000000000000..953d45868ba1
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable left-side operand, of type "int?", to be used with the "+" operator.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.gd
new file mode 100644
index 000000000000..61dbacbd1321
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.gd
@@ -0,0 +1,7 @@
+func test():
+    var bar: String? = ""
+    foo(bar, bar)
+
+
+func foo(a: String?, b: String):
+    prints(a, b)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.out
new file mode 100644
index 000000000000..8d6e3feaa66c
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_parameters.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Invalid argument for "foo()" function: argument 2 must not be null, but "String?" is nullable.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.gd
new file mode 100644
index 000000000000..7fe2a943222d
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.gd
@@ -0,0 +1,2 @@
+func test():
+    var input: InputMap? = InputMap # Should error
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.out
new file mode 100644
index 000000000000..361a4c0514ca
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_qualifier_forbidden_for_native_types.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Cannot assign a value of type GDScriptNativeClass to variable "input" with specified type InputMap?.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.gd
new file mode 100644
index 000000000000..e94424de9bde
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.gd
@@ -0,0 +1,6 @@
+func test():
+    print(foo().begins_with("")) # Should error
+
+
+func foo() -> String?:
+    return null
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.out
new file mode 100644
index 000000000000..70fb304feb05
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable return of "foo" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.gd
new file mode 100644
index 000000000000..c6da3eba92b2
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.gd
@@ -0,0 +1,8 @@
+func test():
+    non_nullable_return()
+
+func non_nullable_return() -> Vector2:
+    return nullable_return() # Should error
+
+func nullable_return() -> Vector2?:
+    return null
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.out
new file mode 100644
index 000000000000..6d1843f83ea8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_return_on_non_nullable_method.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Cannot return nullable value of type "Vector2?" because the function return type is "Vector2".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.gd
new file mode 100644
index 000000000000..fde3640ac1cf
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.gd
@@ -0,0 +1,8 @@
+class A:
+    var index: int?
+    func get_nullable_instance() -> A?:
+        return A.new()
+func test():
+    var foo: Array[Array] = [[]]
+    var a_instance := A.new()
+    foo[0][a_instance.get_nullable_instance()?.index]
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.out
new file mode 100644
index 000000000000..d913a0780d56
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_subscript_as_index.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for the nullable expression "a_instance.get_nullable_instance()?.index" to be used as an index.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.gd
new file mode 100644
index 000000000000..a75bb3429894
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.gd
@@ -0,0 +1,3 @@
+func test():
+    var foo: int? = null
+    (foo if true else 0) + 1 # Should error
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.out
new file mode 100644
index 000000000000..953d45868ba1
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_ternary.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable left-side operand, of type "int?", to be used with the "+" operator.
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.gd
new file mode 100644
index 000000000000..b902a7fcd0f8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.gd
@@ -0,0 +1,7 @@
+func test():
+    var bar := foo()
+    print(bar.begins_with("")) # Should error
+
+
+func foo() -> String?:
+    return null
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.out
new file mode 100644
index 000000000000..4fbf8538d72e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_type_inference.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable "bar" to call "begins_with()".
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.gd
new file mode 100644
index 000000000000..e566f02947a4
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.gd
@@ -0,0 +1,4 @@
+func test():
+    var input: int? = null
+    while !input:
+        input -= 1 # Should error
diff --git a/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.out b/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.out
new file mode 100644
index 000000000000..452dd198ec9e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/errors/nullable_while_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Potentially unsafe for nullable left-side operand, of type "int?", to be used with the "-" operator.
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.gd
new file mode 100644
index 000000000000..542cd64a071f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.gd
@@ -0,0 +1,5 @@
+func test():
+    var x: int? = 1
+    var y: int? = 1
+    if x and y:
+        print(x + y)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.out
new file mode 100644
index 000000000000..d5e2d977b083
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_and_binary_operator_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+2
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.gd
new file mode 100644
index 000000000000..38bdfa2ced5a
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.gd
@@ -0,0 +1,5 @@
+func test():
+    var nullable_string: String? = "123"
+    print((nullable_string as String).begins_with("1"))
+    nullable_string = null
+    print((nullable_string as String?)?.begins_with("1"))
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.out
new file mode 100644
index 000000000000..2a62816a5447
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast.out
@@ -0,0 +1,3 @@
+GDTEST_OK
+true
+<null>
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.gd
new file mode 100644
index 000000000000..6458fa839a19
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.gd
@@ -0,0 +1,4 @@
+func test():
+    var nullable_string: String? = "123"
+    if (nullable_string as String) == "123":
+        print(nullable_string.begins_with("123")) # Should not error
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.out
new file mode 100644
index 000000000000..55482c2b52ef
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_cast_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+true
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.gd
new file mode 100644
index 000000000000..8563fca6b97b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.gd
@@ -0,0 +1,3 @@
+func test():
+    var nullable_int: int? = null
+    print(nullable_int ?? 123)
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.out
new file mode 100644
index 000000000000..b8d6b089cc6b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+123
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.gd
new file mode 100644
index 000000000000..73f7963fa081
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.gd
@@ -0,0 +1,3 @@
+func test():
+    var nullable_str: String? = null
+    print((nullable_str ?? "123").begins_with("123"))
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.out
new file mode 100644
index 000000000000..55482c2b52ef
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_coalesce_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+true
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.gd
new file mode 100644
index 000000000000..1f198adfe3f8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.gd
@@ -0,0 +1,9 @@
+class B:
+    var idx := 0
+class A:
+    var a: B? = B.new()
+func test():
+    var foo := A.new()
+    if foo.a:
+        for i in foo.a?.idx:
+            print(i)
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_complex_narrowing.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.gd
new file mode 100644
index 000000000000..6da127cde09f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.gd
@@ -0,0 +1,6 @@
+func test():
+    var arr: Array? = null
+    if is_instance_of(arr, TYPE_ARRAY):
+        print(arr)
+    else:
+        print("arr is null")
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.out
new file mode 100644
index 000000000000..5c2514b0ec67
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_of.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+arr is null
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.gd
new file mode 100644
index 000000000000..5c5f0765028f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: String? = null
+    if is_instance_valid(foo):
+        print(foo.begins_with(""))
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_instance_valid.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.gd
new file mode 100644
index 000000000000..40a604dc5ddc
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: String? = null
+    if is_same(foo, ""):
+        print(foo.begins_with(""))
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_is_same.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.gd
new file mode 100644
index 000000000000..39c0c25b3065
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.gd
@@ -0,0 +1,13 @@
+func test():
+    var nullable_string: String? = null
+    match nullable_string:
+        "123", "13":
+            print(nullable_string.begins_with("1"))
+        {}:
+            print(nullable_string.begins_with("1"))
+        []:
+            print(nullable_string.begins_with("1"))
+        null:
+            prints("Nullable is null! Proof: ", nullable_string)
+        var nullable:
+            prints("Nullable is null! Proof: ", nullable)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.out
new file mode 100644
index 000000000000..2edc53361966
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_match_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+Nullable is null! Proof:  <null>
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.gd
new file mode 100644
index 000000000000..98a1c6091381
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.gd
@@ -0,0 +1,8 @@
+func test():
+    print(_get_result())
+
+
+func _get_result() -> Array[int]:
+    var might_be_null: Array[int?] = []
+    return might_be_null
+
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.out
new file mode 100644
index 000000000000..38eadc22fa8f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_container_type.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+Cannot return nullable value of type "Array[int?]" because the function return type is "Array[int]".
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.gd
new file mode 100644
index 000000000000..4ab8802f1e7b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.gd
@@ -0,0 +1,9 @@
+func test():
+    print(_get_result())
+
+
+func _get_result() -> String:
+    var might_be_null: String? = null
+    if might_be_null:
+        return might_be_null
+    return "123"
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.out
new file mode 100644
index 000000000000..b8d6b089cc6b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_method_return_with_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+123
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.gd
new file mode 100644
index 000000000000..28c24174152d
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.gd
@@ -0,0 +1,5 @@
+func test():
+    var foo: int? = 5
+    if foo != null:
+        for i in foo:
+            print(i)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.out
new file mode 100644
index 000000000000..b4a50885c746
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_nested_narrowing.out
@@ -0,0 +1,6 @@
+GDTEST_OK
+0
+1
+2
+3
+4
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.gd
new file mode 100644
index 000000000000..43c6cc94c13b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.gd
@@ -0,0 +1,11 @@
+var foo: String?:
+	set(value):
+		print("tried setting")
+		foo = value
+	get:
+		print("tried getting")
+		return foo
+
+func test():
+	foo = null
+	print("ok" if foo == null else "nok")
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.out
new file mode 100644
index 000000000000..4b40f9209843
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_setter_getter.out
@@ -0,0 +1,4 @@
+GDTEST_OK
+tried setting
+tried getting
+ok
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.gd
new file mode 100644
index 000000000000..5ef865fb4655
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.gd
@@ -0,0 +1,4 @@
+func test():
+    var foo: int? = 1
+    var result := (foo if foo else 123) + 1 # Should be okay
+    print(result)
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.out
new file mode 100644
index 000000000000..d5e2d977b083
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_ternary_narrowing.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+2
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.gd
new file mode 100644
index 000000000000..3938e8df80ce
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.gd
@@ -0,0 +1,5 @@
+func test():
+    var foo: Array[int]? = null
+    foo = [1]
+    if foo is Array:
+        print(foo[0])
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.out
new file mode 100644
index 000000000000..a7f1357bb23c
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_type_test.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+1
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.gd
new file mode 100644
index 000000000000..d208196c35e8
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.gd
@@ -0,0 +1,14 @@
+func test():
+    var ok := 0
+    var foo: int? = null
+    if foo == null:
+        print("it's null!")
+        ok += 1
+
+    foo = 123
+    if foo != null:
+        print(-foo)
+        ok += 1
+
+    if ok == 2:
+        print("Ok")
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.out
new file mode 100644
index 000000000000..729fd1030a37
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_unary_operator.out
@@ -0,0 +1,4 @@
+GDTEST_OK
+it's null!
+-123
+Ok
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.gd
new file mode 100644
index 000000000000..b31439b2296c
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.gd
@@ -0,0 +1,4 @@
+## Ensure we can pass nullable arguments to functions which expect a Variant
+func test():
+    var foo: String? = null
+    print(is_instance_valid(foo))
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.out
new file mode 100644
index 000000000000..44302c81378b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_variant_parameter.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+false
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.gd b/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.gd
new file mode 100644
index 000000000000..2100e5435b6c
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.gd
@@ -0,0 +1,4 @@
+func test():
+    var input: int? = null
+    while input:
+        input -= 1 # Should not error
diff --git a/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.out b/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/analyzer/features/nullable_while_narrowing.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.gd b/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.gd
new file mode 100644
index 000000000000..02eaa31202a5
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.gd
@@ -0,0 +1,2 @@
+func test():
+    const CONSTANT: String? = null # Should error
diff --git a/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.out b/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.out
new file mode 100644
index 000000000000..4b7544e46f01
--- /dev/null
+++ b/modules/gdscript/tests/scripts/parser/errors/nullable_qualifier_forbidden_for_constants.out
@@ -0,0 +1,2 @@
+GDTEST_PARSER_ERROR
+Nullable qualifier ("?") not allowed in this context
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.gd b/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.gd
new file mode 100644
index 000000000000..12c81e55e802
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.gd
@@ -0,0 +1,4 @@
+func test():
+    var node := Node.new()
+    node.free()
+    print(node?.get_parent())
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.out b/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.out
new file mode 100644
index 000000000000..f0c83a69b348
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_access_on_freed_instance.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+<null>
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.gd b/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.gd
new file mode 100644
index 000000000000..f6b416ec0c72
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.gd
@@ -0,0 +1,10 @@
+func test():
+    # OK
+    var object: Object = null
+    # Potentially unsafe to assign the nullable return of "nullable_object_func()" to non-nullable "object".
+    object = nullable_object_func()
+    # Value of type "Object" cannot be assigned to a variable of type "Object".
+    object = nullable_object_func() ?? null
+    print(object)
+func nullable_object_func() -> Object?:
+    return null
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.out b/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.out
new file mode 100644
index 000000000000..f0c83a69b348
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_assignment_with_object.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+<null>
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.gd b/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.gd
new file mode 100644
index 000000000000..dfd4a80cebb3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.gd
@@ -0,0 +1,5 @@
+func test():
+    var nullable_node: Node2D? = null
+    # Potentially unsafe access.
+    if is_instance_valid(nullable_node) and nullable_node.name == &"Node":
+        print(nullable_node)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.out b/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_binary_op_short_circuit.out
@@ -0,0 +1 @@
+GDTEST_OK
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.gd b/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.gd
new file mode 100644
index 000000000000..a5d2293e2ad7
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.gd
@@ -0,0 +1,6 @@
+func test():
+    var node := Node.new()
+    node.free()
+    node = node ?? Node.new()
+    print(node?.get_parent())
+    node.free()
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.out b/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.out
new file mode 100644
index 000000000000..90c0e225d258
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_coalescing_on_freed_instance.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+<Object#null>
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.gd b/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.gd
new file mode 100644
index 000000000000..3b2b4ff305aa
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.gd
@@ -0,0 +1,7 @@
+func some_func(position: Vector2) -> void:
+    print(position)
+func test():
+    var nullable_node: Node2D? = null
+    if nullable_node != null:
+        # Invalid argument for "some_func()" function: argument 1 must not be null, but "Vector2?" is nullable.
+        some_func(nullable_node.position)
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.out b/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.out
new file mode 100644
index 000000000000..d73c5eb7cde3
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/features/nullable_implicit_narrowing_with_function_parameter.out
@@ -0,0 +1 @@
+GDTEST_OK