Support string assertions resulting in non-empty-string

Author: herndlm

README.md

@@ -85,10 +85,26 @@ This extension specifies types of values passed to:
 * `Assert::methodExists`
 * `Assert::propertyExists`
 * `Assert::isArrayAccessible`
+* `Assert::contains`
+* `Assert::startsWith`
+* `Assert::startsWithLetter`
+* `Assert::endsWith`
+* `Assert::unicodeLetters`
+* `Assert::alpha`
+* `Assert::digits`
+* `Assert::alnum`
+* `Assert::lower`
+* `Assert::upper`
 * `Assert::length`
 * `Assert::minLength`
 * `Assert::maxLength`
 * `Assert::lengthBetween`
+* `Assert::uuid`
+* `Assert::ip`
+* `Assert::ipv4`
+* `Assert::ipv6`
+* `Assert::email`
+* `Assert::notWhitespaceOnly`
 * `nullOr*`, `all*` and `allNullOr*` variants of the above methods
 
 

src/Type/WebMozartAssert/AssertTypeSpecifyingExtension.php

@@ -58,12 +58,29 @@
 use function array_reduce;
 use function array_shift;
 use function count;
+use function is_array;
 use function lcfirst;
 use function substr;
 
 class AssertTypeSpecifyingExtension implements StaticMethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
 {
 
+	private const ASSERTIONS_RESULTING_AT_LEAST_IN_NON_EMPTY_STRING = [
+		'startsWithLetter',
+		'unicodeLetters',
+		'alpha',
+		'digits',
+		'alnum',
+		'lower',
+		'upper',
+		'uuid',
+		'ip',
+		'ipv4',
+		'ipv6',
+		'email',
+		'notWhitespaceOnly',
+	];
+
 	/** @var Closure[] */
 	private static $resolvers;
 
@@ -104,7 +121,7 @@ public function isStaticMethodSupported(
 		}
 
 		$resolver = $resolvers[$trimmedName];
-		$resolverReflection = new ReflectionObject($resolver);
+		$resolverReflection = new ReflectionObject(Closure::fromCallable($resolver));
 
 		return count($node->getArgs()) >= count($resolverReflection->getMethod('__invoke')->getParameters()) - 1;
 	}
@@ -156,50 +173,60 @@ static function (Type $type) {
 			);
 		}
 
-		$expression = self::createExpression($scope, $staticMethodReflection->getName(), $node->getArgs());
-		if ($expression === null) {
+		[$expr, $rootExpr] = self::createExpression($scope, $staticMethodReflection->getName(), $node->getArgs());
+		if ($expr === null) {
 			return new SpecifiedTypes([], []);
 		}
 
 		return $this->typeSpecifier->specifyTypesInCondition(
 			$scope,
-			$expression,
-			TypeSpecifierContext::createTruthy()
+			$expr,
+			TypeSpecifierContext::createTruthy(),
+			$rootExpr
 		);
 	}
 
 	/**
 	 * @param Arg[] $args
+	 * @return array{?Expr, ?Expr}
 	 */
 	private static function createExpression(
 		Scope $scope,
 		string $name,
 		array $args
-	): ?Expr
+	): array
 	{
 		$trimmedName = self::trimName($name);
 		$resolvers = self::getExpressionResolvers();
 		$resolver = $resolvers[$trimmedName];
-		$expression = $resolver($scope, ...$args);
-		if ($expression === null) {
-			return null;
+
+		$resolverResult = $resolver($scope, ...$args);
+		if (is_array($resolverResult)) {
+			[$expr, $rootExpr] = $resolverResult;
+		} else {
+			$expr = $resolverResult;
+			$rootExpr = null;
+		}
+
+		if ($expr === null) {
+			return [null, null];
 		}
 
 		if (substr($name, 0, 6) === 'nullOr') {
-			$expression = new BooleanOr(
-				$expression,
+			$expr = new BooleanOr(
+				$expr,
 				new Identical(
 					$args[0]->value,
 					new ConstFetch(new Name('null'))
 				)
 			);
 		}
 
-		return $expression;
+		return [$expr, $rootExpr];
 	}
 
 	/**
-	 * @return Closure[]
+	 * @return array<string, callable(Scope, Arg...): (Expr|array{?Expr, ?Expr}|null)>
 	 */
 	private static function getExpressionResolvers(): array
 	{
@@ -723,6 +750,23 @@ private static function getExpressionResolvers(): array
 					);
 				},
 			];
