Added mapping \ArgumentCountError to better ArgumentCountError.

- Better exception provides two methods:
  - getExpected(): Returns expected number of arguments.
  - getActual(): Returns the actual number of arguments.

Author: smuuf

README.md

@@ -124,8 +124,18 @@ Currently only a handful _(in the beginning it was just a single one, since I ne
 
 - `\TypeError` can be converted into:
 	- `\Smuuf\BetterExceptions\Types\ArgumentTypeError`
+		- Provides methods:
+			- `getExpected()`: Returns a list of strings of expected argument types.
+			- `getActual()`: Returns actual argument type as string.
 	- `\Smuuf\BetterExceptions\Types\ReturnTypeError`
+		- _Same as `\Smuuf\BetterExceptions\Types\ArgumentTypeError`._
 
 - `\Error` can be converted into:
 	- `\Smuuf\BetterExceptions\Types\UnknownNamedParameterError`
-
+		- Provides methods:
+			- `getParameterName()`: Returns the name of unknown parameter as string.
+- `\ArgumentCountError` can be converted into:
+	- `\Smuuf\BetterExceptions\Types\ArgumentCountError`
+		- Provides methods:
+			- `getExpected()`: Returns expected number of arguments.
+			- `getActual()`: Returns the actual number of arguments.

src/Internals/Processors/Base/BaseArgumentCountErrorProcessor.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Smuuf\BetterExceptions\Internals\Processors\Base;
+
+use \Smuuf\BetterExceptions\Types\ArgumentCountError;
+use \Smuuf\BetterExceptions\Internals\RegexMatcher;
+use \Smuuf\BetterExceptions\Internals\Processors\ProcessorInterface;
+
+abstract class BaseArgumentCountErrorProcessor implements ProcessorInterface {
+
+	protected const REGEX =
+		'#(?<actual>\d+) passed.*(?<expected>\d+) expected#';
+
+	public static function process(\Throwable $ex): ?\Throwable {
+
+		$msg = $ex->getMessage();
+
+		// Is this \Error is about an unknown named parameter?
+		if ($match = RegexMatcher::match(self::REGEX, $msg)) {
+			return new ArgumentCountError(
+				$msg,
+				(int) $match['expected'],
+				(int) $match['actual']
+			);
+		}
+
+		return null;
+
+	}
+
+}

src/Internals/Processors/Php7/ArgumentCountErrorProcessor.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Smuuf\BetterExceptions\Internals\Processors\Php7;
+
+use \Smuuf\BetterExceptions\Internals\Processors\Base\BaseArgumentCountErrorProcessor;
+
+abstract class ArgumentCountErrorProcessor extends BaseArgumentCountErrorProcessor {
+
+}

src/Internals/Processors/Php8/ArgumentCountErrorProcessor.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Smuuf\BetterExceptions\Internals\Processors\Php8;
+
+use \Smuuf\BetterExceptions\Internals\Processors\Base\BaseArgumentCountErrorProcessor;
+
+abstract class ArgumentCountErrorProcessor extends BaseArgumentCountErrorProcessor {
+
+}

src/Internals/Processors/ProcessorFactory.php

@@ -22,7 +22,7 @@ private static function getSpecificProcessor(\Throwable $ex): string {
 		if (!class_exists($class)) {
 			throw new ErrorException(sprintf(
 				"Cannot create better exception from '$exType'"
-				. " for PHP %s"
+				. " for PHP %s with message '{$ex->getMessage()}'"
 				. " (processor '$class' is missing)",
 				$ver
 			));

src/Types/ArgumentCountError.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Smuuf\BetterExceptions\Types;
+
+class ArgumentCountError extends \ArgumentCountError {
+
+	/** @var int Number of expected arguments. */
+	protected int $expected;
+
+	/** @var int Number of actually passed arguments. */
+	protected int $actual;
+
+	public function __construct(
+		string $message,
+		int $expected,
+		int $actual
+	) {
+
+		parent::__construct($message);
+		$this->expected = $expected;
+		$this->actual = $actual;
+
+	}
+
+	public function getExpected(): int {
+		return $this->expected;
+	}
+
+	public function getActual(): int {
+		return $this->actual;
+	}
+
+
+}

src/Types/Base/BetterTypeError.php

@@ -9,9 +9,6 @@
  */
 abstract class BetterTypeError extends \TypeError {
 
-	/** @var string Exception message. */
-	protected $message;
-
 	/** @var array<string> List of expected types. */
 	protected array $expected;
 

tests/bootstrap.php

@@ -45,4 +45,29 @@ function get_better_exception(callable $fn, ...$args) {
 		return BetterException::from($ex);
 	}
 
+	throw new \LogicException("Expected exception but got nothing :(");
+
+}
+
+/**
+ * Test-driven-development helper for creating new mapping - create new test for
+ * new mapping and use this helper to see the original exception message.
+ *
+ * (Yes, an exception would be printed out anyway by PHP or by Tester, but
+ * then would terminate. This way you can set up multiple cases and see all
+ * messages at once.)
+ */
+function print_exception_message(callable $fn, ...$args) {
+
+	try {
+		$fn(...$args);
+	} catch (\Throwable $ex) {
+
+		$class = get_class($ex);
+		$parents = implode(' extends ', class_parents($ex));
+		echo sprintf("Exception: %s (extends $parents)\n", $class);
+		echo "  Message: {$ex->getMessage()}\n";
+
+	}
+
 }

tests/unit/shared/ArgumentCountError.phpt

@@ -0,0 +1,126 @@
+<?php
+
+declare(strict_types=1);
+
+use \Tester\Assert;
+
+use \Smuuf\BetterExceptions\Types\ArgumentCountError;
+
+require __DIR__ . '/../../bootstrap.php';
+
+//
+// \Error to UnknownNamedParameterError.
+//
+
+function argument_count_error_1($a) {
+    return $a;
+}
+
+function argument_count_error_2($a, $b, $c) {
+    return $a + $b + $c;
+}
+
+function argument_count_error_3($a, $b, $c = null, $d) {
+    return $a + $b + $c + $d;
+}
+
+function argument_count_error_4($a, $b, $c, $d = null) {
+    return $a + $b + $c + $d;
+}
+
+function argument_count_error_5($a, ...$b) {
+    return $a + $b;
+}
+
+function argument_count_error_6($a, $b = null, ...$c) {
+    return $a + $b + $c;
+}
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_1');
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(1, $bex->getExpected());
+Assert::same(0, $bex->getActual());
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_2');
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(0, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_2', 1);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(1, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_2', 1, 2);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(2, $bex->getActual());
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_3', );
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(4, $bex->getExpected());
+Assert::same(0, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_3', 1);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(4, $bex->getExpected());
+Assert::same(1, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_3', 1, 2);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(4, $bex->getExpected());
+Assert::same(2, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_3', 1, 2, 3);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(4, $bex->getExpected());
+Assert::same(3, $bex->getActual());
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_4', );
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(0, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_4', 1);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(1, $bex->getActual());
+
+$bex = get_better_exception('argument_count_error_4', 1, 2);
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(3, $bex->getExpected());
+Assert::same(2, $bex->getActual());
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_5');
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(1, $bex->getExpected());
+Assert::same(0, $bex->getActual());
+
+//
+//
+//
+
+$bex = get_better_exception('argument_count_error_6');
+Assert::type(ArgumentCountError::class, $bex);
+Assert::same(1, $bex->getExpected());
+Assert::same(0, $bex->getActual());