start making \\ the separator instead of :>

Author: withinboredom

Zend/zend_compile.c

@@ -1099,6 +1099,21 @@ static zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2
 	return zend_string_concat3(name1, name1_len, "\\", 1, name2, name2_len);
 }
 
+static zend_string *zend_prefix_with_outer_class(zend_string *name) {
+	ZEND_ASSERT(CG(active_class_entry));
+
+	zend_string *ns = CG(active_class_entry)->name;
+
+	// If the current ns is the current name, return the ns.
+	// we only need to check if ns[len(ns) - len(name) + 1] == '\\' and the end of ns is name.
+	if (ZSTR_LEN(ns) >= ZSTR_LEN(name) && ZSTR_VAL(ns)[ZSTR_LEN(ns) - ZSTR_LEN(name) - 1] == '\\'
+		&& memcmp(ZSTR_VAL(ns) + ZSTR_LEN(ns) - ZSTR_LEN(name), ZSTR_VAL(name), ZSTR_LEN(name)) == 0) {
+		return zend_string_copy(ns);
+		}
+
+	return zend_concat_names(ZSTR_VAL(ns), ZSTR_LEN(ns), ZSTR_VAL(name), ZSTR_LEN(name));
+}
+
 static zend_string *zend_prefix_with_ns(zend_string *name) {
 	if (FC(current_namespace)) {
 		zend_string *ns = FC(current_namespace);
@@ -1236,6 +1251,10 @@ static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /*
 		}
 	}
 
+	if (CG(active_class_entry)) {
+		return zend_prefix_with_outer_class(name);
+	}
+
 	/* If not fully qualified and not an alias, prepend the current namespace */
 	return zend_prefix_with_ns(name);
 }
@@ -9093,10 +9112,9 @@ static void zend_compile_use_trait(zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
-static void zend_compile_implements(zend_ast *ast) /* {{{ */
+static void zend_compile_implements(zend_ast *ast, zend_class_entry *ce) /* {{{ */
 {
 	zend_ast_list *list = zend_ast_get_list(ast);
-	zend_class_entry *ce = CG(active_class_entry);
 	zend_class_name *interface_names;
 	uint32_t i;
 
@@ -9154,6 +9172,18 @@ static void zend_compile_enum_backing_type(zend_class_entry *ce, zend_ast *enum_
 	zend_type_release(type, 0);
 }
 
+HashTable *inner_class_queue = NULL;
+
+static void zend_defer_class_decl(zend_ast *ast)
+{
+	if (inner_class_queue == NULL) {
+		ALLOC_HASHTABLE(inner_class_queue);
+		zend_hash_init(inner_class_queue, 0, NULL, ZVAL_PTR_DTOR, 0);
+	}
+
+	zend_hash_next_index_insert_ptr(inner_class_queue, ast);
+}
+
 static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) /* {{{ */
 {
 	zend_ast_decl *decl = (zend_ast_decl *) ast;
@@ -9188,7 +9218,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 			// rename the inner class so we may reference it by name
 			name = zend_string_concat3(
 				ZSTR_VAL(CG(active_class_entry)->name), ZSTR_LEN(CG(active_class_entry)->name),
-				":>", 2,
+				"\\", 1,
 				ZSTR_VAL(unqualified_name), ZSTR_LEN(unqualified_name)
 			);
 
@@ -9284,16 +9314,16 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 			zend_resolve_const_class_name_reference(extends_ast, "class name");
 	}
 
+	if (implements_ast) {
+		zend_compile_implements(implements_ast, ce);
+	}
+
 	CG(active_class_entry) = ce;
 
 	if (decl->child[3]) {
 		zend_compile_attributes(&ce->attributes, decl->child[3], 0, ZEND_ATTRIBUTE_TARGET_CLASS, 0);
 	}
 
-	if (implements_ast) {
-		zend_compile_implements(implements_ast);
-	}
-
 	if (ce->ce_flags & ZEND_ACC_ENUM) {
 		if (enum_backing_type_ast != NULL) {
 			zend_compile_enum_backing_type(ce, enum_backing_type_ast);
@@ -9311,8 +9341,6 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 		zend_verify_abstract_class(ce);
 	}
 
-	CG(active_class_entry) = original_ce;
-
 	if (toplevel) {
 		ce->ce_flags |= ZEND_ACC_TOP_LEVEL;
 	}
@@ -9333,7 +9361,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 				 && !zend_compile_ignore_class(parent_ce, ce->info.user.filename)) {
 					if (zend_try_early_bind(ce, parent_ce, lcname, NULL)) {
 						zend_string_release(lcname);
-						return;
+						goto compile_inner_classes;
 					}
 				}
 			} else if (EXPECTED(zend_hash_add_ptr(CG(class_table), lcname, ce) != NULL)) {
@@ -9342,7 +9370,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 				zend_inheritance_check_override(ce);
 				ce->ce_flags |= ZEND_ACC_LINKED;
 				zend_observer_class_linked_notify(ce, lcname);
-				return;
+				goto compile_inner_classes;
 			} else {
 				goto link_unbound;
 			}
@@ -9412,6 +9440,25 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 			opline->result.opline_num = -1;
 		}
 	}
