commitierung der kochung

desIstUrGuad · desIstUrGuad · commit c1b0fd59f56a · 2025-04-02T21:42:25.000Z
diff --git a/LE.md b/LE.md
@@ -0,0 +1,126 @@
+# Generics syntax
+
+## Generic classes and interfaces
+
+### Basic case
+```lhp
+class GenericTestClass<T> {
+    // T can be used as type alias inside of 'GenericTestClass'
+    public function __construct(
+        private T $property
+    ) {}
+    
+    public function getMyT(): T {
+        return $this->property;
+    }
+    
+    public function setMyT(T $newValue) {
+        $this->property = $newValue;
+    }
+}
+```
+
+### Multiple Generics
+```lehp
+class GenericTestClass<T, U> {
+    // T and U can now be used as type aliases inside of 'GenericTestClass'
+
+    public function __construct(
+        private T $first,
+        private U $second
+    ) {}
+
+    public function getFirst(): T {
+        return $this->first;
+    }
+
+    public function setFirst(T $value) {
+        $this->first = $value;
+    }
+
+    public function getSecond(): U {
+        return $this->second;
+    }
+
+    public function setSecond(U $value) {
+        $this->second = $value;
+    }
+}
+```
+
+### Bounded Gerics
+```lehp
+interface Serializable {
+    public function serialize(): string;
+}
+
+class BoundedGenericClass<T: Serializable> {
+    public function __construct(
+        private T $serializable
+    ) {}
+    
+    public function getSerialized(): string
+    {
+        return $this->serializable->serialize();
+    }
+    
+    public function getAsSerializable(): Serializable
+    {
+        return (Serializable) $this->serializable; // cast optional
+    }
+    
+    public function getObject(): T
+    {
+        return $this->serializable;
+    }
+}  
+```
+
+### A little bit more complex
+```
+interface Serializer<T> {
+    public function serialize(T $object): string;
+}
+
+class RandomAssSerializableContaier<T, K: Serializer<T>> {
+    
+    private array $content = [];
+    
+    public function __construct(
+        private K serializer
+    ) {}
+    
+    public function add(T $toAdd)
+    {
+        $content[] = $toAdd;
+    }
+    
+    public function asSerializedList(): array
+    {
+        return array_map(
+            fn ($obj) $this->serializer->serialize($obj),
+            $this->content
+        );
+    }   
+}
+```
+## Functions
+### Basic case
+```
+function noOp<T>(T $in): T
+{
+    return $in;
+}
+```
+
+### A bit more complex
+```
+interface Serializer<T> {
+    public function serialize(T $object): string;
+}
+
+function serialize<T, K: Serializer<T>>(T $in, K $serializer): string
+{
+    return $serializer->serialize($in);
+}
+```
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
@@ -291,18 +291,23 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> function_name non_empty_member_modifiers
 %type <ast> property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body
 %type <ast> optional_parameter_list
-%type <ast> generic_type_parameter_list
-%type <ast> generic_type_parameters
+%type <ast> nested_generic_type_parameter_list
+%type <ast> nested_generic_type_parameters
 %type <ast> generic_type
 %type <ast> non_empty_generic_type_parameters
+%type <ast> generic_type_with_constraint
+%type <ast> generic_type_parameter_list_with_constraints
+%type <ast> class_or_fuction_decl_generic_type_parameters
+%type <ast> simple_generic_type
+%type <ast> simple_generic_type_parameter_list
+%type <ast> non_empty_simple_generic_type_parameters
 
 %type <num> returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers
 %type <num> method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers
 %type <num> class_modifiers class_modifier anonymous_class_modifiers anonymous_class_modifiers_optional use_type backup_fn_flags
 
 %type <ptr> backup_lex_pos
 %type <str> backup_doc_comment
-%type <str> generic_param_name
 
 %type <ident> reserved_non_modifiers semi_reserved
 
@@ -607,25 +612,60 @@ is_variadic:
 
 class_declaration_statement:
 		class_modifiers T_CLASS { $<num>$ = CG(zend_lineno); }
-		T_STRING generic_type_parameters extends_from implements_list backup_doc_comment '{' class_statement_list '}'
+		T_STRING class_or_fuction_decl_generic_type_parameters extends_from implements_list backup_doc_comment '{' class_statement_list '}'
 			{ $$ = zend_ast_create_decl(ZEND_AST_CLASS, $1, $<num>3, $8, zend_ast_get_str($4), $6, $7, $10, $5, NULL); }
 	|	T_CLASS { $<num>$ = CG(zend_lineno); }
-		T_STRING generic_type_parameters extends_from implements_list backup_doc_comment '{' class_statement_list '}'
+		T_STRING class_or_fuction_decl_generic_type_parameters extends_from implements_list backup_doc_comment '{' class_statement_list '}'
 			{ $$ = zend_ast_create_decl(ZEND_AST_CLASS, 0, $<num>2, $7, zend_ast_get_str($3), $5, $6, $9, $4, NULL); }
 ;
 
