Implement delayed variance checks and other fixes

kocsismate · kocsismate · commit db58d12e5e0c · 2023-03-24T16:32:41.000+01:00
diff --git a/Zend/tests/type_declarations/typed_class_constants_inheritance_error1.phpt b/Zend/tests/type_declarations/typed_class_constants_inheritance_error1.phpt
@@ -11,4 +11,4 @@ class B extends A {
 }
 ?>
 --EXPECTF--
-Fatal error: Declaration of B::CONST1 must be compatible with A::CONST1 in %s on line %d
+Fatal error: Type of B::CONST1 must be compatible with A::CONST1 of type int in %s on line %d
diff --git a/Zend/tests/type_declarations/typed_class_constants_inheritance_error2.phpt b/Zend/tests/type_declarations/typed_class_constants_inheritance_error2.phpt
@@ -11,4 +11,4 @@ class B extends A {
 }
 ?>
 --EXPECTF--
-Fatal error: Declaration of B::CONST1 must be compatible with A::CONST1 in %s on line %d
+Fatal error: Type of B::CONST1 must be compatible with A::CONST1 of type int in %s on line %d
diff --git a/Zend/tests/type_declarations/typed_class_constants_type_error10.phpt b/Zend/tests/type_declarations/typed_class_constants_type_error10.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Typed class constants (type error)
+--FILE--
+<?php
+class A1 {
+    const ?B1 C = null;
+}
+
+class A2 extends A1 {
+    const ?B2 C = null;
+}
+
+?>
+--EXPECTF--
+Fatal error: Type of A2::C must be compatible with A1::C of type ?B1 in %s on line %d
diff --git a/Zend/tests/type_declarations/typed_class_constants_type_error11.phpt b/Zend/tests/type_declarations/typed_class_constants_type_error11.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Typed class constants (static type error)
+--FILE--
+<?php
+enum E1 {
+    const static C = E2::Foo;
+}
+
+enum E2 {
+   case Foo;
+}
+
+try {
+    var_dump(E1::C);
+} catch (TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+Cannot assign E2 to class constant E1::C of type static
diff --git a/Zend/tests/type_declarations/typed_class_constants_type_success3.phpt b/Zend/tests/type_declarations/typed_class_constants_type_success3.phpt
@@ -25,10 +25,15 @@ var_dump(A::CONST1);
 var_dump(A::CONST1);
 var_dump(A::CONST2);
 var_dump(A::CONST2);
+var_dump(E::CONST3);
+var_dump(E::CONST3);
 var_dump(A::CONST3);
 var_dump(A::CONST3);
+var_dump(E::CONST4);
+var_dump(E::CONST4);
 var_dump(A::CONST4);
 var_dump(A::CONST4);
+
 ?>
 --EXPECT--
 enum(E::Foo)
@@ -41,3 +46,7 @@ enum(E::Foo)
 enum(E::Foo)
 enum(E::Foo)
 enum(E::Foo)
+enum(E::Foo)
+enum(E::Foo)
+enum(E::Foo)
+enum(E::Foo)
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -1413,7 +1413,7 @@ static zend_result update_property(zval *val, zend_property_info *prop_info) {
 	return zval_update_constant_ex(val, prop_info->ce);
 }
 
-ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_class_entry *scope)
+ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, const zend_string *name, zend_class_entry *scope)
 {
 	ZEND_ASSERT(Z_TYPE(c->value) == IS_CONSTANT_AST);
 
@@ -1430,7 +1430,7 @@ ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_cla
 		return FAILURE;
 	}
 
-	if (UNEXPECTED(!zend_verify_class_constant_type(c, &tmp))) {
+	if (UNEXPECTED(!zend_verify_class_constant_type(c, name, &tmp))) {
 		zval_ptr_dtor(&tmp);
 		return FAILURE;
 	}
@@ -1499,7 +1499,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 				}
 
 				val = &c->value;
-				if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {
+				if (UNEXPECTED(zend_update_class_constant(c, name, c->ce) != SUCCESS)) {
 					return FAILURE;
 				}
 			}
@@ -4594,7 +4594,6 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry
 	c->doc_comment = doc_comment;
 	c->attributes = NULL;
 	c->ce = ce;
-	c->name = name;
 	c->type = type;
 
 	if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
