Add support of suffixed variadic syntax

Author: SerafimArts

resources/grammar/callable.pp2

@@ -50,7 +50,9 @@ CallableParameter
   : MaybeDefaultCallableParameter()
   ;
 
-// Parses "<param>" or "<param> =" expression
+// Expects expression:
+// - "<param>"
+// - "<param> ="
 MaybeDefaultCallableParameter -> {
     if (\count($children) === 1) {
         return $children[0];
@@ -63,62 +65,133 @@ MaybeDefaultCallableParameter -> {
     $children[0]->optional = true;
     return $children[0];
 }
-  : MaybeNamedCallableParameter() <T_ASSIGN>?
+  : ( MaybePrefixedVariadicTypedNamedCallableParameter()
+    | MaybeModifiersNamedCallableParameter() )
+    <T_ASSIGN>?
   ;
 
-// Parses "$variable" or "<param> $variable", or "<param>" expression
-MaybeNamedCallableParameter -> {
-    if ($children instanceof Node\Stmt\Callable\CallableParameterNode) {
+// Expects expression:
+// - "&...<var_param>"
+// - "...&<var_param>"
+// - "...<var_param>"
+// - "&<var_param>"
+// - "<var_param>"
+MaybeModifiersNamedCallableParameter -> {
+    if (!\is_array($children)) {
         return $children;
     }
 
-    if (\count($children) === 1) {
-        return $children[0];
+    $result = \end($children);
+
+    foreach ($children as $modifier) {
+        if ($modifier instanceof \Phplrt\Contracts\Lexer\TokenInterface) {
+            switch ($modifier->getName()) {
+                case 'T_AMP':
+                    $result->output = true;
+                    break;
+                case 'T_ELLIPSIS':
+                    if ($result->variadic) {
+                        throw SemanticException::fromVariadicRedefinition($offset);
+                    }
+                    $result->variadic = true;
+                    break;
+            }
+        }
     }
 
-    $children[0]->name = $children[1];
-    return $children[0];
+    return $result;
 }
-  : MaybeVariableCallableParameter()
-  | MaybeVariadicCallableParameter() VariableLiteral()?
+  : <T_AMP> <T_ELLIPSIS> MaybeSuffixedVariadicNamedCallableParameter()
+  | <T_ELLIPSIS> <T_AMP> MaybeSuffixedVariadicNamedCallableParameter()
+  | <T_ELLIPSIS> MaybeSuffixedVariadicNamedCallableParameter()
+  | <T_AMP> MaybeSuffixedVariadicNamedCallableParameter()
+  | MaybeSuffixedVariadicNamedCallableParameter()
   ;
 
-// Parses "$variable" expression
-MaybeVariableCallableParameter -> {
-    return new Node\Stmt\Callable\CallableParameterNode(null, $children[0]);
+// Expects expression:
+// - "$<var>..."
+// - "$<var>"
+MaybeSuffixedVariadicNamedCallableParameter -> {
+    $result = new Node\Stmt\Callable\CallableParameterNode(null, $children[0]);
+
+    if (\count($children) !== 1) {
+        $result->variadic = true;
+    }
+
+    return $result;
 }
   : VariableLiteral()
+    <T_ELLIPSIS>?
   ;
 
-// Parses "...<param>" or "<param>...", or "<param>" expression
-MaybeVariadicCallableParameter -> {
-    if (count($children) === 1) {
+MaybePrefixedVariadicTypedNamedCallableParameter -> {
+    if (\count($children) === 1) {
         return $children[0];
     }
 
-    if ($children[0] instanceof Node\Stmt\Callable\ParameterNode) {
-        $children[0]->variadic = true;
-        return $children[0];
+    if ($children[1]->variadic) {
+        throw SemanticException::fromVariadicRedefinition($offset);
     }
 
     $children[1]->variadic = true;
     return $children[1];
 }
-  : <T_ELLIPSIS> MaybeOutputCallableParameter()   // Prefixed variadic argument (Psalm format)
-  | MaybeOutputCallableParameter() <T_ELLIPSIS>?  // Suffixed variadic argument (PhpStan + Psalm)
+  : <T_ELLIPSIS>? MaybeTypedNamedCallableParameter()
   ;
 
-// Parses "<param>&" or "<param>" expression
-MaybeOutputCallableParameter -> {
-    $argument = new Node\Stmt\Callable\CallableParameterNode($children[0]);
+// Expects expression:
+// - "<typed_param> $<var>"
+// - "<typed_param>"
+MaybeTypedNamedCallableParameter -> {
+    if (\count($children) === 1) {
+        return $children[0];
+    }
 
-    if (\count($children) !== 1) {
-        $argument->output = true;
+    $children[0]->name = $children[1];
+    return $children[0];
+}
+  : MaybeModifiersTypedCallableParameter()
+    VariableLiteral()?
+  ;
+
+// Expects expression:
+// - "<type>...&"
+// - "<type>&..."
+// - "<type>&"
+// - "<type>..."
+// - "<type>"
+MaybeModifiersTypedCallableParameter -> {
+    $result = \reset($children);
+
+    foreach ($children as $modifier) {
+        if ($modifier instanceof \Phplrt\Contracts\Lexer\TokenInterface) {
+            switch ($modifier->getName()) {
+                case 'T_AMP':
+                    $result->output = true;
+                    break;
+                case 'T_ELLIPSIS':
+                    if ($result->variadic) {
+                        throw SemanticException::fromVariadicRedefinition($offset);
+                    }
+                    $result->variadic = true;
+                    break;
+            }
+        }
     }
 
-    return $argument;
+    return $result;
+}
+  : TypedCallableParameter()
+    ( <T_AMP> <T_ELLIPSIS>?
+    | <T_ELLIPSIS> <T_AMP>? )?
+  ;
+
+// Expects expression:
+// - "<type>"
+TypedCallableParameter -> {
+    return new Node\Stmt\Callable\CallableParameterNode($children[0]);
 }
-  : Type() <T_AMP>?
+  : Type()
   ;
 
 CallableReturnType

src/Exception/SemanticException.php

@@ -12,7 +12,9 @@ class SemanticException extends \LogicException implements ParserExceptionInterf
 
     final public const ERROR_CODE_VARIADIC_WITH_DEFAULT = 0x03;
 
-    final public const ERROR_CODE_INVALID_OPERATOR = 0x04;
+    final public const ERROR_CODE_VARIADIC_ALREADY_VARIADIC = 0x04;
+
+    final public const ERROR_CODE_INVALID_OPERATOR = 0x05;
 
     protected const CODE_LAST = self::ERROR_CODE_INVALID_OPERATOR;
 
@@ -73,6 +75,18 @@ public static function fromVariadicWithDefault(int $offset = 0): self
         return new static($offset, $message, self::ERROR_CODE_VARIADIC_WITH_DEFAULT);
     }
 
+    /**
+     * @param int<0, max> $offset
+     *
+     * @return static
+     */
+    public static function fromVariadicRedefinition(int $offset = 0): self
+    {
+        $message = 'Either prefix or postfix variadic syntax should be used, but not both';
+
+        return new static($offset, $message, self::ERROR_CODE_VARIADIC_ALREADY_VARIADIC);
+    }
+
     /**
      * @param non-empty-string $operator
      * @param int<0, max> $offset