+
+	compile_inner_classes:
+
+	if (inner_class_queue == NULL) {
+		CG(active_class_entry) = original_ce;
+		return;
+	}
+
+	HashTable *queue = inner_class_queue;
+	inner_class_queue = NULL;
+
+	ZEND_HASH_FOREACH_PTR(queue, ast) {
+		zend_compile_class_decl(NULL, ast, 0);
+	} ZEND_HASH_FOREACH_END();
+
+	CG(active_class_entry) = original_ce;
+
+	zend_hash_destroy(queue);
+	FREE_HASHTABLE(queue);
 }
 /* }}} */
 
@@ -11682,6 +11729,10 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */
 			zend_compile_use_trait(ast);
 			break;
 		case ZEND_AST_CLASS:
+			if (CG(active_class_entry)) {
+				zend_defer_class_decl(ast);
+				break;
+			}
 			zend_compile_class_decl(NULL, ast, 0);
 			break;
 		case ZEND_AST_GROUP_USE:

Zend/zend_compile.h

@@ -1028,14 +1028,15 @@ ZEND_API zend_string *zend_type_to_string(zend_type type);
 #define ZEND_FETCH_CLASS_EXCEPTION   0x0200
 #define ZEND_FETCH_CLASS_ALLOW_UNLINKED 0x0400
 #define ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED 0x0800
+#define ZEND_FETCH_CLASS_NO_INNER    0x1000
 
 /* These should not clash with ZEND_ACC_PPP_MASK and ZEND_ACC_PPP_SET_MASK */
 #define ZEND_PARAM_REF      (1<<3)
 #define ZEND_PARAM_VARIADIC (1<<4)
 
-#define ZEND_NAME_FQ       0
-#define ZEND_NAME_NOT_FQ   1
-#define ZEND_NAME_RELATIVE 2
+#define ZEND_NAME_FQ          0
+#define ZEND_NAME_NOT_FQ      1
+#define ZEND_NAME_RELATIVE    2
 
 /* ZEND_FETCH_ flags in class name AST of new const expression must not clash with ZEND_NAME_ flags */
 #define ZEND_CONST_EXPR_NEW_FETCH_TYPE_SHIFT 2

Zend/zend_execute_API.c

@@ -1166,6 +1166,79 @@ ZEND_API bool zend_is_valid_class_name(zend_string *name) {
 	return 1;
 }
 
+static zend_class_entry *zend_resolve_nested_class(zend_string *requested_name, uint32_t flags) {
+	zend_class_entry *ce = NULL;
+	char *separator;
+	zend_string *scope_name = zend_string_copy(requested_name);
+
+	const char *unqualified_name = strrchr(ZSTR_VAL(scope_name), '\\');
+	zend_string *inner_name = zend_string_init(unqualified_name, ZSTR_LEN(scope_name) - (unqualified_name - ZSTR_VAL(scope_name)), 0);
+
+	while ((separator = strrchr(ZSTR_VAL(scope_name), '\\'))) {
+		const size_t outer_len = separator - ZSTR_VAL(scope_name);
+
+		zend_string *outer_class_name = zend_string_init(ZSTR_VAL(scope_name), outer_len, 0);
+		const zend_class_entry *outer_ce = zend_lookup_class_ex(outer_class_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER);
+
+		if (outer_ce) {
+			// Outer class found; now explicitly check the requested class again
+			ce = zend_lookup_class_ex(requested_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER);
+			if (ce) {
+				zend_string_release(scope_name);
+				zend_string_release(outer_class_name);
+				zend_string_release(inner_name);
+				return ce;
+			}
+
+			// Check if the class is in the outer scope
+			zend_string *outer_name = zend_string_concat2(ZSTR_VAL(outer_class_name), ZSTR_LEN(outer_class_name), ZSTR_VAL(inner_name), ZSTR_LEN(inner_name));
+			ce = zend_lookup_class_ex(outer_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER);
+			zend_string_release(outer_name);
+			zend_string_release(outer_class_name);
+			if (ce) {
+				zend_string_release(scope_name);
+				zend_string_release(inner_name);
+				return ce;
+			}
+
+			// Continue moving upwards (perhaps the inner class is further up)
+			zend_string *shorter_scope = zend_string_init(ZSTR_VAL(scope_name), outer_len, 0);
+			zend_string_release(scope_name);
+			scope_name = shorter_scope;
+		} else {
+			// Outer class isn't found: reached namespace level.
+			zend_string_release(scope_name);
+			zend_string_release(outer_class_name);
+			zend_string_release(inner_name);
+			break;
+		}
+	}
+
+	// handle the edge case where the class is in the global scope
+	if (separator == NULL) {
+		separator = strrchr(ZSTR_VAL(requested_name), '\\');
+		if (separator) {
+			zend_string_release(scope_name);
+			// set scope name to just the separator minus the first character
+			scope_name = zend_string_init(separator + 1, ZSTR_LEN(requested_name) - (separator - ZSTR_VAL(requested_name) + 1), 0);
+		} else {
+			zend_string_release(scope_name);
+			zend_string_release(inner_name);
+			return NULL;
+		}
+		ce = zend_lookup_class_ex(scope_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER);
+		zend_string_release(scope_name);
+		zend_string_release(inner_name);
+		return ce;
+	}
+
+	zend_string_release(scope_name);
+	zend_string_release(inner_name);
+
+	// Final lookup directly at namespace/global scope
+	return zend_lookup_class_ex(requested_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER);
+}
+
 ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *key, uint32_t flags) /* {{{ */
 {
 	zend_class_entry *ce = NULL;
@@ -1225,7 +1298,15 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *
 		return ce;
 	}
 
