Fix https://github.com/slevomat/coding-standard/issues/1768 non-empty-lowercase-string, non-empty-array

SlevomatCodingStandard/Helpers/AnnotationHelper.php

@@ -260,6 +260,14 @@ public static function isAnnotationUseless(
 			);
 		}
 
+		if ($annotationType instanceof UnionTypeNode) {
+			return false;
+		}
+
+		if ($annotationType instanceof IntersectionTypeNode) {
+			return false;
+		}
+
 		if ($annotationType instanceof ObjectShapeNode) {
 			return false;
 		}
@@ -293,11 +301,10 @@ public static function isAnnotationUseless(
 				return $enableStandaloneNullTrueFalseTypeHints;
 			}
 
-			if (in_array(
+			if (TypeHintHelper::isSimpleUnofficialTypeHints(
 				strtolower($annotationType->name),
-				['class-string', 'trait-string', 'callable-string', 'numeric-string', 'non-empty-string', 'non-falsy-string', 'literal-string', 'positive-int', 'negative-int'],
-				true,
-			)) {
+			) && !in_array($annotationType->name, ['object', 'mixed'], true)
+			) {
 				return false;
 			}
 		}

SlevomatCodingStandard/Helpers/AnnotationTypeHelper.php

@@ -2,6 +2,7 @@
 
 namespace SlevomatCodingStandard\Helpers;
 
+use InvalidArgumentException;
 use PHP_CodeSniffer\Files\File;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprFloatNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
@@ -21,7 +22,10 @@
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
 use function count;
+use function get_class;
 use function in_array;