+
+			foreach (['contains', 'startsWith', 'endsWith'] as $name) {
+				self::$resolvers[$name] = static function (Scope $scope, Arg $value, Arg $subString): array {
+					if ($scope->getType($subString->value)->isNonEmptyString()->yes()) {
+						return self::createIsNonEmptyStringAndSomethingExprPair([$value]);
+					}
+
+					return [self::$resolvers['string']($scope, $value), null];
+				};
+			}
+
+			foreach (self::ASSERTIONS_RESULTING_AT_LEAST_IN_NON_EMPTY_STRING as $name) {
+				self::$resolvers[$name] = static function (Scope $scope, Arg $value): array {
+					return self::createIsNonEmptyStringAndSomethingExprPair([$value]);
+				};
+			}
+
 		}
 
 		return self::$resolvers;
@@ -790,15 +834,16 @@ private function handleAll(
 	{
 		$args = $node->getArgs();
 		$args[0] = new Arg(new ArrayDimFetch($args[0]->value, new LNumber(0)));
-		$expression = self::createExpression($scope, $methodName, $args);
-		if ($expression === null) {
+		[$expr, $rootExpr] = self::createExpression($scope, $methodName, $args);
+		if ($expr === null) {
 			return new SpecifiedTypes();
 		}
 
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition(
 			$scope,
-			$expression,
-			TypeSpecifierContext::createTruthy()
+			$expr,
+			TypeSpecifierContext::createTruthy(),
+			$rootExpr
 		);
 
 		$sureNotTypes = $specifiedTypes->getSureNotTypes();
@@ -817,7 +862,8 @@ private function handleAll(
 				$node->getArgs()[0]->value,
 				static function () use ($type): Type {
 					return $type;
-				}
+				},
+				$rootExpr
 			);
 		}
 
@@ -827,7 +873,8 @@ static function () use ($type): Type {
 	private function arrayOrIterable(
 		Scope $scope,
 		Expr $expr,
-		Closure $typeCallback
+		Closure $typeCallback,
+		?Expr $rootExpr = null
 	): SpecifiedTypes
 	{
 		$currentType = TypeCombinator::intersect($scope->getType($expr), new IterableType(new MixedType(), new MixedType()));
@@ -859,7 +906,8 @@ private function arrayOrIterable(
 			$specifiedType,
 			TypeSpecifierContext::createTruthy(),
 			false,
-			$scope
+			$scope,
+			$rootExpr
 		);
 	}
 
@@ -900,4 +948,31 @@ static function (?ArrayItem $item) use ($scope, $value, $resolver) {
 		return self::implodeExpr($resolvers, BooleanOr::class);
 	}
 
+	/**
+	 * @param Arg[] $args
+	 * @return array{Expr, Expr}
+	 */
+	private static function createIsNonEmptyStringAndSomethingExprPair(array $args): array
+	{
+		$expr = new BooleanAnd(
+			new FuncCall(
+				new Name('is_string'),
+				[$args[0]]
+			),
+			new NotIdentical(
+				$args[0]->value,
+				new String_('')
+			)
+		);
+
+		$rootExpr = new BooleanAnd(
+			$expr,
+			new FuncCall(new Name('FAUX_FUNCTION'), [
+				new Arg($args[0]->value),
+			])
+		);
+
+		return [$expr, $rootExpr];
+	}
+
 }

tests/Type/WebMozartAssert/data/collection.php

@@ -30,6 +30,30 @@ public function allStringNotEmpty(array $a, iterable $b, $c): void
 		assertType('iterable<non-empty-string>', $c);
 	}
 
+	public function allContains(array $a, iterable $b, $c): void
+	{
+		Assert::allContains($a, 'foo');
+		assertType('array<non-empty-string>', $a);
+
+		Assert::allContains($b, 'foo');
+		assertType('iterable<non-empty-string>', $b);
+
+		Assert::allContains($c, 'foo');
+		assertType('iterable<non-empty-string>', $c);
+	}
+
+	public function allNullOrContains(array $a, iterable $b, $c): void
+	{
+		Assert::allNullOrContains($a, 'foo');
+		assertType('array<non-empty-string|null>', $a);
+
+		Assert::allNullOrContains($b, 'foo');
+		assertType('iterable<non-empty-string|null>', $b);
+
+		Assert::allNullOrContains($c, 'foo');
+		assertType('iterable<non-empty-string|null>', $c);
+	}
+
 	public function allInteger(array $a, iterable $b, $c): void
 	{
 		Assert::allInteger($a);

tests/Type/WebMozartAssert/data/impossible-check.php

@@ -76,6 +76,16 @@ public function allCount(array $a): void
 		Assert::allCount($a, 2);
 	}
 
+	public function nonEmptyStringAndSomethingUnknownNarrow($a, string $b): void
+	{
+		Assert::string($a);
+		Assert::stringNotEmpty($a);
+		Assert::uuid($a);
+
+		Assert::stringNotEmpty($b);
+		Assert::contains($b, 'foo');
+	}
+
 }
 
 interface Bar {};