@@ -440,7 +440,7 @@ ZEND_API void zend_declare_class_constant_double(zend_class_entry *ce, const cha
 ZEND_API void zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length);
 ZEND_API void zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value);
 
-ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_class_entry *scope);
+ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, const zend_string *name, zend_class_entry *scope);
 ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type);
 ZEND_API HashTable *zend_separate_class_constants_table(zend_class_entry *class_type);
 
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
@@ -404,7 +404,6 @@ typedef struct _zend_property_info {
 
 typedef struct _zend_class_constant {
 	zval value; /* flags are stored in u2 */
-	zend_string *name;
 	zend_string *doc_comment;
 	HashTable *attributes;
 	zend_class_entry *ce;
diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
@@ -373,7 +373,7 @@ ZEND_API zval *zend_get_class_constant_ex(zend_string *class_name, zend_string *
 		}
 
 		MARK_CONSTANT_VISITED(ret_constant);
-		ret = zend_update_class_constant(c, c->ce);
+		ret = zend_update_class_constant(c, constant_name, c->ce);
 		RESET_CONSTANT_VISITED(ret_constant);
 
 		if (UNEXPECTED(ret != SUCCESS)) {
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -828,12 +828,12 @@ ZEND_API bool zend_verify_scalar_type_hint(uint32_t type_mask, zval *arg, bool s
 	return zend_verify_weak_scalar_type_hint(type_mask, arg);
 }
 
-ZEND_COLD zend_never_inline void zend_verify_class_constant_type_error(const zend_class_constant *c, const zval *constant)
+ZEND_COLD zend_never_inline void zend_verify_class_constant_type_error(const zend_class_constant *c, const zend_string *name, const zval *constant)
 {
 	zend_string *type_str = zend_type_to_string(c->type);
 
 	zend_type_error("Cannot assign %s to class constant %s::%s of type %s",
-		zend_zval_type_name(constant), ZSTR_VAL(c->ce->name), ZSTR_VAL(c->name), ZSTR_VAL(type_str));
+		zend_zval_type_name(constant), ZSTR_VAL(c->ce->name), ZSTR_VAL(name), ZSTR_VAL(type_str));
 
 	zend_string_release(type_str);
 }
@@ -979,7 +979,7 @@ if (ZEND_TYPE_HAS_LIST(member_type)) {
 			return false;
 		}
 	} else if ((ZEND_TYPE_PURE_MASK(member_type) & MAY_BE_STATIC)) {
-		return instanceof_function(value_ce, scope);
+		return value_ce == scope;
 	} else {
 		const zend_class_entry *ce = zend_ce_from_type(scope, &member_type);
 		return ce && instanceof_function(value_ce, ce);
@@ -1492,10 +1492,10 @@ static zend_always_inline bool zend_check_class_constant_type(zend_class_constan
 	return zend_verify_scalar_type_hint(type_mask, constant, true, false);
 }
 
-ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant *c, zval *constant)
+ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant *c, const zend_string *name, zval *constant)
 {
 	if (!zend_check_class_constant_type(c, constant)) {
-		zend_verify_class_constant_type_error(c, constant);
+		zend_verify_class_constant_type_error(c, name, constant);
 		return 0;
 	}
 
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
@@ -466,8 +466,8 @@ ZEND_API int ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *call);
 #define ZEND_CLASS_HAS_READONLY_PROPS(ce) ((ce->ce_flags & ZEND_ACC_HAS_READONLY_PROPS) == ZEND_ACC_HAS_READONLY_PROPS)
 
 
-ZEND_API bool zend_verify_class_constant_type(zend_class_constant *c, zval *constant);
-ZEND_COLD void zend_verify_class_constant_type_error(const zend_class_constant *c, const zval *constant);
+ZEND_API bool zend_verify_class_constant_type(zend_class_constant *c, const zend_string *name, zval *constant);
+ZEND_COLD void zend_verify_class_constant_type_error(const zend_class_constant *c, const zend_string *name, const zval *constant);
 
 ZEND_API bool zend_verify_property_type(const zend_property_info *info, zval *property, bool strict);
 ZEND_COLD void zend_verify_property_type_error(const zend_property_info *info, const zval *property);
diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c
@@ -51,6 +51,9 @@ static void add_compatibility_obligation(
 static void add_property_compatibility_obligation(
 		zend_class_entry *ce, const zend_property_info *child_prop,
 		const zend_property_info *parent_prop);
+static void add_class_constant_compatibility_obligation(
+		zend_class_entry *ce, const zend_class_constant *child_const,
+		const zend_class_constant *parent_const, const zend_string *const_name);
 
 static void ZEND_COLD emit_incompatible_method_error(
 		const zend_function *child, zend_class_entry *child_scope,
@@ -1359,8 +1362,22 @@ static void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_en
 }
 /* }}} */
 
+static void emit_incompatible_class_constant_error(
+		const zend_class_constant *child, const zend_class_constant *parent, const zend_string *const_name) {
+	zend_string *type_str = zend_type_to_string_resolved(parent->type, parent->ce);
+	zend_error_noreturn(E_COMPILE_ERROR,
+		"Type of %s::%s must be compatible with %s::%s of type %s",
+		ZSTR_VAL(child->ce->name),
+		ZSTR_VAL(const_name),
+		ZSTR_VAL(parent->ce->name),
+		ZSTR_VAL(const_name),
+		ZSTR_VAL(type_str));
+}
+
 static inheritance_status class_constant_types_compatible(const zend_class_constant *parent, const zend_class_constant *child)
 {
+	ZEND_ASSERT(ZEND_TYPE_IS_SET(parent->type));
+
 	if (!ZEND_TYPE_IS_SET(child->type)) {
 		return INHERITANCE_ERROR;
 	}
@@ -1393,10 +1410,11 @@ static void do_inherit_class_constant(zend_string *name, zend_class_constant *pa
 		}
 
 		if (!(ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PRIVATE) && UNEXPECTED(ZEND_TYPE_IS_SET(parent_const->type))) {
-			if (class_constant_types_compatible(parent_const, c) == INHERITANCE_ERROR) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s must be compatible with %s::%s",
-					ZSTR_VAL(c->ce->name), ZSTR_VAL(name), ZSTR_VAL(parent_const->ce->name), ZSTR_VAL(name)
-				);
+			inheritance_status status = class_constant_types_compatible(parent_const, c);
+			if (status == INHERITANCE_ERROR) {
+				emit_incompatible_class_constant_error(c, parent_const, name);
+			} else if (status == INHERITANCE_UNRESOLVED) {
+				add_class_constant_compatibility_obligation(ce, c, parent_const, name);
 			}
 		}
 	} else if (!(ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PRIVATE)) {
@@ -2555,7 +2573,8 @@ typedef struct {
 	enum {
 		OBLIGATION_DEPENDENCY,
 		OBLIGATION_COMPATIBILITY,
-		OBLIGATION_PROPERTY_COMPATIBILITY
+		OBLIGATION_PROPERTY_COMPATIBILITY,
+		OBLIGATION_CLASS_CONSTANT_COMPATIBILITY
 	} type;
 	union {
 		zend_class_entry *dependency_ce;
@@ -2571,6 +2590,11 @@ typedef struct {
 			const zend_property_info *parent_prop;
 			const zend_property_info *child_prop;
 		};
+		struct {
+			const zend_string *const_name;
+			const zend_class_constant *parent_const;
+			const zend_class_constant *child_const;
+		};
 	};
 } variance_obligation;
 
@@ -2646,6 +2670,18 @@ static void add_property_compatibility_obligation(
 	zend_hash_next_index_insert_ptr(obligations, obligation);
 }
 
+static void add_class_constant_compatibility_obligation(
+		zend_class_entry *ce, const zend_class_constant *child_const,
+		const zend_class_constant *parent_const, const zend_string *const_name) {
+	HashTable *obligations = get_or_init_obligations_for_class(ce);
+	variance_obligation *obligation = emalloc(sizeof(variance_obligation));
+	obligation->type = OBLIGATION_CLASS_CONSTANT_COMPATIBILITY;
+	obligation->const_name = const_name;
+	obligation->child_const = child_const;
+	obligation->parent_const = parent_const;
+	zend_hash_next_index_insert_ptr(obligations, obligation);
+}
+
 static void resolve_delayed_variance_obligations(zend_class_entry *ce);
 
 static void check_variance_obligation(variance_obligation *obligation) {
@@ -2669,13 +2705,19 @@ static void check_variance_obligation(variance_obligation *obligation) {
 				&obligation->parent_fn, obligation->parent_scope, status);
 		}
 		/* Either the compatibility check was successful or only threw a warning. */
-	} else {
-		ZEND_ASSERT(obligation->type == OBLIGATION_PROPERTY_COMPATIBILITY);
+	} else if (obligation->type == OBLIGATION_PROPERTY_COMPATIBILITY) {
 		inheritance_status status =
 			property_types_compatible(obligation->parent_prop, obligation->child_prop);
 		if (status != INHERITANCE_SUCCESS) {
 			emit_incompatible_property_error(obligation->child_prop, obligation->parent_prop);
 		}
+	} else {
+		ZEND_ASSERT(obligation->type == OBLIGATION_CLASS_CONSTANT_COMPATIBILITY);
+		inheritance_status status =
+		class_constant_types_compatible(obligation->parent_const, obligation->child_const);
+		if (status != INHERITANCE_SUCCESS) {
+			emit_incompatible_class_constant_error(obligation->child_const, obligation->parent_const, obligation->const_name);
+		}
 	}
 }
 
