Prevent some variable shadowing

Author: Girgias

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);
 				}

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;

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;
 		}
 	}
 }

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);
 

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);
 								}
 							}
 						}

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) {

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();

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) {

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;

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;
 	}

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 {