Synchronize parameter names in definition and declaration

Fixes #10244.

21 files changed, 165 insertions, 165 deletions

diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h
index e18d663d85..61c80aaba3 100644
--- a/core/bind/core_bind.h
+++ b/core/bind/core_bind.h
@@ -458,7 +458,7 @@ protected:
 public:
 	Error open(const String &p_path);
 
-	Error list_dir_begin(bool p_skip_internal = false, bool p_skip_hidden = false); ///< This starts dir listing
+	Error list_dir_begin(bool p_skip_navigational = false, bool p_skip_hidden = false); ///< This starts dir listing
 	String get_next();
 	bool current_is_dir() const;
 
diff --git a/core/io/file_access_buffered.cpp b/core/io/file_access_buffered.cpp
index 81adbbbaf7..126ec7575e 100644
--- a/core/io/file_access_buffered.cpp
+++ b/core/io/file_access_buffered.cpp
@@ -106,11 +106,11 @@ uint8_t FileAccessBuffered::get_8() const {
 	return byte;
 };
 
-int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
+int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_length) const {
 
 	ERR_FAIL_COND_V(!file.open, -1);
 
-	if (p_elements > cache_size) {
+	if (p_length > cache_size) {
 
 		int total_read = 0;
 
@@ -122,12 +122,12 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
 			//memcpy(p_dest, read.ptr() + (file.offset - cache.offset), size);
 			memcpy(p_dest, cache.buffer.ptr() + (file.offset - cache.offset), size);
 			p_dest += size;
-			p_elements -= size;
+			p_length -= size;
 			file.offset += size;
 			total_read += size;
 		};
 
-		int err = read_data_block(file.offset, p_elements, p_dest);
+		int err = read_data_block(file.offset, p_length, p_dest);
 		if (err >= 0) {
 			total_read += err;
 			file.offset += err;
@@ -136,7 +136,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
 		return total_read;
 	};
 
-	int to_read = p_elements;
+	int to_read = p_length;
 	int total_read = 0;
 	while (to_read > 0) {
 
@@ -161,7 +161,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
 		to_read -= r;
 	};
 
-	return p_elements;
+	return p_length;
 };
 
 bool FileAccessBuffered::is_open() const {
diff --git a/core/io/file_access_buffered.h b/core/io/file_access_buffered.h
index c5bf120890..0ad2d0e929 100644
--- a/core/io/file_access_buffered.h
+++ b/core/io/file_access_buffered.h
@@ -81,7 +81,7 @@ public:
 	virtual bool eof_reached() const;
 
 	virtual uint8_t get_8() const;
-	virtual int get_buffer(uint8_t *p_dst, int p_length) const; ///< get an array of bytes
+	virtual int get_buffer(uint8_t *p_dest, int p_length) const; ///< get an array of bytes
 
 	virtual bool is_open() const;
 
diff --git a/core/io/file_access_memory.h b/core/io/file_access_memory.h
index 8b6abe7e81..ea858c547e 100644
--- a/core/io/file_access_memory.h
+++ b/core/io/file_access_memory.h
@@ -62,7 +62,7 @@ public:
 
 	virtual Error get_error() const; ///< get last error
 
-	virtual void store_8(uint8_t p_dest); ///< store a byte
+	virtual void store_8(uint8_t p_byte); ///< store a byte
 	virtual void store_buffer(const uint8_t *p_src, int p_length); ///< store an array of bytes
 
 	virtual bool file_exists(const String &p_name); ///< return true if a file exists
diff --git a/core/io/file_access_zip.cpp b/core/io/file_access_zip.cpp
index a92014000d..d748d5c773 100644
--- a/core/io/file_access_zip.cpp
+++ b/core/io/file_access_zip.cpp
@@ -159,15 +159,15 @@ unzFile ZipArchive::get_file_handle(String p_file) const {
 	return pkg;
 };
 
-bool ZipArchive::try_open_pack(const String &p_name) {
+bool ZipArchive::try_open_pack(const String &p_path) {
 
 	//printf("opening zip pack %ls, %i, %i\n", p_name.c_str(), p_name.extension().nocasecmp_to("zip"), p_name.extension().nocasecmp_to("pcz"));
-	if (p_name.get_extension().nocasecmp_to("zip") != 0 && p_name.get_extension().nocasecmp_to("pcz") != 0)
+	if (p_path.get_extension().nocasecmp_to("zip") != 0 && p_path.get_extension().nocasecmp_to("pcz") != 0)
 		return false;
 
 	zlib_filefunc_def io;
 
-	FileAccess *f = FileAccess::open(p_name, FileAccess::READ);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
 	if (!f)
 		return false;
 	io.opaque = f;
@@ -180,7 +180,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
 	io.zclose_file = godot_close;
 	io.zerror_file = godot_testerror;
 
-	unzFile zfile = unzOpen2(p_name.utf8().get_data(), &io);
+	unzFile zfile = unzOpen2(p_path.utf8().get_data(), &io);
 	ERR_FAIL_COND_V(!zfile, false);
 
 	unz_global_info64 gi;
@@ -188,7 +188,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
 	ERR_FAIL_COND_V(err != UNZ_OK, false);
 
 	Package pkg;
-	pkg.filename = p_name;
+	pkg.filename = p_path;
 	pkg.zfile = zfile;
 	packages.push_back(pkg);
 	int pkg_num = packages.size() - 1;
@@ -209,7 +209,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
 		files[fname] = f;
 
 		uint8_t md5[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-		PackedData::get_singleton()->add_path(p_name, fname, 1, 0, md5, this);
+		PackedData::get_singleton()->add_path(p_path, fname, 1, 0, md5, this);
 		//printf("packed data add path %ls, %ls\n", p_name.c_str(), fname.c_str());
 
 		if ((i + 1) < gi.number_entry) {
diff --git a/core/io/ip_address.h b/core/io/ip_address.h
index ac58283605..da16622a9b 100644
--- a/core/io/ip_address.h
+++ b/core/io/ip_address.h
@@ -75,7 +75,7 @@ public:
 	void set_ipv4(const uint8_t *p_ip);
 
 	const uint8_t *get_ipv6() const;
-	void set_ipv6(const uint8_t *buf);
+	void set_ipv6(const uint8_t *p_buf);
 
 	operator String() const;
 	IP_Address(const String &p_string);
diff --git a/core/io/json.cpp b/core/io/json.cpp
index 10fd60abf7..d537061c5b 100644
--- a/core/io/json.cpp
+++ b/core/io/json.cpp
@@ -94,15 +94,15 @@ String JSON::print(const Variant &p_var) {
 	return _print_var(p_var);
 }
 
-Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_token, int &line, String &r_err_str) {
+Error JSON::_get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str) {
 
 	while (p_len > 0) {
-		switch (p_str[idx]) {
+		switch (p_str[index]) {
 
 			case '\n': {
 
 				line++;
-				idx++;
+				index++;
 				break;
 			};
 			case 0: {
@@ -112,54 +112,54 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
 			case '{': {
 
 				r_token.type = TK_CURLY_BRACKET_OPEN;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '}': {
 
 				r_token.type = TK_CURLY_BRACKET_CLOSE;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '[': {
 
 				r_token.type = TK_BRACKET_OPEN;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ']': {
 
 				r_token.type = TK_BRACKET_CLOSE;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ':': {
 
 				r_token.type = TK_COLON;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ',': {
 
 				r_token.type = TK_COMMA;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '"': {
 
-				idx++;
+				index++;
 				String str;
 				while (true) {
-					if (p_str[idx] == 0) {
+					if (p_str[index] == 0) {
 						r_err_str = "Unterminated String";
 						return ERR_PARSE_ERROR;
-					} else if (p_str[idx] == '"') {
-						idx++;
+					} else if (p_str[index] == '"') {
+						index++;
 						break;
-					} else if (p_str[idx] == '\\') {
+					} else if (p_str[index] == '\\') {
 						//escaped characters...
-						idx++;
-						CharType next = p_str[idx];
+						index++;
+						CharType next = p_str[index];
 						if (next == 0) {
 							r_err_str = "Unterminated String";
 							return ERR_PARSE_ERROR;
@@ -177,7 +177,7 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
 								//hexnumbarh - oct is deprecated
 
 								for (int j = 0; j < 4; j++) {
-									CharType c = p_str[idx + j + 1];
+									CharType c = p_str[index + j + 1];
 									if (c == 0) {
 										r_err_str = "Unterminated String";
 										return ERR_PARSE_ERROR;
@@ -204,7 +204,7 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
 									res <<= 4;
 									res |= v;
 								}
-								idx += 4; //will add at the end anyway
+								index += 4; //will add at the end anyway
 
 							} break;
 							//case '\"': res='\"'; break;
@@ -220,11 +220,11 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
 						str += res;
 
 					} else {
-						if (p_str[idx] == '\n')
+						if (p_str[index] == '\n')
 							line++;
-						str += p_str[idx];
+						str += p_str[index];
 					}
-					idx++;
+					index++;
 				}
 
 				r_token.type = TK_STRING;
@@ -234,28 +234,28 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
 			} break;
 			default: {
 
-				if (p_str[idx] <= 32) {
-					idx++;
+				if (p_str[index] <= 32) {
+					index++;
 					break;
 				}
 
-				if (p_str[idx] == '-' || (p_str[idx] >= '0' && p_str[idx] <= '9')) {
+				if (p_str[index] == '-' || (p_str[index] >= '0' && p_str[index] <= '9')) {
 					//a number
 					const CharType *rptr;
-					double number = String::to_double(&p_str[idx], &rptr);
-					idx += (rptr - &p_str[idx]);
+					double number = String::to_double(&p_str[index], &rptr);
+					index += (rptr - &p_str[index]);
 					r_token.type = TK_NUMBER;
 					r_token.value = number;
 					return OK;
 
-				} else if ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
+				} else if ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
 
 					String id;
 
-					while ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
+					while ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
 
-						id += p_str[idx];
-						idx++;
+						id += p_str[index];
+						index++;
 					}
 
 					r_token.type = TK_IDENTIFIER;
diff --git a/core/math/math_2d.cpp b/core/math/math_2d.cpp
index 52e240ed47..956cfe5258 100644
--- a/core/math/math_2d.cpp
+++ b/core/math/math_2d.cpp
@@ -281,22 +281,22 @@ Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, c
 }
 
 // slide returns the component of the vector along the given plane, specified by its normal vector.
-Vector2 Vector2::slide(const Vector2 &p_n) const {
+Vector2 Vector2::slide(const Vector2 &p_normal) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector2());
+	ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector2());
 #endif
-	return *this - p_n * this->dot(p_n);
+	return *this - p_normal * this->dot(p_normal);
 }
 
-Vector2 Vector2::bounce(const Vector2 &p_n) const {
-	return -reflect(p_n);
+Vector2 Vector2::bounce(const Vector2 &p_normal) const {
+	return -reflect(p_normal);
 }
 
-Vector2 Vector2::reflect(const Vector2 &p_n) const {
+Vector2 Vector2::reflect(const Vector2 &p_normal) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector2());
+	ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector2());
 #endif
-	return 2.0 * p_n * this->dot(p_n) - *this;
+	return 2.0 * p_normal * this->dot(p_normal) - *this;
 }
 
 bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_pos, Point2 *r_normal) const {
diff --git a/core/math/math_2d.h b/core/math/math_2d.h
index b679371e03..963b5efc43 100644
--- a/core/math/math_2d.h
+++ b/core/math/math_2d.h
@@ -107,9 +107,9 @@ struct Vector2 {
 	Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
 	Vector2 cubic_interpolate_soft(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
 
-	Vector2 slide(const Vector2 &p_vec) const;
-	Vector2 bounce(const Vector2 &p_vec) const;
-	Vector2 reflect(const Vector2 &p_vec) const;
+	Vector2 slide(const Vector2 &p_normal) const;
+	Vector2 bounce(const Vector2 &p_normal) const;
+	Vector2 reflect(const Vector2 &p_normal) const;
 
 	Vector2 operator+(const Vector2 &p_v) const;
 	void operator+=(const Vector2 &p_v);
@@ -621,9 +621,9 @@ struct Transform2D {
 	void affine_invert();
 	Transform2D affine_inverse() const;
 
-	void set_rotation(real_t p_phi);
+	void set_rotation(real_t p_rot);
 	real_t get_rotation() const;
-	_FORCE_INLINE_ void set_rotation_and_scale(real_t p_phi, const Size2 &p_scale);
+	_FORCE_INLINE_ void set_rotation_and_scale(real_t p_rot, const Size2 &p_scale);
 	void rotate(real_t p_phi);
 
 	void scale(const Size2 &p_scale);
@@ -660,8 +660,8 @@ struct Transform2D {
 	_FORCE_INLINE_ Vector2 basis_xform_inv(const Vector2 &p_vec) const;
 	_FORCE_INLINE_ Vector2 xform(const Vector2 &p_vec) const;
 	_FORCE_INLINE_ Vector2 xform_inv(const Vector2 &p_vec) const;
-	_FORCE_INLINE_ Rect2 xform(const Rect2 &p_vec) const;
-	_FORCE_INLINE_ Rect2 xform_inv(const Rect2 &p_vec) const;
+	_FORCE_INLINE_ Rect2 xform(const Rect2 &p_rect) const;
+	_FORCE_INLINE_ Rect2 xform_inv(const Rect2 &p_rect) const;
 
 	operator String() const;
 
@@ -833,25 +833,25 @@ next4:
 	return true;
 }
 
-Vector2 Transform2D::basis_xform(const Vector2 &v) const {
+Vector2 Transform2D::basis_xform(const Vector2 &p_vec) const {
 
 	return Vector2(
-			tdotx(v),
-			tdoty(v));
+			tdotx(p_vec),
+			tdoty(p_vec));
 }
 
-Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
+Vector2 Transform2D::basis_xform_inv(const Vector2 &p_vec) const {
 
 	return Vector2(
-			elements[0].dot(v),
-			elements[1].dot(v));
+			elements[0].dot(p_vec),
+			elements[1].dot(p_vec));
 }
 
-Vector2 Transform2D::xform(const Vector2 &v) const {
+Vector2 Transform2D::xform(const Vector2 &p_vec) const {
 
 	return Vector2(
-				   tdotx(v),
-				   tdoty(v)) +
+				   tdotx(p_vec),
+				   tdoty(p_vec)) +
 		   elements[2];
 }
 Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
diff --git a/core/math/rect3.h b/core/math/rect3.h
index e5d7462009..7c971f5ac7 100644
--- a/core/math/rect3.h
+++ b/core/math/rect3.h
@@ -72,9 +72,9 @@ public:
 	Rect3 intersection(const Rect3 &p_aabb) const; ///get box where two intersect, empty if no intersection occurs
 	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
 	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
-	_FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &from, const Vector3 &p_dir, real_t t0, real_t t1) const;
+	_FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_dir, real_t t0, real_t t1) const;
 
-	_FORCE_INLINE_ bool intersects_convex_shape(const Plane *p_plane, int p_plane_count) const;
+	_FORCE_INLINE_ bool intersects_convex_shape(const Plane *p_planes, int p_plane_count) const;
 	bool intersects_plane(const Plane &p_plane) const;
 
 	_FORCE_INLINE_ bool has_point(const Vector3 &p_point) const;
@@ -326,27 +326,27 @@ inline real_t Rect3::get_shortest_axis_size() const {
 	return max_size;
 }
 
-bool Rect3::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t0, real_t t1) const {
+bool Rect3::smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_dir, real_t t0, real_t t1) const {
 
-	real_t divx = 1.0 / dir.x;
-	real_t divy = 1.0 / dir.y;
-	real_t divz = 1.0 / dir.z;
+	real_t divx = 1.0 / p_dir.x;
+	real_t divy = 1.0 / p_dir.y;
+	real_t divz = 1.0 / p_dir.z;
 
 	Vector3 upbound = position + size;
 	real_t tmin, tmax, tymin, tymax, tzmin, tzmax;
-	if (dir.x >= 0) {
-		tmin = (position.x - from.x) * divx;
-		tmax = (upbound.x - from.x) * divx;
+	if (p_dir.x >= 0) {
+		tmin = (position.x - p_from.x) * divx;
+		tmax = (upbound.x - p_from.x) * divx;
 	} else {
-		tmin = (upbound.x - from.x) * divx;
-		tmax = (position.x - from.x) * divx;
+		tmin = (upbound.x - p_from.x) * divx;
+		tmax = (position.x - p_from.x) * divx;
 	}
-	if (dir.y >= 0) {
-		tymin = (position.y - from.y) * divy;
-		tymax = (upbound.y - from.y) * divy;
+	if (p_dir.y >= 0) {
+		tymin = (position.y - p_from.y) * divy;
+		tymax = (upbound.y - p_from.y) * divy;
 	} else {
-		tymin = (upbound.y - from.y) * divy;
-		tymax = (position.y - from.y) * divy;
+		tymin = (upbound.y - p_from.y) * divy;
+		tymax = (position.y - p_from.y) * divy;
 	}
 	if ((tmin > tymax) || (tymin > tmax))
 		return false;
@@ -354,12 +354,12 @@ bool Rect3::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t
 		tmin = tymin;
 	if (tymax < tmax)
 		tmax = tymax;
-	if (dir.z >= 0) {
-		tzmin = (position.z - from.z) * divz;
-		tzmax = (upbound.z - from.z) * divz;
+	if (p_dir.z >= 0) {
+		tzmin = (position.z - p_from.z) * divz;
+		tzmax = (upbound.z - p_from.z) * divz;
 	} else {
-		tzmin = (upbound.z - from.z) * divz;
-		tzmax = (position.z - from.z) * divz;
+		tzmin = (upbound.z - p_from.z) * divz;
+		tzmax = (position.z - p_from.z) * divz;
 	}
 	if ((tmin > tzmax) || (tzmin > tmax))
 		return false;
diff --git a/core/math/vector3.h b/core/math/vector3.h
index 6a7974681e..c58a86fbdb 100644
--- a/core/math/vector3.h
+++ b/core/math/vector3.h
@@ -108,9 +108,9 @@ struct Vector3 {
 
 	_FORCE_INLINE_ real_t angle_to(const Vector3 &p_b) const;
 
-	_FORCE_INLINE_ Vector3 slide(const Vector3 &p_vec) const;
-	_FORCE_INLINE_ Vector3 bounce(const Vector3 &p_vec) const;
-	_FORCE_INLINE_ Vector3 reflect(const Vector3 &p_vec) const;
+	_FORCE_INLINE_ Vector3 slide(const Vector3 &p_normal) const;
+	_FORCE_INLINE_ Vector3 bounce(const Vector3 &p_normal) const;
+	_FORCE_INLINE_ Vector3 reflect(const Vector3 &p_normal) const;
 
 	/* Operators */
 
@@ -410,22 +410,22 @@ void Vector3::zero() {
 }
 
 // slide returns the component of the vector along the given plane, specified by its normal vector.
-Vector3 Vector3::slide(const Vector3 &p_n) const {
+Vector3 Vector3::slide(const Vector3 &p_normal) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector3());
+	ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector3());
 #endif
-	return *this - p_n * this->dot(p_n);
+	return *this - p_normal * this->dot(p_normal);
 }
 
-Vector3 Vector3::bounce(const Vector3 &p_n) const {
-	return -reflect(p_n);
+Vector3 Vector3::bounce(const Vector3 &p_normal) const {
+	return -reflect(p_normal);
 }
 
-Vector3 Vector3::reflect(const Vector3 &p_n) const {
+Vector3 Vector3::reflect(const Vector3 &p_normal) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector3());
+	ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector3());
 #endif
-	return 2.0 * p_n * this->dot(p_n) - *this;
+	return 2.0 * p_normal * this->dot(p_normal) - *this;
 }
 
 #endif
diff --git a/core/object.h b/core/object.h
index 551c3c31b9..4648d9d90e 100644
--- a/core/object.h
+++ b/core/object.h
@@ -443,7 +443,7 @@ private:
 	mutable StringName _class_name;
 	mutable const StringName *_class_ptr;
 
-	void _add_user_signal(const String &p_name, const Array &p_pargs = Array());
+	void _add_user_signal(const String &p_name, const Array &p_args = Array());
 	bool _has_user_signal(const StringName &p_name) const;
 	Variant _emit_signal(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 	Array _get_signal_list() const;
diff --git a/core/os/file_access.cpp b/core/os/file_access.cpp
index 3bd5ac3f41..9d1fefc925 100644
--- a/core/os/file_access.cpp
+++ b/core/os/file_access.cpp
@@ -475,9 +475,9 @@ void FileAccess::store_buffer(const uint8_t *p_src, int p_length) {
 		store_8(p_src[i]);
 }
 
-Vector<uint8_t> FileAccess::get_file_as_array(const String &p_file) {
+Vector<uint8_t> FileAccess::get_file_as_array(const String &p_path) {
 
-	FileAccess *f = FileAccess::open(p_file, READ);
+	FileAccess *f = FileAccess::open(p_path, READ);
 	ERR_FAIL_COND_V(!f, Vector<uint8_t>());
 	Vector<uint8_t> data;
 	data.resize(f->get_len());
diff --git a/core/os/file_access.h b/core/os/file_access.h
index 6d3e491167..beed7551fb 100644
--- a/core/os/file_access.h
+++ b/core/os/file_access.h
@@ -129,7 +129,7 @@ public:
 	virtual void store_real(real_t p_real);
 
 	virtual void store_string(const String &p_string);
-	virtual void store_line(const String &p_string);
+	virtual void store_line(const String &p_line);
 
 	virtual void store_pascal_string(const String &p_string);
 	virtual String get_pascal_string();
diff --git a/core/os/keyboard.h b/core/os/keyboard.h
index 1ed93e3540..1ef26de183 100644
--- a/core/os/keyboard.h
+++ b/core/os/keyboard.h
@@ -324,7 +324,7 @@ enum KeyModifierMask {
 };
 
 String keycode_get_string(uint32_t p_code);
-bool keycode_has_unicode(uint32_t p_unicode);
+bool keycode_has_unicode(uint32_t p_keycode);
 int find_keycode(const String &p_code);
 int keycode_get_count();
 int keycode_get_value_by_index(int p_index);
diff --git a/core/project_settings.h b/core/project_settings.h
index c64bb393d1..cee3b3b5f3 100644
--- a/core/project_settings.h
+++ b/core/project_settings.h
@@ -158,7 +158,7 @@ public:
 
 	bool is_using_datapack() const;
 
-	void set_registering_order(bool p_registering);
+	void set_registering_order(bool p_enable);
 
 	ProjectSettings();
 	~ProjectSettings();
diff --git a/core/resource.h b/core/resource.h
index 5a4e45da36..bbf233d53e 100644
--- a/core/resource.h
+++ b/core/resource.h
@@ -107,7 +107,7 @@ public:
 	int get_subindex() const;
 
 	virtual Ref<Resource> duplicate(bool p_subresources = false) const;
-	Ref<Resource> duplicate_for_local_scene(Node *p_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache);
+	Ref<Resource> duplicate_for_local_scene(Node *p_for_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache);
 
 	void set_local_to_scene(bool p_enable);
 	bool is_local_to_scene() const;
diff --git a/core/script_debugger_remote.cpp b/core/script_debugger_remote.cpp
index 3628f2ecaf..44e86bca6a 100644
--- a/core/script_debugger_remote.cpp
+++ b/core/script_debugger_remote.cpp
@@ -429,9 +429,9 @@ void ScriptDebuggerRemote::_err_handler(void *ud, const char *p_func, const char
 	sdr->mutex->unlock();
 }
 
-bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
+bool ScriptDebuggerRemote::_parse_live_edit(const Array &p_command) {
 
-	String cmdstr = cmd[0];
+	String cmdstr = p_command[0];
 	if (!live_edit_funcs || !cmdstr.begins_with("live_"))
 		return false;
 
@@ -441,7 +441,7 @@ bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
 		if (!live_edit_funcs->root_func)
 			return true;
 		//print_line("root: "+Variant(cmd).get_construct_string());
-		live_edit_funcs->root_func(live_edit_funcs->udata, cmd[1], cmd[2]);
+		live_edit_funcs->root_func(live_edit_funcs->udata, p_command[1], p_command[2]);
 
 	} else if (cmdstr == "live_node_path") {
 
@@ -449,75 +449,75 @@ bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
 			return true;
 		//print_line("path: "+Variant(cmd).get_construct_string());
 
-		live_edit_funcs->node_path_func(live_edit_funcs->udata, cmd[1], cmd[2]);
+		live_edit_funcs->node_path_func(live_edit_funcs->udata, p_command[1], p_command[2]);
 
 	} else if (cmdstr == "live_res_path") {
 
 		if (!live_edit_funcs->res_path_func)
 			return true;
-		live_edit_funcs->res_path_func(live_edit_funcs->udata, cmd[1], cmd[2]);
+		live_edit_funcs->res_path_func(live_edit_funcs->udata, p_command[1], p_command[2]);
 
 	} else if (cmdstr == "live_node_prop_res") {
 		if (!live_edit_funcs->node_set_res_func)
 			return true;
 
-		live_edit_funcs->node_set_res_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->node_set_res_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_node_prop") {
 
 		if (!live_edit_funcs->node_set_func)
 			return true;
-		live_edit_funcs->node_set_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->node_set_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_res_prop_res") {
 
 		if (!live_edit_funcs->res_set_res_func)
 			return true;
-		live_edit_funcs->res_set_res_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->res_set_res_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_res_prop") {
 
 		if (!live_edit_funcs->res_set_func)
 			return true;
-		live_edit_funcs->res_set_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->res_set_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_node_call") {
 
 		if (!live_edit_funcs->node_call_func)
 			return true;
-		live_edit_funcs->node_call_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);
+		live_edit_funcs->node_call_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4], p_command[5], p_command[6], p_command[7]);
 
 	} else if (cmdstr == "live_res_call") {
 
 		if (!live_edit_funcs->res_call_func)
 			return true;
-		live_edit_funcs->res_call_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);
+		live_edit_funcs->res_call_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4], p_command[5], p_command[6], p_command[7]);
 
 	} else if (cmdstr == "live_create_node") {
 
-		live_edit_funcs->tree_create_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->tree_create_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_instance_node") {
 
-		live_edit_funcs->tree_instance_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->tree_instance_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_remove_node") {
 
-		live_edit_funcs->tree_remove_node_func(live_edit_funcs->udata, cmd[1]);
+		live_edit_funcs->tree_remove_node_func(live_edit_funcs->udata, p_command[1]);
 
 	} else if (cmdstr == "live_remove_and_keep_node") {
 
-		live_edit_funcs->tree_remove_and_keep_node_func(live_edit_funcs->udata, cmd[1], cmd[2]);
+		live_edit_funcs->tree_remove_and_keep_node_func(live_edit_funcs->udata, p_command[1], p_command[2]);
 	} else if (cmdstr == "live_restore_node") {
 
-		live_edit_funcs->tree_restore_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
+		live_edit_funcs->tree_restore_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
 
 	} else if (cmdstr == "live_duplicate_node") {
 
-		live_edit_funcs->tree_duplicate_node_func(live_edit_funcs->udata, cmd[1], cmd[2]);
+		live_edit_funcs->tree_duplicate_node_func(live_edit_funcs->udata, p_command[1], p_command[2]);
 	} else if (cmdstr == "live_reparent_node") {
 
-		live_edit_funcs->tree_reparent_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4]);
+		live_edit_funcs->tree_reparent_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4]);
 
 	} else {
 
diff --git a/core/ustring.cpp b/core/ustring.cpp
index ab4528e495..0521966943 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -279,16 +279,16 @@ void String::operator=(const CharType *p_str) {
 	copy_from(p_str);
 }
 
-bool String::operator==(const StrRange &p_range) const {
+bool String::operator==(const StrRange &p_str_range) const {
 
-	int len = p_range.len;
+	int len = p_str_range.len;
 
 	if (length() != len)
 		return false;
 	if (empty())
 		return true;
 
-	const CharType *c_str = p_range.c_str;
+	const CharType *c_str = p_str_range.c_str;
 	const CharType *dst = &operator[](0);
 
 	/* Compare char by char */
diff --git a/core/ustring.h b/core/ustring.h
index d00bfa59b5..1c61e12e85 100644
--- a/core/ustring.h
+++ b/core/ustring.h
@@ -78,7 +78,7 @@ public:
 	//String operator+(CharType p_char) const;
 
 	String &operator+=(const String &);
-	String &operator+=(CharType p_str);
+	String &operator+=(CharType p_char);
 	String &operator+=(const char *p_str);
 	String &operator+=(const CharType *p_str);
 
@@ -156,7 +156,7 @@ public:
 
 	int get_slice_count(String p_splitter) const;
 	String get_slice(String p_splitter, int p_slice) const;
-	String get_slicec(CharType splitter, int p_slice) const;
+	String get_slicec(CharType p_splitter, int p_slice) const;
 
 	Vector<String> split(const String &p_splitter, bool p_allow_empty = true) const;
 	Vector<String> split_spaces() const;
@@ -186,8 +186,8 @@ public:
 	bool parse_utf8(const char *p_utf8, int p_len = -1); //return true on error
 	static String utf8(const char *p_utf8, int p_len = -1);
 
-	static uint32_t hash(const CharType *p_str, int p_len); /* hash the string */
-	static uint32_t hash(const CharType *p_str); /* hash the string */
+	static uint32_t hash(const CharType *p_cstr, int p_len); /* hash the string */
+	static uint32_t hash(const CharType *p_cstr); /* hash the string */
 	static uint32_t hash(const char *p_cstr, int p_len); /* hash the string */
 	static uint32_t hash(const char *p_cstr); /* hash the string */
 	uint32_t hash() const; /* hash the string */
diff --git a/core/variant_construct_string.cpp b/core/variant_construct_string.cpp
index 45fe367ce6..fa8a393d08 100644
--- a/core/variant_construct_string.cpp
+++ b/core/variant_construct_string.cpp
@@ -66,7 +66,7 @@ class VariantConstruct {
 	static Error _get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str);
 	static Error _parse_value(Variant &value, Token &token, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
 	static Error _parse_array(Array &array, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
-	static Error _parse_dict(Dictionary &object, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
+	static Error _parse_dict(Dictionary &dict, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
 
 public:
 	static Error parse(const String &p_string, Variant &r_ret, String &r_err_str, int &r_err_line, Variant::ObjectConstruct *p_construct, void *p_ud);
@@ -85,15 +85,15 @@ const char *VariantConstruct::tk_name[TK_MAX] = {
 	"EOF",
 };
 
-Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_token, int &line, String &r_err_str) {
+Error VariantConstruct::_get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str) {
 
 	while (true) {
-		switch (p_str[idx]) {
+		switch (p_str[index]) {
 
 			case '\n': {
 
 				line++;
-				idx++;
+				index++;
 				break;
 			};
 			case 0: {
@@ -103,54 +103,54 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
 			case '{': {
 
 				r_token.type = TK_CURLY_BRACKET_OPEN;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '}': {
 
 				r_token.type = TK_CURLY_BRACKET_CLOSE;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '[': {
 
 				r_token.type = TK_BRACKET_OPEN;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ']': {
 
 				r_token.type = TK_BRACKET_CLOSE;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ':': {
 
 				r_token.type = TK_COLON;
-				idx++;
+				index++;
 				return OK;
 			};
 			case ',': {
 
 				r_token.type = TK_COMMA;
-				idx++;
+				index++;
 				return OK;
 			};
 			case '"': {
 
-				idx++;
+				index++;
 				String str;
 				while (true) {
-					if (p_str[idx] == 0) {
+					if (p_str[index] == 0) {
 						r_err_str = "Unterminated String";
 						return ERR_PARSE_ERROR;
-					} else if (p_str[idx] == '"') {
-						idx++;
+					} else if (p_str[index] == '"') {
+						index++;
 						break;
-					} else if (p_str[idx] == '\\') {
+					} else if (p_str[index] == '\\') {
 						//escaped characters...
-						idx++;
-						CharType next = p_str[idx];
+						index++;
+						CharType next = p_str[index];
 						if (next == 0) {
 							r_err_str = "Unterminated String";
 							return ERR_PARSE_ERROR;
@@ -171,7 +171,7 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
 								//hexnumbarh - oct is deprecated
 
 								for (int j = 0; j < 4; j++) {
-									CharType c = p_str[idx + j + 1];
+									CharType c = p_str[index + j + 1];
 									if (c == 0) {
 										r_err_str = "Unterminated String";
 										return ERR_PARSE_ERROR;
@@ -198,7 +198,7 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
 									res <<= 4;
 									res |= v;
 								}
-								idx += 4; //will add at the end anyway
+								index += 4; //will add at the end anyway
 
 							} break;
 							default: {
@@ -211,11 +211,11 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
 						str += res;
 
 					} else {
-						if (p_str[idx] == '\n')
+						if (p_str[index] == '\n')
 							line++;
-						str += p_str[idx];
+						str += p_str[index];
 					}
-					idx++;
+					index++;
 				}
 
 				r_token.type = TK_STRING;
@@ -225,28 +225,28 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
 			} break;
 			default: {
 
-				if (p_str[idx] <= 32) {
-					idx++;
+				if (p_str[index] <= 32) {
+					index++;
 					break;
 				}
 
-				if (p_str[idx] == '-' || (p_str[idx] >= '0' && p_str[idx] <= '9')) {
+				if (p_str[index] == '-' || (p_str[index] >= '0' && p_str[index] <= '9')) {
 					//a number
 					const CharType *rptr;
-					double number = String::to_double(&p_str[idx], &rptr);
-					idx += (rptr - &p_str[idx]);
+					double number = String::to_double(&p_str[index], &rptr);
+					index += (rptr - &p_str[index]);
 					r_token.type = TK_NUMBER;
 					r_token.value = number;
 					return OK;
 
-				} else if ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
+				} else if ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
 
 					String id;
 
-					while ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
+					while ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
 
-						id += p_str[idx];
-						idx++;
+						id += p_str[index];
+						index++;
 					}
 
 					r_token.type = TK_IDENTIFIER;