Use RequiredParam and RequiredValue in a handful of places in order to test

dsnopek · dsnopek · commit 6bab68dfaf1e · 2025-10-16T09:44:51.000-05:00
diff --git a/core/io/resource_saver.cpp b/core/io/resource_saver.cpp
@@ -97,8 +97,8 @@ void ResourceFormatSaver::_bind_methods() {
 	GDVIRTUAL_BIND(_recognize_path, "resource", "path");
 }
 
-Error ResourceSaver::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {
-	ERR_FAIL_COND_V_MSG(p_resource.is_null(), ERR_INVALID_PARAMETER, vformat("Can't save empty resource to path '%s'.", p_path));
+Error ResourceSaver::save(const RequiredParam<Resource> &rp_resource, const String &p_path, uint32_t p_flags) {
+	EXTRACT_REQUIRED_PTR_OR_FAIL_V_MSG(p_resource, rp_resource, ERR_INVALID_PARAMETER, vformat("Can't save empty resource to path '%s'.", p_path));
 	String path = p_path;
 	if (path.is_empty()) {
 		path = p_resource->get_path();
diff --git a/core/io/resource_saver.h b/core/io/resource_saver.h
@@ -83,7 +83,7 @@ class ResourceSaver {
 		FLAG_REPLACE_SUBRESOURCE_PATHS = 64,
 	};
 
-	static Error save(const Ref<Resource> &p_resource, const String &p_path = "", uint32_t p_flags = (uint32_t)FLAG_NONE);
+	static Error save(const RequiredParam<Resource> &p_resource, const String &p_path = "", uint32_t p_flags = (uint32_t)FLAG_NONE);
 	static void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions);
 	static void add_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver, bool p_at_front = false);
 	static void remove_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver);
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
@@ -95,7 +95,7 @@ void Tween::_stop_internal(bool p_reset) {
 	}
 }
 
-Ref<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration) {
+RequiredValue<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration) {
 	ERR_FAIL_NULL_V(p_target, nullptr);
 	CHECK_VALID();
 
@@ -118,7 +118,7 @@ Ref<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePat
 	return tweener;
 }
 