-generic_type_parameters:
-    T_GENERIC_START generic_type_parameter_list possible_comma T_GENERIC_END { $$ = $2; }
+// only support e.g. "<T, S, A>"
+non_empty_simple_generic_type_parameters:
+    T_GENERIC_START simple_generic_type_parameter_list T_GENERIC_END { $$ = $2; }
+;
+
+// only support e.g. "SomeType<T, S, A>"
+simple_generic_type:
+  T_STRING { $$ = zend_ast_create_zval_from_str(zend_ast_get_str($1)); }
+  | T_STRING non_empty_simple_generic_type_parameters { $$ = zend_ast_create(ZEND_AST_GENERIC_TYPE, zend_ast_create_zval_from_str(zend_ast_get_str($1)), $2); }
+;
+
+// only support e.g. "T, S, A"
+simple_generic_type_parameter_list:
+    T_STRING { $$ = zend_ast_create_list(1, ZEND_AST_GENERIC_TYPE_PARAM_LIST, $1); }
+    | generic_type_parameter_list_with_constraints ',' T_STRING { $$ = zend_ast_list_add($1, $3); }
+;
+
+// supports bounded types, e.g. "<T : SomeInterface, S : SomeClass>"
+class_or_fuction_decl_generic_type_parameters:
+    T_GENERIC_START generic_type_parameter_list_with_constraints T_GENERIC_END { $$ = $2; }
     | %empty { $$ = NULL; }
 ;
 
-generic_type_parameter_list:
+// supports bounded types, e.g. "T : SomeInterface, S : SomeClass"
+generic_type_parameter_list_with_constraints:
+    generic_type_with_constraint { $$ = zend_ast_create_list(1, ZEND_AST_GENERIC_TYPE_PARAM_LIST, $1); }
+    | generic_type_parameter_list_with_constraints ',' generic_type_with_constraint { $$ = zend_ast_list_add($1, $3); }
+;
+
+// supports bounded types, e.g. "T : SomeInterface"
+generic_type_with_constraint:
+    T_STRING { $$ = zend_ast_create_zval_from_str(zend_ast_get_str($1)); }
+    | T_STRING ':' simple_generic_type { $$ = zend_ast_create(ZEND_AST_GENERIC_TYPE, zend_ast_create_zval_from_str(zend_ast_get_str($1)), $3); }
+;
+
+nested_generic_type_parameters:
+    T_GENERIC_START nested_generic_type_parameter_list T_GENERIC_END { $$ = $2; }
+    | %empty { $$ = NULL; }
+;
+
+nested_generic_type_parameter_list:
     generic_type { $$ = zend_ast_create_list(1, ZEND_AST_GENERIC_TYPE_PARAM_LIST, $1); }
-    | generic_type_parameter_list ',' generic_type { $$ = zend_ast_list_add($1, $3); }
+    | nested_generic_type_parameter_list ',' generic_type { $$ = zend_ast_list_add($1, $3); }
 ;
 
 non_empty_generic_type_parameters:
-    T_GENERIC_START generic_type_parameter_list possible_comma T_GENERIC_END { $$ = $2; }
+    T_GENERIC_START nested_generic_type_parameter_list T_GENERIC_END { $$ = $2; }
 ;
 
 generic_type:
@@ -896,9 +936,9 @@ type_expr_without_static:
 
 //TODO add generic type params to AST
 type_without_static:
-		T_ARRAY	 generic_type_parameters  { $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
+		T_ARRAY	 nested_generic_type_parameters  { $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
 	|	T_CALLABLE	{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
-	|	name generic_type_parameters  { $$ = $1; }
+	|	name nested_generic_type_parameters  { $$ = $1; }
 ;
 
 union_type_without_static_element:
@@ -1390,10 +1430,6 @@ backup_doc_comment:
 	%empty { $$ = CG(doc_comment); CG(doc_comment) = NULL; }
 ;
 
-generic_param_name:
-	%empty { $$ = CG(doc_comment); CG(doc_comment) = NULL; }
-;
-
 backup_fn_flags:
 	%prec PREC_ARROW_FUNCTION %empty { $$ = CG(extra_fn_flags); CG(extra_fn_flags) = 0; }
 ;
diff --git a/t.php b/t.php
@@ -1,5 +1,5 @@
 <?php
-class test!🥖K!🥖!🥖bruh!🥥!🥥{
+class test!🥖lebruh, bruh : LELE!🥥 extends bruh {
     public function __construct(
     public K $lol
 ){
diff --git a/tree.php b/tree.php
@@ -1,7 +1,7 @@
 <?php
 $tokens = token_get_all('<?php
 
-                         class test!🥖K!🥥{
+                         class test!🥖bruh : LELE, lebruh!🥥 {
                              public function __construct(
                              public !🥖K!🥥 $lol
                          ){
