Fix missing named and unnamed parameters in PHP 7

Author: thekid

src/main/php/lang/reflection/Routine.class.php

@@ -3,7 +3,11 @@
 use Error, ReflectionException, ReflectionUnionType, ReflectionIntersectionType;
 use lang\{Reflection, Type, TypeUnion};
 
-/** Base class for methods and constructors */
+/**
+ * Base class for methods and constructors
+ *
+ * @test  lang.reflection.unittest.ArgumentPassingTest
+ */
 abstract class Routine extends Member {
 
   /** @return [:var] */
@@ -90,23 +94,26 @@ public function parameters(): Parameters {
 
   /** Support named arguments for PHP 7.X */
   public static function pass($reflect, $args) {
-    if (is_string(key($args))) {
-      $pass= [];
-      foreach ($reflect->getParameters() as $param) {
-        if (isset($args[$param->name])) {
-          $pass[]= $args[$param->name];
-        } else if ($param->isOptional()) {
-          $pass[]= $param->getDefaultValue();
-        } else {
-          throw new ReflectionException('Missing parameter $'.$param->name);
-        }
+    $pass= [];
+    foreach ($reflect->getParameters() as $i => $param) {
+      if (isset($args[$param->name])) {
+        $pass[]= $args[$param->name];
         unset($args[$param->name]);
+      } else if (isset($args[$i])) {
+        $pass[]= $args[$i];
+        unset($args[$i]);
+      } else if ($param->isOptional()) {
+        $pass[]= $param->getDefaultValue();
+      } else {
+        throw new ReflectionException('Missing parameter $'.$param->name);
       }
-      if ($args) {
-        throw new Error('Unknown named parameter $'.key($args));
-      }
-      return $pass;
     }
-    return $args;
+
+    // Check for excess named parameters
+    if ($args && is_string($excess= key($args))) {
+      throw new Error('Unknown named parameter $'.$excess);
+    }
+
+    return $pass;
   }
 }

src/test/php/lang/reflection/unittest/AnnotationTest.class.php

@@ -273,7 +273,7 @@ public function instantiation() {
     Assert::instance(Annotated::class, $t->annotation(Annotated::class)->newInstance());
   }
 
-  #[Test, Values(['#[Parameterized(1, 2)]', '#[Parameterized(a: 1, b: 2)]', '#[Parameterized(b: 2, a: 1)]'])]
+  #[Test, Values(['#[Parameterized(1, 2)]', '#[Parameterized(1, b: 2)]', '#[Parameterized(a: 1, b: 2)]', '#[Parameterized(b: 2, a: 1)]'])]
   public function parameterized_instantiation($declaration) {
     $t= $this->declare('{}', $declaration);
     Assert::equals(new Parameterized(1, 2), $t->annotation(Parameterized::class)->newInstance());

src/test/php/lang/reflection/unittest/ArgumentPassingTest.class.php

@@ -0,0 +1,75 @@
+<?php namespace lang\reflection\unittest;
+
+use ReflectionFunction;
+use lang\Error;
+use lang\reflection\Routine;
+use test\{Assert, Expect, Test};
+
+class ArgumentPassingTest {
+
+  #[Test]
+  public function pass_ordered() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Assert::equals([1, 2], Routine::pass($f, [1, 2]));
+  }
+
+  #[Test, Expect(class: Error::class, message: 'Missing parameter $a')]
+  public function missing() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Routine::pass($f, []);
+  }
+
+  #[Test, Expect(class: Error::class, message: 'Missing parameter $b')]
+  public function missing_ordered() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Routine::pass($f, [1]);
+  }
+
+  #[Test]
+  public function pass_named() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Assert::equals([1, 2], Routine::pass($f, ['a' => 1, 'b' => 2]));
+  }
+
+  #[Test]
+  public function pass_named_out_of_order() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Assert::equals([1, 2], Routine::pass($f, ['b' => 2, 'a' => 1]));
+  }
+
+  #[Test, Expect(class: Error::class, message: 'Missing parameter $b')]
+  public function missing_named() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Routine::pass($f, ['a' => 1]);
+  }
+
+  #[Test, Expect(class: Error::class, message: 'Unknown named parameter $unknown')]
+  public function unknown_named() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Routine::pass($f, ['a' => 1, 'b' => 2, 'unknown' => null]);
+  }
+
+  #[Test]
+  public function pass_named_and_ordered() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Assert::equals([1, 2], Routine::pass($f, [1, 'b' => 2]));
+  }
+
+  #[Test]
+  public function pass_too_many() {
+    $f= new ReflectionFunction(fn($a, $b) => null);
+    Assert::equals([1, 2], Routine::pass($f, [1, 2, 3]));
+  }
+
+  #[Test]
+  public function pass_optional() {
+    $f= new ReflectionFunction(fn($a, $b= 0) => null);
+    Assert::equals([1, 2], Routine::pass($f, [1, 2]));
+  }
+
+  #[Test]
+  public function pass_without_optional() {
+    $f= new ReflectionFunction(fn($a, $b= 0) => null);
+    Assert::equals([1, 0], Routine::pass($f, [1]));
+  }
+}