-	/* The compiler is not-reentrant. Make sure we autoload only during run-time. */
+	/* Check to see if our current scope is an outer class; if it is, we need to check the outer class's
+     * namespace for the class we're looking for. */
+	if (!(flags & ZEND_FETCH_CLASS_NO_INNER)) {
+		if (!key) {
+			zend_string_release_ex(lc_name, 0);
+		}
+		return zend_resolve_nested_class(name, flags);
+	}
+
 	if ((flags & ZEND_FETCH_CLASS_NO_AUTOLOAD) || zend_is_compiling()) {
 		if (!key) {
 			zend_string_release_ex(lc_name, 0);

Zend/zend_language_parser.y

@@ -231,7 +231,6 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token T_DOLLAR_OPEN_CURLY_BRACES "'${'"
 %token T_CURLY_OPEN      "'{$'"
 %token T_PAAMAYIM_NEKUDOTAYIM "'::'"
-%token T_INNER_REF       "':>'"
 %token T_NS_SEPARATOR    "'\\'"
 %token T_ELLIPSIS        "'...'"
 %token T_COALESCE        "'??'"
@@ -873,16 +872,9 @@ type_expr_without_static:
 ;
 
 type_without_static:
-		T_ARRAY						{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
-	|	T_CALLABLE					{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
-	|	inner_type_without_static	{ $$ = $1; }
-;
-
-inner_type_without_static:
-		inner_type_without_static T_INNER_REF name
-			{ $$ = zend_ast_create(ZEND_AST_INNER_CLASS, $1, $3); }
-	| 	name
-			{ $$ = $1; }
+		T_ARRAY		{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
+	|	T_CALLABLE	{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
+	|	name		{ $$ = $1; }
 ;
 
 union_type_without_static_element:
@@ -1431,8 +1423,6 @@ class_name:
 			{ zval zv; ZVAL_INTERNED_STR(&zv, ZSTR_KNOWN(ZEND_STR_STATIC));
 			  $$ = zend_ast_create_zval_ex(&zv, ZEND_NAME_NOT_FQ); }
 	|	name { $$ = $1; }
-	| class_name T_INNER_REF name
-			{ $$ = zend_ast_create(ZEND_AST_INNER_CLASS, $1, $3); }
 ;
 
 class_name_reference:

Zend/zend_language_scanner.l

@@ -1601,10 +1601,6 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM);
 }
 
-<ST_IN_SCRIPTING>":>" {
-	RETURN_TOKEN(T_INNER_REF);
-}
-
 <ST_IN_SCRIPTING>"..." {
 	RETURN_TOKEN(T_ELLIPSIS);
 }

ext/reflection/php_reflection.c

@@ -4079,16 +4079,14 @@ static void add_class_vars(zend_class_entry *ce, bool statics, zval *return_valu
 ZEND_METHOD(ReflectionClass, isInnerClass)
 {
 	reflection_object *intern;
-  zend_class_entry *ce;
-
-  ZEND_PARSE_PARAMETERS_NONE();
+	zend_class_entry *ce;
 
-  GET_REFLECTION_OBJECT_PTR(ce);
+	ZEND_PARSE_PARAMETERS_NONE();
+	GET_REFLECTION_OBJECT_PTR(ce);
 
-  // If the class is an inner class, it will have a T_INNER_REF in its name
-  // todo: make this better?
 
-  RETURN_BOOL(strstr(ZSTR_VAL(ce->name), ":>") != NULL);
+	//inner classes have a lexical scope, normal classes do not
+	RETURN_BOOL(ce->lexical_scope != NULL);
 }
 /* }}} */
 

ext/tokenizer/tokenizer_data.c

@@ -712,11 +712,6 @@
  * @cvalue T_PAAMAYIM_NEKUDOTAYIM
  */
 const T_PAAMAYIM_NEKUDOTAYIM = UNKNOWN;
-/**
- * @var int
- * @cvalue T_INNER_REF
- */
-const T_INNER_REF = UNKNOWN;
 /**
  * @var int
  * @cvalue T_NS_SEPARATOR