@@ -3139,6 +3181,7 @@ static inheritance_status zend_can_early_bind(zend_class_entry *ce, zend_class_e
 	zend_string *key;
 	zend_function *parent_func;
 	zend_property_info *parent_info;
+	zend_class_constant *parent_const;
 	inheritance_status overall_status = INHERITANCE_SUCCESS;
 
 	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, parent_func) {
@@ -3177,6 +3220,25 @@ static inheritance_status zend_can_early_bind(zend_class_entry *ce, zend_class_e
 		}
 	} ZEND_HASH_FOREACH_END();
 
+	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->constants_table, key, parent_const) {
+		zval *zv;
+		if ((ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PRIVATE) || !ZEND_TYPE_IS_SET(parent_const->type)) {
+			continue;
+		}
+
+		zv = zend_hash_find_known_hash(&ce->constants_table, key);
+		if (zv) {
+			zend_class_constant *child_const = Z_PTR_P(zv);
+			if (ZEND_TYPE_IS_SET(child_const->type)) {
+				inheritance_status status = class_constant_types_compatible(parent_const, child_const);
+				ZEND_ASSERT(status != INHERITANCE_WARNING);
+				if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
+					return status;
+				}
+			}
+		}
+	} ZEND_HASH_FOREACH_END();
+
 	return overall_status;
 }
 /* }}} */
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -5955,7 +5955,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO
 				}
 			}
 			if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
