Prevent some variable shadowing

Girgias · Girgias · commit c8107cbd717c · 2024-10-16T17:13:32.000+01:00
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -8003,9 +8003,8 @@ static void zend_compile_closure_uses(zend_ast *ast) /* {{{ */
 		ZVAL_NULL(&zv);
 
 		{
-			int i;
-			for (i = 0; i < op_array->last_var; i++) {
-				if (zend_string_equals(op_array->vars[i], var_name)) {
+			for (int var_index = 0; var_index < op_array->last_var; var_index++) {
+				if (zend_string_equals(op_array->vars[var_index], var_name)) {
 					zend_error_noreturn_unchecked(E_COMPILE_ERROR,
 						"Cannot use lexical variable $%S as a parameter name", var_name);
 				}
diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c
@@ -1328,9 +1328,9 @@ static inheritance_status verify_property_type_compatibility(
 		if (parent_info->hooks[ZEND_PROPERTY_HOOK_SET]
 		 && (!child_info->hooks || !child_info->hooks[ZEND_PROPERTY_HOOK_SET])) {
 			zend_type set_type = parent_info->hooks[ZEND_PROPERTY_HOOK_SET]->common.arg_info[0].type;
-			inheritance_status result = zend_perform_covariant_type_check(
+			inheritance_status hook_result = zend_perform_covariant_type_check(
 				parent_info->ce, set_type, child_info->ce, child_info->type);
-			if ((result == INHERITANCE_ERROR && throw_on_error) || (result == INHERITANCE_UNRESOLVED && throw_on_unresolved)) {
+			if ((hook_result == INHERITANCE_ERROR && throw_on_error) || (hook_result == INHERITANCE_UNRESOLVED && throw_on_unresolved)) {
 				emit_set_hook_type_error(child_info, parent_info);
 			}
 		}
@@ -2900,9 +2900,9 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent
 				zend_function **hooks = new_prop->hooks =
 					zend_arena_alloc(&CG(arena), ZEND_PROPERTY_HOOK_STRUCT_SIZE);
 				memcpy(hooks, property_info->hooks, ZEND_PROPERTY_HOOK_STRUCT_SIZE);
-				for (uint32_t i = 0; i < ZEND_PROPERTY_HOOK_COUNT; i++) {
-					if (hooks[i]) {
-						zend_function *old_fn = hooks[i];
+				for (uint32_t hook_index = 0; hook_index < ZEND_PROPERTY_HOOK_COUNT; hook_index++) {
+					if (hooks[hook_index]) {
+						const zend_function *old_fn = hooks[hook_index];
 
 						/* Hooks are not yet supported for internal properties. */
 						ZEND_ASSERT(ZEND_USER_CODE(old_fn->type));
@@ -2917,7 +2917,7 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent
 
 						zend_fixup_trait_method(new_fn, ce);
 
-						hooks[i] = new_fn;
+						hooks[hook_index] = new_fn;
 					}
 				}
 				ce->ce_flags |= ZEND_ACC_USE_GUARDS;
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
@@ -3663,21 +3663,17 @@ ZEND_API uint8_t ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t len
  * http://www.iti.fh-flensburg.de/lang/algorithmen/pattern/sundayen.htm
  */
 static zend_always_inline void zend_memnstr_ex_pre(unsigned int td[], const char *needle, size_t needle_len, int reverse) /* {{{ */ {
-	int i;
-
-	for (i = 0; i < 256; i++) {
+	for (unsigned int i = 0; i < 256; i++) {
 		td[i] = needle_len + 1;
 	}
 
 	if (reverse) {
-		for (i = needle_len - 1; i >= 0; i--) {
-			td[(unsigned char)needle[i]] = i + 1;
+		for (size_t i = needle_len; i > 0; i--) {
+			td[(unsigned char)needle[i-1]] = i;
 		}
 	} else {
-		size_t i;
-
-		for (i = 0; i < needle_len; i++) {
-			td[(unsigned char)needle[i]] = (int)needle_len - i;
+		for (size_t i = 0; i < needle_len; i++) {
+			td[(unsigned char)needle[i]] = needle_len - i;
 		}
 	}
 }
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -3240,8 +3240,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMP
 {
 	USE_OPLINE
 	zval *op1, *op2;
-	zend_string *op1_str, *op2_str, *str;
-
+	zend_string *op1_str, *op2_str;
 
 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
@@ -3343,7 +3342,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMP
 				break;
 			}
 		}
-		str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+		zend_string *str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
 		memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
 		memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
 
diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
@@ -1329,19 +1329,19 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, zend_string *subject_str,
 						 * arrays with NULLs or empty strings.
 						 */
 						if (count < num_subpats) {
-							for (int i = count; i < num_subpats; i++) {
+							for (int subpattern = count; subpattern < num_subpats; subpattern++) {
 								if (offset_capture) {
 									add_offset_pair(
-										match_sets[i], NULL, PCRE2_UNSET, PCRE2_UNSET,
+										match_sets[subpattern], NULL, PCRE2_UNSET, PCRE2_UNSET,
 										NULL, unmatched_as_null);
 								} else if (unmatched_as_null) {
 									zval tmp;
 									ZVAL_NULL(&tmp);
-									zend_hash_next_index_insert_new(match_sets[i], &tmp);
+									zend_hash_next_index_insert_new(match_sets[subpattern], &tmp);
 								} else {
 									zval tmp;
 									ZVAL_EMPTY_STRING(&tmp);
-									zend_hash_next_index_insert_new(match_sets[i], &tmp);
+									zend_hash_next_index_insert_new(match_sets[subpattern], &tmp);
 								}
 							}
 						}
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
@@ -2809,20 +2809,20 @@ PHP_METHOD(AppendIterator, __construct)
 /* {{{ Append an iterator */
 PHP_METHOD(AppendIterator, append)
 {
-	spl_dual_it_object   *intern;
-	zval *it;
+	spl_dual_it_object *intern;
+	zval *iterator;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &it, zend_ce_iterator) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &iterator, zend_ce_iterator) == FAILURE) {
 		RETURN_THROWS();
 	}
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
 
 	if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator) == SUCCESS && spl_dual_it_valid(intern) != SUCCESS) {
-		spl_array_iterator_append(&intern->u.append.zarrayit, it);
+		spl_array_iterator_append(&intern->u.append.zarrayit, iterator);
 		intern->u.append.iterator->funcs->move_forward(intern->u.append.iterator);
 	}else{
-		spl_array_iterator_append(&intern->u.append.zarrayit, it);
+		spl_array_iterator_append(&intern->u.append.zarrayit, iterator);
 	}
 
 	if (!intern->inner.iterator || spl_dual_it_valid(intern) != SUCCESS) {
diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c
@@ -339,9 +339,9 @@ static inline HashTable* spl_object_storage_debug_info(zend_object *obj) /* {{{
 		/* Incrementing the refcount of obj and inf would confuse the garbage collector.
 		 * Prefer to null the destructor */
 		Z_ARRVAL_P(&tmp)->pDestructor = NULL;
-		zval obj;
-		ZVAL_OBJ(&obj, element->obj);
-		add_assoc_zval_ex(&tmp, "obj", sizeof("obj") - 1, &obj);
+		zval element_obj;
+		ZVAL_OBJ(&element_obj, element->obj);
+		add_assoc_zval_ex(&tmp, "obj", sizeof("obj") - 1, &element_obj);
 		add_assoc_zval_ex(&tmp, "inf", sizeof("inf") - 1, &element->inf);
 		zend_hash_next_index_insert(Z_ARRVAL(storage), &tmp);
 	} ZEND_HASH_FOREACH_END();
diff --git a/ext/standard/array.c b/ext/standard/array.c
@@ -4209,10 +4209,10 @@ static zend_always_inline void php_array_replace_wrapper(INTERNAL_FUNCTION_PARAM
 
 
 	for (i = 0; i < argc; i++) {
-		zval *arg = args + i;
+		zval *check_arg = args + i;
 
-		if (Z_TYPE_P(arg) != IS_ARRAY) {
-			zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(arg));
+		if (Z_TYPE_P(check_arg) != IS_ARRAY) {
+			zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(check_arg));
 			RETURN_THROWS();
 		}
 	}
@@ -4264,13 +4264,13 @@ static zend_always_inline void php_array_merge_wrapper(INTERNAL_FUNCTION_PARAMET
 	}
 
 	for (i = 0; i < argc; i++) {
-		zval *arg = args + i;
+		zval *check_arg = args + i;
 
-		if (Z_TYPE_P(arg) != IS_ARRAY) {
-			zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(arg));
+		if (Z_TYPE_P(check_arg) != IS_ARRAY) {
+			zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(check_arg));
 			RETURN_THROWS();
 		}
-		count += zend_hash_num_elements(Z_ARRVAL_P(arg));
+		count += zend_hash_num_elements(Z_ARRVAL_P(check_arg));
 	}
 
 	if (argc == 2) {
diff --git a/ext/standard/dns.c b/ext/standard/dns.c
@@ -576,10 +576,10 @@ static uint8_t *php_parserr(uint8_t *cp, uint8_t *end, querybuf *answer, int typ
 			{
 				int l1 = 0, l2 = 0;
 				zval entries;
-				zend_string *tp;
+				zend_string *tp_str;
 
 				add_assoc_string(subarray, "type", "TXT");
-				tp = zend_string_alloc(dlen, 0);
+				tp_str = zend_string_alloc(dlen, 0);
 
 				array_init(&entries);
 
@@ -590,17 +590,17 @@ static uint8_t *php_parserr(uint8_t *cp, uint8_t *end, querybuf *answer, int typ
 						n = dlen - (l1 + 1);
 					}
 					if (n) {
-						memcpy(ZSTR_VAL(tp) + l2 , cp + l1 + 1, n);
+						memcpy(ZSTR_VAL(tp_str) + l2 , cp + l1 + 1, n);
 						add_next_index_stringl(&entries, (char *) cp + l1 + 1, n);
 					}
 					l1 = l1 + n + 1;
 					l2 = l2 + n;
 				}
-				ZSTR_VAL(tp)[l2] = '\0';
-				ZSTR_LEN(tp) = l2;
+				ZSTR_VAL(tp_str)[l2] = '\0';
+				ZSTR_LEN(tp_str) = l2;
 				cp += dlen;
 
-				add_assoc_str(subarray, "txt", tp);
+				add_assoc_str(subarray, "txt", tp_str);
 				add_assoc_zval(subarray, "entries", &entries);
 			}
 			break;
diff --git a/ext/standard/levenshtein.c b/ext/standard/levenshtein.c
@@ -20,7 +20,7 @@
  * reference implementation, only optimized for memory usage, not speed */
 static zend_long reference_levdist(const zend_string *string1, const zend_string *string2, zend_long cost_ins, zend_long cost_rep, zend_long cost_del )
 {
-	zend_long *p1, *p2, *tmp;
+	zend_long *p1, *p2;
 	zend_long c0, c1, c2;
 	size_t i1, i2;
 
@@ -61,7 +61,7 @@ static zend_long reference_levdist(const zend_string *string1, const zend_string
 			}
 			p2[i2 + 1] = c0;
 		}
-		tmp = p1;
+		zend_long *tmp = p1;
 		p1 = p2;
 		p2 = tmp;
 	}
diff --git a/ext/standard/var.c b/ext/standard/var.c
@@ -103,12 +103,7 @@ static const char *php_var_dump_object_prefix(zend_object *obj) {
 PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
 {
 	HashTable *myht;
-	zend_string *class_name;
 	int is_ref = 0;
-	zend_ulong num;
-	zend_string *key;
-	zval *val;
-	uint32_t count;
 
 	if (level > 1) {
 		php_printf("%*c", level - 1, ' ');
@@ -136,7 +131,7 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
 			PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
 			PUTS("\"\n");
 			break;
-		case IS_ARRAY:
+		case IS_ARRAY: {
 			myht = Z_ARRVAL_P(struc);
 			if (!(GC_FLAGS(myht) & GC_IMMUTABLE)) {
 				if (GC_IS_RECURSIVE(myht)) {
@@ -146,8 +141,11 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
 				GC_ADDREF(myht);
 				GC_PROTECT_RECURSION(myht);
 			}
-			count = zend_hash_num_elements(myht);
+			uint32_t count = zend_hash_num_elements(myht);
 			php_printf("%sarray(%d) {\n", COMMON, count);
+			zend_ulong num;
+			zend_string *key;
+			zval *val;
 			ZEND_HASH_FOREACH_KEY_VAL(myht, num, key, val) {
 				php_array_element_dump(val, num, key, level);
 			} ZEND_HASH_FOREACH_END();
@@ -160,6 +158,7 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
 			}
 			PUTS("}\n");
 			break;
+		}
 		case IS_OBJECT: {
 			zend_class_entry *ce = Z_OBJCE_P(struc);
 			if (ce->ce_flags & ZEND_ACC_ENUM) {
@@ -176,7 +175,7 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
 			ZEND_GUARD_OR_GC_PROTECT_RECURSION(guard, DEBUG, zobj);
 
 			myht = zend_get_properties_for(struc, ZEND_PROP_PURPOSE_DEBUG);
-			class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
+			zend_string *class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
 			const char *prefix = php_var_dump_object_prefix(Z_OBJ_P(struc));
 
 			php_printf("%s%sobject(%s)#%d (%d) {\n", COMMON, prefix, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0);
@@ -616,8 +615,8 @@ PHPAPI zend_result php_var_export_ex(zval *struc, int level, smart_str *buf) /*
 				smart_str_appendc(buf, '\\');
 				smart_str_append(buf, ce->name);
 				if (is_enum) {
-					zend_object *zobj = Z_OBJ_P(struc);
-					zval *case_name_zval = zend_enum_fetch_case_name(zobj);
+					zend_object *enum_obj = Z_OBJ_P(struc);
+					zval *case_name_zval = zend_enum_fetch_case_name(enum_obj);
 					smart_str_appendl(buf, "::", 2);
 					smart_str_append(buf, Z_STR_P(case_name_zval));
 				} else {

Original file line number	Diff line number	Diff line change
`@@ -8003,9 +8003,8 @@ static void zend_compile_closure_uses(zend_ast ast) / {{{ */`
`8003`	`8003`	`ZVAL_NULL(&zv);`
`8004`	`8004`
`8005`	`8005`	`{`
`8006`		`- int i;`
`8007`		`- for (i = 0; i < op_array->last_var; i++) {`
`8008`		`- if (zend_string_equals(op_array->vars[i], var_name)) {`
	`8006`	`+ for (int var_index = 0; var_index < op_array->last_var; var_index++) {`
	`8007`	`+ if (zend_string_equals(op_array->vars[var_index], var_name)) {`
`8009`	`8008`	`zend_error_noreturn_unchecked(E_COMPILE_ERROR,`
`8010`	`8009`	`"Cannot use lexical variable $%S as a parameter name", var_name);`
`8011`	`8010`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3663,21 +3663,17 @@ ZEND_API uint8_t ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t len`
`3663`	`3663`	`* http://www.iti.fh-flensburg.de/lang/algorithmen/pattern/sundayen.htm`
`3664`	`3664`	`*/`
`3665`	`3665`	`static zend_always_inline void zend_memnstr_ex_pre(unsigned int td[], const char needle, size_t needle_len, int reverse) / {{{ */ {`
`3666`		`- int i;`
`3667`		`-`
`3668`		`- for (i = 0; i < 256; i++) {`
	`3666`	`+ for (unsigned int i = 0; i < 256; i++) {`
`3669`	`3667`	`td[i] = needle_len + 1;`
`3670`	`3668`	`}`
`3671`	`3669`
`3672`	`3670`	`if (reverse) {`
`3673`		`- for (i = needle_len - 1; i >= 0; i--) {`
`3674`		`- td[(unsigned char)needle[i]] = i + 1;`
	`3671`	`+ for (size_t i = needle_len; i > 0; i--) {`
	`3672`	`+ td[(unsigned char)needle[i-1]] = i;`
`3675`	`3673`	`}`
`3676`	`3674`	`} else {`
`3677`		`- size_t i;`
`3678`		`-`
`3679`		`- for (i = 0; i < needle_len; i++) {`
`3680`		`- td[(unsigned char)needle[i]] = (int)needle_len - i;`
	`3675`	`+ for (size_t i = 0; i < needle_len; i++) {`
	`3676`	`+ td[(unsigned char)needle[i]] = needle_len - i;`
`3681`	`3677`	`}`
`3682`	`3678`	`}`
`3683`	`3679`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3240,8 +3240,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST\|TMPVAR\|CV, CONST\|TMP`
`3240`	`3240`	`{`
`3241`	`3241`	`USE_OPLINE`
`3242`	`3242`	`zval op1, op2;`
`3243`		`- zend_string op1_str, op2_str, *str;`
`3244`		`-`
	`3243`	`+ zend_string op1_str, op2_str;`
`3245`	`3244`
`3246`	`3245`	`op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);`
`3247`	`3246`	`op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);`
`@@ -3343,7 +3342,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST\|TMPVAR\|CV, CONST\|TMP`
`3343`	`3342`	`break;`
`3344`	`3343`	`}`
`3345`	`3344`	`}`
`3346`		`- str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);`
	`3345`	`+ zend_string *str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);`
`3347`	`3346`	`memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));`
`3348`	`3347`	`memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);`
`3349`	`3348`
Original file line number	Diff line number	Diff line change
`@@ -4209,10 +4209,10 @@ static zend_always_inline void php_array_replace_wrapper(INTERNAL_FUNCTION_PARAM`
`4209`	`4209`
`4210`	`4210`
`4211`	`4211`	`for (i = 0; i < argc; i++) {`
`4212`		`- zval *arg = args + i;`
	`4212`	`+ zval *check_arg = args + i;`
`4213`	`4213`
`4214`		`- if (Z_TYPE_P(arg) != IS_ARRAY) {`
`4215`		`- zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(arg));`
	`4214`	`+ if (Z_TYPE_P(check_arg) != IS_ARRAY) {`
	`4215`	`+ zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(check_arg));`
`4216`	`4216`	`RETURN_THROWS();`
`4217`	`4217`	`}`
`4218`	`4218`	`}`
`@@ -4264,13 +4264,13 @@ static zend_always_inline void php_array_merge_wrapper(INTERNAL_FUNCTION_PARAMET`
`4264`	`4264`	`}`
`4265`	`4265`
`4266`	`4266`	`for (i = 0; i < argc; i++) {`
`4267`		`- zval *arg = args + i;`
	`4267`	`+ zval *check_arg = args + i;`
`4268`	`4268`
`4269`		`- if (Z_TYPE_P(arg) != IS_ARRAY) {`
`4270`		`- zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(arg));`
	`4269`	`+ if (Z_TYPE_P(check_arg) != IS_ARRAY) {`
	`4270`	`+ zend_argument_type_error(i + 1, "must be of type array, %s given", zend_zval_value_name(check_arg));`
`4271`	`4271`	`RETURN_THROWS();`
`4272`	`4272`	`}`
`4273`		`- count += zend_hash_num_elements(Z_ARRVAL_P(arg));`
	`4273`	`+ count += zend_hash_num_elements(Z_ARRVAL_P(check_arg));`
`4274`	`4274`	`}`
`4275`	`4275`
`4276`	`4276`	`if (argc == 2) {`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`* reference implementation, only optimized for memory usage, not speed */`
`21`	`21`	`static zend_long reference_levdist(const zend_string string1, const zend_string string2, zend_long cost_ins, zend_long cost_rep, zend_long cost_del )`
`22`	`22`	`{`
`23`		`- zend_long p1, p2, *tmp;`
	`23`	`+ zend_long p1, p2;`
`24`	`24`	`zend_long c0, c1, c2;`
`25`	`25`	`size_t i1, i2;`
`26`	`26`
`@@ -61,7 +61,7 @@ static zend_long reference_levdist(const zend_string *string1, const zend_string`
`61`	`61`	`}`
`62`	`62`	`p2[i2 + 1] = c0;`
`63`	`63`	`}`
`64`		`- tmp = p1;`
	`64`	`+ zend_long *tmp = p1;`
`65`	`65`	`p1 = p2;`
`66`	`66`	`p2 = tmp;`
`67`	`67`	`}`