SlevomatCodingStandard.Classes.RequireSelfReference: New sniff

Author: kukulich

SlevomatCodingStandard/Sniffs/Classes/RequireSelfReferenceSniff.php

@@ -0,0 +1,113 @@
+<?php declare(strict_types = 1);
+
+namespace SlevomatCodingStandard\Sniffs\Classes;
+
+use PHP_CodeSniffer\Files\File;
+use PHP_CodeSniffer\Sniffs\Sniff;
+use SlevomatCodingStandard\Helpers\ClassHelper;
+use SlevomatCodingStandard\Helpers\FixerHelper;
+use SlevomatCodingStandard\Helpers\NamespaceHelper;
+use SlevomatCodingStandard\Helpers\ReferencedNameHelper;
+use SlevomatCodingStandard\Helpers\TokenHelper;
+use function array_merge;
+use function preg_quote;
+use function preg_replace;
+use const T_ANON_CLASS;
+use const T_ATTRIBUTE;
+use const T_OPEN_TAG;
+
+class RequireSelfReferenceSniff implements Sniff
+{
+
+	public const CODE_REQUIRED_SELF_REFERENCE = 'RequiredSelfReference';
+
+	/**
+	 * @return array<int, (int|string)>
+	 */
+	public function register(): array
+	{
+		return [
+			T_OPEN_TAG,
+		];
+	}
+
+	/**
+	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+	 * @param int $openTagPointer
+	 */
+	public function process(File $phpcsFile, $openTagPointer): void
+	{
+		if (TokenHelper::findPrevious($phpcsFile, T_OPEN_TAG, $openTagPointer - 1) !== null) {
+			return;
+		}
+
+		$tokens = $phpcsFile->getTokens();
+
+		$referencedNames = array_merge(
+			ReferencedNameHelper::getAllReferencedNames($phpcsFile, $openTagPointer),
+			ReferencedNameHelper::getAllReferencedNamesInAttributes($phpcsFile, $openTagPointer)
+		);
+
+		foreach ($referencedNames as $referencedName) {
+			if (!$referencedName->isClass()) {
+				continue;
+			}
+
+			$classPointer = ClassHelper::getClassPointer($phpcsFile, $referencedName->getStartPointer());
+			if ($classPointer === null) {
+				continue;
+			}
+
+			if ($tokens[$classPointer]['code'] === T_ANON_CLASS) {
+				continue;
+			}
+
+			$className = ClassHelper::getFullyQualifiedName($phpcsFile, $classPointer);
+
+			$resolvedName = NamespaceHelper::resolveClassName(
+				$phpcsFile,
+				$referencedName->getNameAsReferencedInFile(),
+				$referencedName->getStartPointer()
+			);
+
+			if ($className !== $resolvedName) {
+				continue;
+			}
+
+			$fix = $phpcsFile->addFixableError(
+				'"self" for local reference is required.',
+				$referencedName->getStartPointer(),
+				self::CODE_REQUIRED_SELF_REFERENCE
+			);
+			if (!$fix) {
+				continue;
+			}
+
+			$inAttribute = $tokens[$referencedName->getStartPointer()]['code'] === T_ATTRIBUTE;
+
+			$phpcsFile->fixer->beginChangeset();
+
+			if ($inAttribute) {
+				$attributeContent = TokenHelper::getContent(
+					$phpcsFile,
+					$referencedName->getStartPointer(),
+					$referencedName->getEndPointer()
+				);
+				$fixedAttributeContent = preg_replace(
+					'~(?<=\W)' . preg_quote($referencedName->getNameAsReferencedInFile(), '~') . '(?=\W)~',
+					'self',
+					$attributeContent
+				);
+				$phpcsFile->fixer->replaceToken($referencedName->getStartPointer(), $fixedAttributeContent);
+
+			} else {
+				$phpcsFile->fixer->replaceToken($referencedName->getStartPointer(), 'self');
+			}
+
+			FixerHelper::removeBetweenIncluding($phpcsFile, $referencedName->getStartPointer() + 1, $referencedName->getEndPointer());
+
+			$phpcsFile->fixer->endChangeset();
+		}
+	}
+
+}