-Ref<IntervalTweener> Tween::tween_interval(double p_time) {
+RequiredValue<IntervalTweener> Tween::tween_interval(double p_time) {
 	CHECK_VALID();
 
 	Ref<IntervalTweener> tweener;
@@ -127,7 +127,7 @@ Ref<IntervalTweener> Tween::tween_interval(double p_time) {
 	return tweener;
 }
 
-Ref<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {
+RequiredValue<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {
 	CHECK_VALID();
 
 	Ref<CallbackTweener> tweener;
@@ -136,7 +136,7 @@ Ref<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {
 	return tweener;
 }
 
-Ref<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration) {
+RequiredValue<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration) {
 	CHECK_VALID();
 
 	if (!Animation::validate_type_match(p_from, p_to)) {
@@ -149,7 +149,7 @@ Ref<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant
 	return tweener;
 }
 
-Ref<SubtweenTweener> Tween::tween_subtween(const Ref<Tween> &p_subtween) {
+RequiredValue<SubtweenTweener> Tween::tween_subtween(const Ref<Tween> &p_subtween) {
 	CHECK_VALID();
 
 	// Ensure that the subtween being added is not null.
@@ -221,15 +221,15 @@ void Tween::clear() {
 	tweeners.clear();
 }
 
-Ref<Tween> Tween::bind_node(const Node *p_node) {
+RequiredValue<Tween> Tween::bind_node(const Node *p_node) {
 	ERR_FAIL_NULL_V(p_node, this);
 
 	bound_node = p_node->get_instance_id();
 	is_bound = true;
 	return this;
 }
 
-Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {
+RequiredValue<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {
 	process_mode = p_mode;
 	return this;
 }
@@ -238,7 +238,7 @@ Tween::TweenProcessMode Tween::get_process_mode() const {
 	return process_mode;
 }
 
-Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {
+RequiredValue<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {
 	pause_mode = p_mode;
 	return this;
 }
@@ -247,7 +247,7 @@ Tween::TweenPauseMode Tween::get_pause_mode() const {
 	return pause_mode;
 }
 
-Ref<Tween> Tween::set_ignore_time_scale(bool p_ignore) {
+RequiredValue<Tween> Tween::set_ignore_time_scale(bool p_ignore) {
 	ignore_time_scale = p_ignore;
 	return this;
 }
@@ -256,13 +256,13 @@ bool Tween::is_ignoring_time_scale() const {
 	return ignore_time_scale;
 }
 
-Ref<Tween> Tween::set_parallel(bool p_parallel) {
+RequiredValue<Tween> Tween::set_parallel(bool p_parallel) {
 	default_parallel = p_parallel;
 	parallel_enabled = p_parallel;
 	return this;
 }
 
-Ref<Tween> Tween::set_loops(int p_loops) {
+RequiredValue<Tween> Tween::set_loops(int p_loops) {
 	loops = p_loops;
 	return this;
 }
@@ -275,12 +275,12 @@ int Tween::get_loops_left() const {
 	}
 }
 
-Ref<Tween> Tween::set_speed_scale(float p_speed) {
+RequiredValue<Tween> Tween::set_speed_scale(float p_speed) {
 	speed_scale = p_speed;
 	return this;
 }
 
-Ref<Tween> Tween::set_trans(TransitionType p_trans) {
+RequiredValue<Tween> Tween::set_trans(TransitionType p_trans) {
 	default_transition = p_trans;
 	return this;
 }
@@ -289,7 +289,7 @@ Tween::TransitionType Tween::get_trans() const {
 	return default_transition;
 }
 
-Ref<Tween> Tween::set_ease(EaseType p_ease) {
+RequiredValue<Tween> Tween::set_ease(EaseType p_ease) {
 	default_ease = p_ease;
 	return this;
 }
@@ -298,12 +298,12 @@ Tween::EaseType Tween::get_ease() const {
 	return default_ease;
 }
 
-Ref<Tween> Tween::parallel() {
+RequiredValue<Tween> Tween::parallel() {
 	parallel_enabled = true;
 	return this;
 }
 
-Ref<Tween> Tween::chain() {
+RequiredValue<Tween> Tween::chain() {
 	parallel_enabled = false;
 	return this;
 }
@@ -554,7 +554,7 @@ double PropertyTweener::_get_custom_interpolated_value(const Variant &p_value) {
 	return result;
 }
 
-Ref<PropertyTweener> PropertyTweener::from(const Variant &p_value) {
+RequiredValue<PropertyTweener> PropertyTweener::from(const Variant &p_value) {
 	Ref<Tween> tween = _get_tween();
 	ERR_FAIL_COND_V(tween.is_null(), nullptr);
 
@@ -568,32 +568,32 @@ Ref<PropertyTweener> PropertyTweener::from(const Variant &p_value) {
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::from_current() {
+RequiredValue<PropertyTweener> PropertyTweener::from_current() {
 	do_continue = false;
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::as_relative() {
+RequiredValue<PropertyTweener> PropertyTweener::as_relative() {
 	relative = true;
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {
+RequiredValue<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {
 	trans_type = p_trans;
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {
+RequiredValue<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {
 	ease_type = p_ease;
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::set_custom_interpolator(const Callable &p_method) {
+RequiredValue<PropertyTweener> PropertyTweener::set_custom_interpolator(const Callable &p_method) {
 	custom_method = p_method;
 	return this;
 }
 
-Ref<PropertyTweener> PropertyTweener::set_delay(double p_delay) {
+RequiredValue<PropertyTweener> PropertyTweener::set_delay(double p_delay) {
 	delay = p_delay;
 	return this;
 }
@@ -731,7 +731,7 @@ IntervalTweener::IntervalTweener() {
 	ERR_FAIL_MSG("IntervalTweener can't be created directly. Use the tween_interval() method in Tween.");
 }
 
-Ref<CallbackTweener> CallbackTweener::set_delay(double p_delay) {
+RequiredValue<CallbackTweener> CallbackTweener::set_delay(double p_delay) {
 	delay = p_delay;
 	return this;
 }
@@ -781,17 +781,17 @@ CallbackTweener::CallbackTweener() {
 	ERR_FAIL_MSG("CallbackTweener can't be created directly. Use the tween_callback() method in Tween.");
 }
 
-Ref<MethodTweener> MethodTweener::set_delay(double p_delay) {
+RequiredValue<MethodTweener> MethodTweener::set_delay(double p_delay) {
 	delay = p_delay;
 	return this;
 }
 
-Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {
+RequiredValue<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {
 	trans_type = p_trans;
 	return this;
 }
 
-Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {
+RequiredValue<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {
 	ease_type = p_ease;
 	return this;
 }
@@ -912,7 +912,7 @@ bool SubtweenTweener::step(double &r_delta) {
 	return true;
 }
 
-Ref<SubtweenTweener> SubtweenTweener::set_delay(double p_delay) {
+RequiredValue<SubtweenTweener> SubtweenTweener::set_delay(double p_delay) {
 	delay = p_delay;
 	return this;
 }
diff --git a/scene/animation/tween.h b/scene/animation/tween.h
@@ -144,11 +144,11 @@ class Tween : public RefCounted {
 public:
 	virtual String to_string() override;
 
-	Ref<PropertyTweener> tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration);
-	Ref<IntervalTweener> tween_interval(double p_time);
-	Ref<CallbackTweener> tween_callback(const Callable &p_callback);
-	Ref<MethodTweener> tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration);
-	Ref<SubtweenTweener> tween_subtween(const Ref<Tween> &p_subtween);
+	RequiredValue<PropertyTweener> tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration);
+	RequiredValue<IntervalTweener> tween_interval(double p_time);
+	RequiredValue<CallbackTweener> tween_callback(const Callable &p_callback);
+	RequiredValue<MethodTweener> tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration);
+	RequiredValue<SubtweenTweener> tween_subtween(const Ref<Tween> &p_subtween);
 	void append(Ref<Tweener> p_tweener);
 
 	bool custom_step(double p_delta);
@@ -161,25 +161,25 @@ class Tween : public RefCounted {
 	bool is_valid();
 	void clear();
 
-	Ref<Tween> bind_node(const Node *p_node);
-	Ref<Tween> set_process_mode(TweenProcessMode p_mode);
+	RequiredValue<Tween> bind_node(const Node *p_node);
+	RequiredValue<Tween> set_process_mode(TweenProcessMode p_mode);
 	TweenProcessMode get_process_mode() const;
-	Ref<Tween> set_pause_mode(TweenPauseMode p_mode);
+	RequiredValue<Tween> set_pause_mode(TweenPauseMode p_mode);
 	TweenPauseMode get_pause_mode() const;
-	Ref<Tween> set_ignore_time_scale(bool p_ignore = true);
+	RequiredValue<Tween> set_ignore_time_scale(bool p_ignore = true);
 	bool is_ignoring_time_scale() const;
 
-	Ref<Tween> set_parallel(bool p_parallel);
-	Ref<Tween> set_loops(int p_loops);
+	RequiredValue<Tween> set_parallel(bool p_parallel);
+	RequiredValue<Tween> set_loops(int p_loops);
 	int get_loops_left() const;
-	Ref<Tween> set_speed_scale(float p_speed);
-	Ref<Tween> set_trans(TransitionType p_trans);
+	RequiredValue<Tween> set_speed_scale(float p_speed);
+	RequiredValue<Tween> set_trans(TransitionType p_trans);
 	TransitionType get_trans() const;
-	Ref<Tween> set_ease(EaseType p_ease);
+	RequiredValue<Tween> set_ease(EaseType p_ease);
 	EaseType get_ease() const;
 
-	Ref<Tween> parallel();
-	Ref<Tween> chain();
+	RequiredValue<Tween> parallel();
+	RequiredValue<Tween> chain();
 
 	static real_t run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
 	static Variant interpolate_variant(const Variant &p_initial_val, const Variant &p_delta_val, double p_time, double p_duration, Tween::TransitionType p_trans, Tween::EaseType p_ease);
@@ -204,13 +204,13 @@ class PropertyTweener : public Tweener {
 	double _get_custom_interpolated_value(const Variant &p_value);
 
 public:
-	Ref<PropertyTweener> from(const Variant &p_value);
-	Ref<PropertyTweener> from_current();
-	Ref<PropertyTweener> as_relative();
-	Ref<PropertyTweener> set_trans(Tween::TransitionType p_trans);
-	Ref<PropertyTweener> set_ease(Tween::EaseType p_ease);
-	Ref<PropertyTweener> set_custom_interpolator(const Callable &p_method);
-	Ref<PropertyTweener> set_delay(double p_delay);
+	RequiredValue<PropertyTweener> from(const Variant &p_value);
+	RequiredValue<PropertyTweener> from_current();
+	RequiredValue<PropertyTweener> as_relative();
+	RequiredValue<PropertyTweener> set_trans(Tween::TransitionType p_trans);
+	RequiredValue<PropertyTweener> set_ease(Tween::EaseType p_ease);
+	RequiredValue<PropertyTweener> set_custom_interpolator(const Callable &p_method);
+	RequiredValue<PropertyTweener> set_delay(double p_delay);
 
 	void set_tween(const Ref<Tween> &p_tween) override;
 	void start() override;
@@ -260,7 +260,7 @@ class CallbackTweener : public Tweener {
 	GDCLASS(CallbackTweener, Tweener);
 
 public:
-	Ref<CallbackTweener> set_delay(double p_delay);
+	RequiredValue<CallbackTweener> set_delay(double p_delay);
 
 	bool step(double &r_delta) override;
 
@@ -281,9 +281,9 @@ class MethodTweener : public Tweener {
 	GDCLASS(MethodTweener, Tweener);
 
 public:
-	Ref<MethodTweener> set_trans(Tween::TransitionType p_trans);
-	Ref<MethodTweener> set_ease(Tween::EaseType p_ease);
-	Ref<MethodTweener> set_delay(double p_delay);
+	RequiredValue<MethodTweener> set_trans(Tween::TransitionType p_trans);
+	RequiredValue<MethodTweener> set_ease(Tween::EaseType p_ease);
+	RequiredValue<MethodTweener> set_delay(double p_delay);
 
 	void set_tween(const Ref<Tween> &p_tween) override;
 	bool step(double &r_delta) override;
@@ -316,7 +316,7 @@ class SubtweenTweener : public Tweener {
 	void start() override;
 	bool step(double &r_delta) override;
 
-	Ref<SubtweenTweener> set_delay(double p_delay);
+	RequiredValue<SubtweenTweener> set_delay(double p_delay);
 
 	SubtweenTweener(const Ref<Tween> &p_subtween);
 	SubtweenTweener();
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
@@ -2648,7 +2648,7 @@ void Node::_propagate_replace_owner(Node *p_owner, Node *p_by_owner) {
 	data.blocked--;
 }
 
-Ref<Tween> Node::create_tween() {
+RequiredValue<Tween> Node::create_tween() {
 	ERR_THREAD_GUARD_V(Ref<Tween>());
 
 	SceneTree *tree = data.tree;
diff --git a/scene/main/node.h b/scene/main/node.h
@@ -508,7 +508,7 @@ class Node : public Object {
 
 	InternalMode get_internal_mode() const;
 
-	void add_child(Node *p_child, bool p_force_readable_name = false, InternalMode p_internal = INTERNAL_MODE_DISABLED);
+	void add_child(const RequiredParam<Node> &rp_child, bool p_force_readable_name = false, InternalMode p_internal = INTERNAL_MODE_DISABLED);
 	void add_sibling(Node *p_sibling, bool p_force_readable_name = false);
 	void remove_child(Node *p_child);
 
@@ -604,7 +604,7 @@ class Node : public Object {
 		}
 	}
 
-	Ref<Tween> create_tween();
+	RequiredValue<Tween> create_tween();
 
 	void print_tree();
 	void print_tree_pretty();
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
@@ -1744,7 +1744,7 @@ Ref<SceneTreeTimer> SceneTree::create_timer(double p_delay_sec, bool p_process_a
 	return stt;
 }
 
-Ref<Tween> SceneTree::create_tween() {
+RequiredValue<Tween> SceneTree::create_tween() {
 	_THREAD_SAFE_METHOD_
 	Ref<Tween> tween;
 	tween.instantiate(this);
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
@@ -428,7 +428,7 @@ class SceneTree : public MainLoop {
 	void unload_current_scene();
 
 	Ref<SceneTreeTimer> create_timer(double p_delay_sec, bool p_process_always = true, bool p_process_in_physics = false, bool p_ignore_time_scale = false);
-	Ref<Tween> create_tween();
+	RequiredValue<Tween> create_tween();
 	void remove_tween(const Ref<Tween> &p_tween);
 	TypedArray<Tween> get_processed_tweens();
 

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ void Tween::_stop_internal(bool p_reset) {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-Ref<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration) {`
	`98`	`+RequiredValue<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration) {`
`99`	`99`	`ERR_FAIL_NULL_V(p_target, nullptr);`
`100`	`100`	`CHECK_VALID();`
`101`	`101`
`@@ -118,7 +118,7 @@ Ref<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePat`
`118`	`118`	`return tweener;`
`119`	`119`	`}`
`120`	`120`
`121`		`-Ref<IntervalTweener> Tween::tween_interval(double p_time) {`
	`121`	`+RequiredValue<IntervalTweener> Tween::tween_interval(double p_time) {`
`122`	`122`	`CHECK_VALID();`
`123`	`123`
`124`	`124`	`Ref<IntervalTweener> tweener;`
`@@ -127,7 +127,7 @@ Ref<IntervalTweener> Tween::tween_interval(double p_time) {`
`127`	`127`	`return tweener;`
`128`	`128`	`}`
`129`	`129`
`130`		`-Ref<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {`
	`130`	`+RequiredValue<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {`
`131`	`131`	`CHECK_VALID();`
`132`	`132`
`133`	`133`	`Ref<CallbackTweener> tweener;`
`@@ -136,7 +136,7 @@ Ref<CallbackTweener> Tween::tween_callback(const Callable &p_callback) {`
`136`	`136`	`return tweener;`
`137`	`137`	`}`
`138`	`138`
`139`		`-Ref<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration) {`
	`139`	`+RequiredValue<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration) {`
`140`	`140`	`CHECK_VALID();`
`141`	`141`
`142`	`142`	`if (!Animation::validate_type_match(p_from, p_to)) {`
`@@ -149,7 +149,7 @@ Ref<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant`
`149`	`149`	`return tweener;`
`150`	`150`	`}`
`151`	`151`
`152`		`-Ref<SubtweenTweener> Tween::tween_subtween(const Ref<Tween> &p_subtween) {`
	`152`	`+RequiredValue<SubtweenTweener> Tween::tween_subtween(const Ref<Tween> &p_subtween) {`
`153`	`153`	`CHECK_VALID();`
`154`	`154`
`155`	`155`	`// Ensure that the subtween being added is not null.`
`@@ -221,15 +221,15 @@ void Tween::clear() {`
`221`	`221`	`tweeners.clear();`
`222`	`222`	`}`
`223`	`223`
`224`		`-Ref<Tween> Tween::bind_node(const Node *p_node) {`
	`224`	`+RequiredValue<Tween> Tween::bind_node(const Node *p_node) {`
`225`	`225`	`ERR_FAIL_NULL_V(p_node, this);`
`226`	`226`
`227`	`227`	`bound_node = p_node->get_instance_id();`
`228`	`228`	`is_bound = true;`
`229`	`229`	`return this;`
`230`	`230`	`}`
`231`	`231`
`232`		`-Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {`
	`232`	`+RequiredValue<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {`
`233`	`233`	`process_mode = p_mode;`
`234`	`234`	`return this;`
`235`	`235`	`}`
`@@ -238,7 +238,7 @@ Tween::TweenProcessMode Tween::get_process_mode() const {`
`238`	`238`	`return process_mode;`
`239`	`239`	`}`
`240`	`240`
`241`		`-Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {`
	`241`	`+RequiredValue<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {`
`242`	`242`	`pause_mode = p_mode;`
`243`	`243`	`return this;`
`244`	`244`	`}`
`@@ -247,7 +247,7 @@ Tween::TweenPauseMode Tween::get_pause_mode() const {`
`247`	`247`	`return pause_mode;`
`248`	`248`	`}`
`249`	`249`
`250`		`-Ref<Tween> Tween::set_ignore_time_scale(bool p_ignore) {`
	`250`	`+RequiredValue<Tween> Tween::set_ignore_time_scale(bool p_ignore) {`
`251`	`251`	`ignore_time_scale = p_ignore;`
`252`	`252`	`return this;`
`253`	`253`	`}`
`@@ -256,13 +256,13 @@ bool Tween::is_ignoring_time_scale() const {`
`256`	`256`	`return ignore_time_scale;`
`257`	`257`	`}`
`258`	`258`
`259`		`-Ref<Tween> Tween::set_parallel(bool p_parallel) {`
	`259`	`+RequiredValue<Tween> Tween::set_parallel(bool p_parallel) {`
`260`	`260`	`default_parallel = p_parallel;`
`261`	`261`	`parallel_enabled = p_parallel;`
`262`	`262`	`return this;`
`263`	`263`	`}`
`264`	`264`
`265`		`-Ref<Tween> Tween::set_loops(int p_loops) {`
	`265`	`+RequiredValue<Tween> Tween::set_loops(int p_loops) {`
`266`	`266`	`loops = p_loops;`
`267`	`267`	`return this;`
`268`	`268`	`}`
`@@ -275,12 +275,12 @@ int Tween::get_loops_left() const {`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
`278`		`-Ref<Tween> Tween::set_speed_scale(float p_speed) {`
	`278`	`+RequiredValue<Tween> Tween::set_speed_scale(float p_speed) {`
`279`	`279`	`speed_scale = p_speed;`
`280`	`280`	`return this;`
`281`	`281`	`}`
`282`	`282`
`283`		`-Ref<Tween> Tween::set_trans(TransitionType p_trans) {`
	`283`	`+RequiredValue<Tween> Tween::set_trans(TransitionType p_trans) {`
`284`	`284`	`default_transition = p_trans;`
`285`	`285`	`return this;`
`286`	`286`	`}`
`@@ -289,7 +289,7 @@ Tween::TransitionType Tween::get_trans() const {`
`289`	`289`	`return default_transition;`
`290`	`290`	`}`
`291`	`291`
`292`		`-Ref<Tween> Tween::set_ease(EaseType p_ease) {`
	`292`	`+RequiredValue<Tween> Tween::set_ease(EaseType p_ease) {`
`293`	`293`	`default_ease = p_ease;`
`294`	`294`	`return this;`
`295`	`295`	`}`
`@@ -298,12 +298,12 @@ Tween::EaseType Tween::get_ease() const {`
`298`	`298`	`return default_ease;`
`299`	`299`	`}`
`300`	`300`
`301`		`-Ref<Tween> Tween::parallel() {`
	`301`	`+RequiredValue<Tween> Tween::parallel() {`
`302`	`302`	`parallel_enabled = true;`
`303`	`303`	`return this;`
`304`	`304`	`}`
`305`	`305`
`306`		`-Ref<Tween> Tween::chain() {`
	`306`	`+RequiredValue<Tween> Tween::chain() {`
`307`	`307`	`parallel_enabled = false;`
`308`	`308`	`return this;`
`309`	`309`	`}`
`@@ -554,7 +554,7 @@ double PropertyTweener::_get_custom_interpolated_value(const Variant &p_value) {`
`554`	`554`	`return result;`
`555`	`555`	`}`
`556`	`556`
`557`		`-Ref<PropertyTweener> PropertyTweener::from(const Variant &p_value) {`
	`557`	`+RequiredValue<PropertyTweener> PropertyTweener::from(const Variant &p_value) {`
`558`	`558`	`Ref<Tween> tween = _get_tween();`
`559`	`559`	`ERR_FAIL_COND_V(tween.is_null(), nullptr);`
`560`	`560`
`@@ -568,32 +568,32 @@ Ref<PropertyTweener> PropertyTweener::from(const Variant &p_value) {`
`568`	`568`	`return this;`
`569`	`569`	`}`
`570`	`570`
`571`		`-Ref<PropertyTweener> PropertyTweener::from_current() {`
	`571`	`+RequiredValue<PropertyTweener> PropertyTweener::from_current() {`
`572`	`572`	`do_continue = false;`
`573`	`573`	`return this;`
`574`	`574`	`}`
`575`	`575`
`576`		`-Ref<PropertyTweener> PropertyTweener::as_relative() {`
	`576`	`+RequiredValue<PropertyTweener> PropertyTweener::as_relative() {`
`577`	`577`	`relative = true;`
`578`	`578`	`return this;`
`579`	`579`	`}`
`580`	`580`
`581`		`-Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {`
	`581`	`+RequiredValue<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {`
`582`	`582`	`trans_type = p_trans;`
`583`	`583`	`return this;`
`584`	`584`	`}`
`585`	`585`
`586`		`-Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {`
	`586`	`+RequiredValue<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {`
`587`	`587`	`ease_type = p_ease;`
`588`	`588`	`return this;`
`589`	`589`	`}`
`590`	`590`
`591`		`-Ref<PropertyTweener> PropertyTweener::set_custom_interpolator(const Callable &p_method) {`
	`591`	`+RequiredValue<PropertyTweener> PropertyTweener::set_custom_interpolator(const Callable &p_method) {`
`592`	`592`	`custom_method = p_method;`
`593`	`593`	`return this;`
`594`	`594`	`}`
`595`	`595`
`596`		`-Ref<PropertyTweener> PropertyTweener::set_delay(double p_delay) {`
	`596`	`+RequiredValue<PropertyTweener> PropertyTweener::set_delay(double p_delay) {`
`597`	`597`	`delay = p_delay;`
`598`	`598`	`return this;`
`599`	`599`	`}`
`@@ -731,7 +731,7 @@ IntervalTweener::IntervalTweener() {`
`731`	`731`	`ERR_FAIL_MSG("IntervalTweener can't be created directly. Use the tween_interval() method in Tween.");`
`732`	`732`	`}`
`733`	`733`
`734`		`-Ref<CallbackTweener> CallbackTweener::set_delay(double p_delay) {`
	`734`	`+RequiredValue<CallbackTweener> CallbackTweener::set_delay(double p_delay) {`
`735`	`735`	`delay = p_delay;`
`736`	`736`	`return this;`
`737`	`737`	`}`
`@@ -781,17 +781,17 @@ CallbackTweener::CallbackTweener() {`
`781`	`781`	`ERR_FAIL_MSG("CallbackTweener can't be created directly. Use the tween_callback() method in Tween.");`
`782`	`782`	`}`
`783`	`783`
`784`		`-Ref<MethodTweener> MethodTweener::set_delay(double p_delay) {`
	`784`	`+RequiredValue<MethodTweener> MethodTweener::set_delay(double p_delay) {`
`785`	`785`	`delay = p_delay;`
`786`	`786`	`return this;`
`787`	`787`	`}`
`788`	`788`
`789`		`-Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {`
	`789`	`+RequiredValue<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {`
`790`	`790`	`trans_type = p_trans;`
`791`	`791`	`return this;`
`792`	`792`	`}`
`793`	`793`
`794`		`-Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {`
	`794`	`+RequiredValue<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {`
`795`	`795`	`ease_type = p_ease;`
`796`	`796`	`return this;`
`797`	`797`	`}`
`@@ -912,7 +912,7 @@ bool SubtweenTweener::step(double &r_delta) {`
`912`	`912`	`return true;`
`913`	`913`	`}`
`914`	`914`
`915`		`-Ref<SubtweenTweener> SubtweenTweener::set_delay(double p_delay) {`
	`915`	`+RequiredValue<SubtweenTweener> SubtweenTweener::set_delay(double p_delay) {`
`916`	`916`	`delay = p_delay;`
`917`	`917`	`return this;`
`918`	`918`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2648,7 +2648,7 @@ void Node::_propagate_replace_owner(Node p_owner, Node p_by_owner) {`
`2648`	`2648`	`data.blocked--;`
`2649`	`2649`	`}`
`2650`	`2650`
`2651`		`-Ref<Tween> Node::create_tween() {`
	`2651`	`+RequiredValue<Tween> Node::create_tween() {`
`2652`	`2652`	`ERR_THREAD_GUARD_V(Ref<Tween>());`
`2653`	`2653`
`2654`	`2654`	`SceneTree *tree = data.tree;`
Original file line number	Diff line number	Diff line change
`@@ -508,7 +508,7 @@ class Node : public Object {`
`508`	`508`
`509`	`509`	`InternalMode get_internal_mode() const;`
`510`	`510`
`511`		`- void add_child(Node *p_child, bool p_force_readable_name = false, InternalMode p_internal = INTERNAL_MODE_DISABLED);`
	`511`	`+ void add_child(const RequiredParam<Node> &rp_child, bool p_force_readable_name = false, InternalMode p_internal = INTERNAL_MODE_DISABLED);`
`512`	`512`	`void add_sibling(Node *p_sibling, bool p_force_readable_name = false);`
`513`	`513`	`void remove_child(Node *p_child);`
`514`	`514`
`@@ -604,7 +604,7 @@ class Node : public Object {`
`604`	`604`	`}`
`605`	`605`	`}`
`606`	`606`
`607`		`- Ref<Tween> create_tween();`
	`607`	`+ RequiredValue<Tween> create_tween();`
`608`	`608`
`609`	`609`	`void print_tree();`
`610`	`610`	`void print_tree_pretty();`
Original file line number	Diff line number	Diff line change
`@@ -1744,7 +1744,7 @@ Ref<SceneTreeTimer> SceneTree::create_timer(double p_delay_sec, bool p_process_a`
`1744`	`1744`	`return stt;`
`1745`	`1745`	`}`
`1746`	`1746`
`1747`		`-Ref<Tween> SceneTree::create_tween() {`
	`1747`	`+RequiredValue<Tween> SceneTree::create_tween() {`
`1748`	`1748`	`_THREAD_SAFE_METHOD_`
`1749`	`1749`	`Ref<Tween> tween;`
`1750`	`1750`	`tween.instantiate(this);`