-				if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {
+				if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
 					ZVAL_UNDEF(EX_VAR(opline->result.var));
 					FREE_OP2();
 					HANDLE_EXCEPTION();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c

Original file line number	Diff line number	Diff line change
`@@ -11,4 +11,4 @@ class B extends A {`
`11`	`11`	`}`
`12`	`12`	`?>`
`13`	`13`	`--EXPECTF--`
`14`		`-Fatal error: Declaration of B::CONST1 must be compatible with A::CONST1 in %s on line %d`
	`14`	`+Fatal error: Type of B::CONST1 must be compatible with A::CONST1 of type int in %s on line %d`
Original file line number	Diff line number	Diff line change
`@@ -1413,7 +1413,7 @@ static zend_result update_property(zval val, zend_property_info prop_info) {`
`1413`	`1413`	`return zval_update_constant_ex(val, prop_info->ce);`
`1414`	`1414`	`}`
`1415`	`1415`
`1416`		`-ZEND_API zend_result zend_update_class_constant(zend_class_constant c, zend_class_entry scope)`
	`1416`	`+ZEND_API zend_result zend_update_class_constant(zend_class_constant c, const zend_string name, zend_class_entry *scope)`
`1417`	`1417`	`{`
`1418`	`1418`	`ZEND_ASSERT(Z_TYPE(c->value) == IS_CONSTANT_AST);`
`1419`	`1419`
`@@ -1430,7 +1430,7 @@ ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_cla`
`1430`	`1430`	`return FAILURE;`
`1431`	`1431`	`}`
`1432`	`1432`
`1433`		`- if (UNEXPECTED(!zend_verify_class_constant_type(c, &tmp))) {`
	`1433`	`+ if (UNEXPECTED(!zend_verify_class_constant_type(c, name, &tmp))) {`
`1434`	`1434`	`zval_ptr_dtor(&tmp);`
`1435`	`1435`	`return FAILURE;`
`1436`	`1436`	`}`
`@@ -1499,7 +1499,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /`
`1499`	`1499`	`}`
`1500`	`1500`
`1501`	`1501`	`val = &c->value;`
`1502`		`- if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {`
	`1502`	`+ if (UNEXPECTED(zend_update_class_constant(c, name, c->ce) != SUCCESS)) {`
`1503`	`1503`	`return FAILURE;`
`1504`	`1504`	`}`
`1505`	`1505`	`}`
`@@ -4594,7 +4594,6 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry`
`4594`	`4594`	`c->doc_comment = doc_comment;`
`4595`	`4595`	`c->attributes = NULL;`
`4596`	`4596`	`c->ce = ce;`
`4597`		`- c->name = name;`
`4598`	`4597`	`c->type = type;`
`4599`	`4598`
`4600`	`4599`	`if (Z_TYPE_P(value) == IS_CONSTANT_AST) {`
Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ ZEND_API zval zend_get_class_constant_ex(zend_string class_name, zend_string *`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`MARK_CONSTANT_VISITED(ret_constant);`
`376`		`- ret = zend_update_class_constant(c, c->ce);`
	`376`	`+ ret = zend_update_class_constant(c, constant_name, c->ce);`
`377`	`377`	`RESET_CONSTANT_VISITED(ret_constant);`
`378`	`378`
`379`	`379`	`if (UNEXPECTED(ret != SUCCESS)) {`
Original file line number	Diff line number	Diff line change
`@@ -828,12 +828,12 @@ ZEND_API bool zend_verify_scalar_type_hint(uint32_t type_mask, zval *arg, bool s`
`828`	`828`	`return zend_verify_weak_scalar_type_hint(type_mask, arg);`
`829`	`829`	`}`
`830`	`830`
`831`		`-ZEND_COLD zend_never_inline void zend_verify_class_constant_type_error(const zend_class_constant c, const zval constant)`
	`831`	`+ZEND_COLD zend_never_inline void zend_verify_class_constant_type_error(const zend_class_constant c, const zend_string name, const zval *constant)`
`832`	`832`	`{`
`833`	`833`	`zend_string *type_str = zend_type_to_string(c->type);`
`834`	`834`
`835`	`835`	`zend_type_error("Cannot assign %s to class constant %s::%s of type %s",`
`836`		`- zend_zval_type_name(constant), ZSTR_VAL(c->ce->name), ZSTR_VAL(c->name), ZSTR_VAL(type_str));`
	`836`	`+ zend_zval_type_name(constant), ZSTR_VAL(c->ce->name), ZSTR_VAL(name), ZSTR_VAL(type_str));`
`837`	`837`
`838`	`838`	`zend_string_release(type_str);`
`839`	`839`	`}`
`@@ -979,7 +979,7 @@ if (ZEND_TYPE_HAS_LIST(member_type)) {`
`979`	`979`	`return false;`
`980`	`980`	`}`
`981`	`981`	`} else if ((ZEND_TYPE_PURE_MASK(member_type) & MAY_BE_STATIC)) {`
`982`		`- return instanceof_function(value_ce, scope);`
	`982`	`+ return value_ce == scope;`
`983`	`983`	`} else {`
`984`	`984`	`const zend_class_entry *ce = zend_ce_from_type(scope, &member_type);`
`985`	`985`	`return ce && instanceof_function(value_ce, ce);`
`@@ -1492,10 +1492,10 @@ static zend_always_inline bool zend_check_class_constant_type(zend_class_constan`
`1492`	`1492`	`return zend_verify_scalar_type_hint(type_mask, constant, true, false);`
`1493`	`1493`	`}`
`1494`	`1494`
`1495`		`-ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant c, zval constant)`
	`1495`	`+ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant c, const zend_string name, zval *constant)`
`1496`	`1496`	`{`
`1497`	`1497`	`if (!zend_check_class_constant_type(c, constant)) {`
`1498`		`- zend_verify_class_constant_type_error(c, constant);`
	`1498`	`+ zend_verify_class_constant_type_error(c, name, constant);`
`1499`	`1499`	`return 0;`
`1500`	`1500`	`}`
`1501`	`1501`