doc/classes.md

@@ -207,6 +207,10 @@ Sniff provides the following settings:
 
 * `excludedMethodPatterns`: allows to configure which methods are excluded from sniff detection. This is an array of regular expressions (PCRE) with delimiters. You should not use this with `includedMethodPatterns`, as it will not work properly.
 
+#### SlevomatCodingStandard.Classes.RequireSelfReference 🔧
+
+Requires `self` for local reference.
+
 #### SlevomatCodingStandard.Classes.RequireSingleLineMethodSignature 🔧
 
 Enforces method signature to be on a single line.

tests/Sniffs/Classes/RequireSelfReferenceSniffTest.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types = 1);
+
+namespace SlevomatCodingStandard\Sniffs\Classes;
+
+use SlevomatCodingStandard\Sniffs\TestCase;
+
+class RequireSelfReferenceSniffTest extends TestCase
+{
+
+	public function testNoErrors(): void
+	{
+		$report = self::checkFile(__DIR__ . '/data/requireSelfReferenceNoErrors.php');
+
+		self::assertNoSniffErrorInFile($report);
+	}
+
+	public function testErrors(): void
+	{
+		$report = self::checkFile(__DIR__ . '/data/requireSelfReferenceErrors.php');
+
+		self::assertSame(10, $report->getErrorCount());
+
+		foreach ([14, 16, 19, 20, 23, 24, 26, 28] as $line) {
+			self::assertSniffError($report, $line, RequireSelfReferenceSniff::CODE_REQUIRED_SELF_REFERENCE);
+		}
+
+		self::assertAllFixedInFile($report);
+	}
+
+}

tests/Sniffs/Classes/data/requireSelfReferenceErrors.fixed.php

@@ -0,0 +1,32 @@
+<?php // lint >= 8.0
+
+namespace SomeNamespace;
+
+class Anything
+{
+
+}
+
+class Whatever
+{
+
+	const FIRST_CONSTANT = 'first';
+	const SECOND_CONSTANT = self::FIRST_CONSTANT;
+
+	private $property = self::SECOND_CONSTANT;
+
+	private $arrayProperty = [
+		self::FIRST_CONSTANT,
+		self::SECOND_CONSTANT,
+	];
+
+	#[Attribute(self::FIRST_CONSTANT)]
+	public function doSomething(self $parameter): self
+	{
+		$arrowFunction = fn ($a = self::SECOND_CONSTANT): ?self => null;
+
+		return function (): self|Anything {
+		};
+	}
+
+}

tests/Sniffs/Classes/data/requireSelfReferenceErrors.php

@@ -0,0 +1,32 @@
+<?php // lint >= 8.0
+
+namespace SomeNamespace;
+
+class Anything
+{
+
+}
+
+class Whatever
+{
+
+	const FIRST_CONSTANT = 'first';
+	const SECOND_CONSTANT = \SomeNamespace\Whatever::FIRST_CONSTANT;
+
+	private $property = Whatever::SECOND_CONSTANT;
+
+	private $arrayProperty = [
+		Whatever::FIRST_CONSTANT,
+		\SomeNamespace\Whatever::SECOND_CONSTANT,
+	];
+
+	#[Attribute(Whatever::FIRST_CONSTANT)]
+	public function doSomething(\SomeNamespace\Whatever $parameter): Whatever
+	{
+		$arrowFunction = fn ($a = Whatever::SECOND_CONSTANT): ?Whatever => null;
+
+		return function (): Whatever|Anything {
+		};
+	}
+
+}

tests/Sniffs/Classes/data/requireSelfReferenceNoErrors.php

@@ -0,0 +1,26 @@
+<?php
+
+?><?php
+
+class Whatever
+{
+
+	const SOME_CONSTANT = PHP_VERSION;
+
+	public function doSomething(): self
+	{
+		return new class extends Anything {
+
+			public function doSomethingElse(): Whatever
+			{
+
+			}
+
+		};
+	}
+
+}
+
+$function = function (): Whatever {
+
+};