+use function preg_match;
+use function sprintf;
 use function strtolower;
 
 /**
@@ -291,7 +295,16 @@ public static function getTypeHintFromOneType(
 				return 'array';
 			}
 
-			return $genericName;
+			if ((bool) preg_match(
+				'/^\\\\?[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*(?:\\\\[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)*$/',
+				$genericName,
+			)) {
+				return $genericName;
+			}
+
+			throw new InvalidArgumentException(
+				sprintf('Invalid type "%1$s" of class %2$s given', $genericName, get_class($typeNode)),
+			);
 		}
 
 		if ($typeNode instanceof IdentifierTypeNode) {
@@ -303,19 +316,61 @@ public static function getTypeHintFromOneType(
 				return $enableUnionTypeHint || $enableStandaloneNullTrueFalseTypeHints ? 'false' : 'bool';
 			}
 
-			if (in_array(strtolower($typeNode->name), ['positive-int', 'negative-int'], true)) {
+			if (in_array(
+				strtolower($typeNode->name),
+				['positive-int', 'non-positive-int', 'negative-int', 'non-negative-int', 'literal-int', 'int-mask'],
+				true,
+			)) {
 				return 'int';
 			}
 
 			if (in_array(
 				strtolower($typeNode->name),
-				['class-string', 'trait-string', 'callable-string', 'numeric-string', 'non-empty-string', 'non-falsy-string', 'literal-string'],
+				['callable-array', 'callable-string'],
 				true,
 			)) {
+				return 'callable';
+			}
+
+			// see https://psalm.dev/docs/annotating_code/type_syntax/scalar_types/#class-string-interface-string
+			if ((bool) preg_match('/-string$/i', $typeNode->name)) {
 				return 'string';
 			}
 
-			return $typeNode->name;
+			// here when used literally e.g. as type non-empty-array|null
+			if (in_array(
+				strtolower($typeNode->name),
+				['non-empty-array', 'list', 'non-empty-list'],
+				true,
+			)) {
+				return 'array';
+			}
+
+			if (strtolower($typeNode->name) === 'array-key') {
+				return $enableUnionTypeHint ? 'int|string' : 'mixed';
+			}
+
+			if (TypeHintHelper::isNeverTypeHint(strtolower($typeNode->name))) {
+				// don't set a type hint at all if it's not supported by the PHP version yet
+				return $enableStandaloneNullTrueFalseTypeHints ? 'never' : 'never-returns';
+			}
+
+			if (strtolower($typeNode->name) === 'static') {
+				// don't set a type hint at all (instead of "self") if it's not supported by the PHP version yet
+				// use $this to fake it
+				return $enableUnionTypeHint ? 'static' : '$this';
+			}
+
+			if ((bool) preg_match(
+				'/^\\\\?[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*(?:\\\\[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)*$/',
+				$typeNode->name,
+			)) {
+				return $typeNode->name;
+			}
+
+			throw new InvalidArgumentException(
+				sprintf('Invalid type "%1$s" of class %2$s given', $typeNode->name, get_class($typeNode)),
+			);
 		}
 
 		if ($typeNode instanceof CallableTypeNode) {
@@ -334,6 +389,11 @@ public static function getTypeHintFromOneType(
 			return 'object';
 		}
 
+		// $this and self are not strictly equal
+		if ($typeNode instanceof ThisTypeNode) {
+			return (string) $typeNode;
+		}
+
 		if ($typeNode instanceof ConstTypeNode) {
 			if ($typeNode->constExpr instanceof ConstExprIntegerNode) {
 				return 'int';
@@ -348,7 +408,16 @@ public static function getTypeHintFromOneType(
 			}
 		}
 
-		return (string) $typeNode;
+		if ((bool) preg_match(
+			'/^\\\\?[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*(?:\\\\[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)*$/',
+			(string) $typeNode,
+		)) {
+			return (string) $typeNode;
+		}
+
+		throw new InvalidArgumentException(
+			sprintf('Invalid type "%1$s" of class %2$s given', (string) $typeNode, get_class($typeNode)),
+		);
 	}
 
 	/**

SlevomatCodingStandard/Helpers/TypeHintHelper.php

@@ -13,6 +13,7 @@
 use function count;
 use function implode;
 use function in_array;
+use function preg_match;
 use function preg_split;
 use function sort;
 use function sprintf;
@@ -79,7 +80,7 @@ public static function convertLongSimpleTypeHintToShort(string $typeHint): strin
 
 	public static function isUnofficialUnionTypeHint(string $typeHint): bool
 	{
-		return in_array($typeHint, ['scalar', 'numeric'], true);
+		return in_array($typeHint, ['scalar', 'numeric', 'array-key'], true);
 	}
 
 	public static function isVoidTypeHint(string $typeHint): bool
@@ -99,7 +100,8 @@ public static function convertUnofficialUnionTypeHintToOfficialTypeHints(string
 	{
 		$conversion = [
 			'scalar' => ['string', 'int', 'float', 'bool'],
-			'numeric' => ['int', 'float'],
+			'numeric' => ['int', 'float', 'string'],
+			'array-key' => ['int', 'string'],
 		];
 
 		return $conversion[$typeHint];
@@ -170,6 +172,7 @@ public static function isSimpleUnofficialTypeHints(string $typeHint): bool
 		static $simpleUnofficialTypeHints;
 
 		if ($simpleUnofficialTypeHints === null) {
+			// see https://psalm.dev/docs/annotating_code/type_syntax/atomic_types/
 			$simpleUnofficialTypeHints = [
 				'null',
 				'mixed',
@@ -180,24 +183,25 @@ public static function isSimpleUnofficialTypeHints(string $typeHint): bool
 				'resource',
 				'static',
 				'$this',
-				'class-string',
-				'trait-string',
-				'callable-string',
-				'numeric-string',
-				'non-empty-string',
-				'non-falsy-string',
-				'literal-string',
 				'array-key',
 				'list',
+				'non-empty-array',
+				'non-empty-list',
 				'empty',
 				'positive-int',
+				'non-positive-int',
 				'negative-int',
+				'non-negative-int',
+				'literal-int',
+				'int-mask',
 				'min',
 				'max',
+				'callable-array',
+				'callable-string',
 			];
 		}
 
-		return in_array($typeHint, $simpleUnofficialTypeHints, true);
+		return in_array($typeHint, $simpleUnofficialTypeHints, true) || (bool) preg_match('/-string$/', $typeHint);
 	}
 
 	/**

SlevomatCodingStandard/Sniffs/PHP/RequireExplicitAssertionSniff.php

@@ -27,6 +27,7 @@
 use function count;
 use function implode;
 use function in_array;
+use function preg_match;
 use function sprintf;
 use function strpos;
 use function trim;
@@ -417,8 +418,7 @@ private function createConditions(string $variableName, TypeNode $typeNode): arr
 
 		if ($typeNode->name === 'numeric') {
 			return [
-				sprintf('\is_int(%s)', $variableName),
-				sprintf('\is_float(%s)', $variableName),
+				sprintf('\is_numeric(%s)', $variableName),
 			];
 		}
 
@@ -432,29 +432,33 @@ private function createConditions(string $variableName, TypeNode $typeNode): arr
 		}
 
 		if ($this->enableIntegerRanges) {
-			if ($typeNode->name === 'positive-int') {
+			if ($typeNode->name === 'positive-int' || $typeNode->name === 'non-negative-int') {
 				return [sprintf('\is_int(%1$s) && %1$s > 0', $variableName)];
 			}
 
-			if ($typeNode->name === 'negative-int') {
+			if ($typeNode->name === 'negative-int' || $typeNode->name === 'non-positive-int') {
 				return [sprintf('\is_int(%1$s) && %1$s < 0', $variableName)];
 			}
+
+			if ($typeNode->name === 'literal-int') {
+				return [sprintf('\is_int(%1$s)', $variableName)];
+			}
 		}
 
 		if (
 			$this->enableAdvancedStringTypes
-			&& in_array($typeNode->name, ['non-empty-string', 'non-falsy-string', 'callable-string', 'numeric-string'], true)
+			&& (bool) preg_match('/-string$/i', $typeNode->name)
 		) {
 			$conditions = [sprintf('\is_string(%s)', $variableName)];
 
-			if ($typeNode->name === 'non-empty-string') {
-				$conditions[] = sprintf("%s !== ''", $variableName);
-			} elseif ($typeNode->name === 'non-falsy-string') {
-				$conditions[] = sprintf('(bool) %s === true', $variableName);
-			} elseif ($typeNode->name === 'callable-string') {
+			if ($typeNode->name === 'callable-string') {
 				$conditions[] = sprintf('\is_callable(%s)', $variableName);
-			} else {
+			} elseif ($typeNode->name === 'numeric-string') {
 				$conditions[] = sprintf('\is_numeric(%s)', $variableName);
+			} elseif ((bool) preg_match('/^non-empty-/i', $typeNode->name)) {
+				$conditions[] = sprintf("%s !== ''", $variableName);
+			} elseif ((bool) preg_match('/^non-falsy-/i', $typeNode->name)) {
+				$conditions[] = sprintf('(bool) %s === true', $variableName);
 			}
 
 			return [implode(' && ', $conditions)];

SlevomatCodingStandard/Sniffs/TestCase.php

@@ -84,13 +84,35 @@ protected static function checkFile(string $filePath, array $sniffProperties = [
 	protected static function assertNoSniffErrorInFile(File $phpcsFile): void
 	{
 		$errors = $phpcsFile->getErrors();
-		self::assertEmpty($errors, sprintf('No errors expected, but %d errors found.', count($errors)));
+		$text = sprintf('No errors expected, but %d errors found:', count($errors));
+		foreach ($errors as $line => $error) {
+			$text .= sprintf(
+				'%sLine %d:%s%s',
+				PHP_EOL,
+				$line,
+				PHP_EOL,
+				self::getFormattedErrors($error),
+			);
+		}
+
+		self::assertEmpty($errors, $text);
 	}
 
 	protected static function assertNoSniffWarningInFile(File $phpcsFile): void
 	{
 		$warnings = $phpcsFile->getWarnings();
-		self::assertEmpty($warnings, sprintf('No warnings expected, but %d warnings found.', count($warnings)));
+		$text = sprintf('No warnings expected, but %d warnings found:', count($warnings));
+		foreach ($warnings as $line => $warning) {
+			$text .= sprintf(
+				'%sLine %d:%s%s',
+				PHP_EOL,
+				$line,
+				PHP_EOL,
+				self::getFormattedErrors($warning),
+			);
+		}
+
+		self::assertEmpty($warnings, $text);
 	}
 
 	protected static function assertSniffError(File $phpcsFile, int $line, string $code, ?string $message = null): void

tests/Helpers/TypeHintHelperTest.php

@@ -81,6 +81,19 @@ public static function dataIsSimpleUnofficialTypeHint(): array
 			['resource', true],
 			['static', true],
 			['$this', true],
+			['array-key', true],
+			['list', true],
+			['non-empty-array', true],
+			['non-empty-list', true],
+			['empty', true],
+			['positive-int', true],
+			['non-positive-int', true],
+			['negative-int', true],
+			['non-negative-int', true],
+			['literal-int', true],
+			['int-mask', true],
+			['callable-array', true],
+			['callable-string', true],
 
 			['\Traversable', false],
 			['int', false],
@@ -379,6 +392,8 @@ public static function dataTypeHintEqualsAnnotation(): array
 		return [
 			['scalar', true],
 			['unionIsNotIntersection', false],
+			['fooFunctionWithReturnAnnotationComplexString', false],
+			['fooFunctionWithReturnAnnotationSimpleHyphenedIterable', false],
 		];
 	}
 

tests/Helpers/data/typeHintEqualsAnnotation.php

@@ -14,3 +14,19 @@ function scalar(): int|bool|float|string
 function unionIsNotIntersection(): Foo|Bar
 {
 }
+
+/**
+ * @return non-empty-lowercase-string
+ */
+function fooFunctionWithReturnAnnotationComplexString(): string
+{
+
+}
+
+/**
+ * @return non-empty-array|null
+ */
+function fooFunctionWithReturnAnnotationSimpleHyphenedIterable(): ?array
+{
+
+}