- extending a class, implementing an interface - typehinting a class or an interface - creating new instance of a class - class whose static method or a property is accessed - thrown and caught exception names Following occurrences are not considered as a referenced name: - namespace name - type name in a use statement - class name in a class definition
 /**
  * @param \PHP_CodeSniffer_File $phpcsFile
  * @param integer $openTagPointer
  */
 public function process(PHP_CodeSniffer_File $phpcsFile, $openTagPointer)
 {
     $referencedNames = ReferencedNameHelper::getAllReferencedNames($phpcsFile, $openTagPointer);
     $useStatements = UseStatementHelper::getUseStatements($phpcsFile, $openTagPointer);
     foreach ($referencedNames as $referencedName) {
         $pointer = $referencedName->getPointer();
         $name = $referencedName->getNameAsReferencedInFile();
         $normalizedName = UseStatement::normalizedNameAsReferencedInFile($name);
         if (isset($useStatements[$normalizedName]) && $referencedName->hasSameUseStatementType($useStatements[$normalizedName])) {
             $useStatement = $useStatements[$normalizedName];
             if (in_array($useStatement->getFullyQualifiedTypeName(), $this->getIgnoredNames(), true) || !StringHelper::endsWith($useStatement->getFullyQualifiedTypeName(), 'Exception') && $useStatement->getFullyQualifiedTypeName() !== 'Throwable' && (!StringHelper::endsWith($useStatement->getFullyQualifiedTypeName(), 'Error') || NamespaceHelper::hasNamespace($useStatement->getFullyQualifiedTypeName())) && !in_array($useStatement->getFullyQualifiedTypeName(), $this->getSpecialExceptionNames(), true)) {
                 continue;
             }
         } else {
             $fileNamespace = NamespaceHelper::findCurrentNamespaceName($phpcsFile, $pointer);
             $canonicalName = $name;
             if (!NamespaceHelper::isFullyQualifiedName($name) && $fileNamespace !== null) {
                 $canonicalName = sprintf('%s%s%s', $fileNamespace, NamespaceHelper::NAMESPACE_SEPARATOR, $name);
             }
             if (in_array($canonicalName, $this->getIgnoredNames(), true) || !StringHelper::endsWith($name, 'Exception') && $name !== 'Throwable' && (!StringHelper::endsWith($canonicalName, 'Error') || NamespaceHelper::hasNamespace($canonicalName)) && !in_array($canonicalName, $this->getSpecialExceptionNames(), true)) {
                 continue;
             }
         }
         if (!NamespaceHelper::isFullyQualifiedName($name)) {
             $phpcsFile->addError(sprintf('Exception %s should be referenced via a fully qualified name', $name), $pointer, self::CODE_NON_FULLY_QUALIFIED_EXCEPTION);
         }
     }
 }
Пример #2
0
 /**
  * @param \PHP_CodeSniffer_File $phpcsFile
  * @param integer $openTagPointer
  */
 public function process(PHP_CodeSniffer_File $phpcsFile, $openTagPointer)
 {
     $unusedNames = UseStatementHelper::getUseStatements($phpcsFile, $openTagPointer);
     $referencedNames = ReferencedNameHelper::getAllReferencedNames($phpcsFile, $openTagPointer, $this->searchAnnotations);
     foreach ($referencedNames as $referencedName) {
         $name = $referencedName->getNameAsReferencedInFile();
         $pointer = $referencedName->getPointer();
         $nameParts = NamespaceHelper::getNameParts($name);
         $nameAsReferencedInFile = $nameParts[0];
         $normalizedNameAsReferencedInFile = UseStatement::normalizedNameAsReferencedInFile($nameAsReferencedInFile);
         if (!NamespaceHelper::isFullyQualifiedName($name) && isset($unusedNames[$normalizedNameAsReferencedInFile])) {
             if ($unusedNames[$normalizedNameAsReferencedInFile]->getNameAsReferencedInFile() !== $nameAsReferencedInFile) {
                 $phpcsFile->addError(sprintf('Case of reference name %s and use statement %s do not match', $nameAsReferencedInFile, $unusedNames[$normalizedNameAsReferencedInFile]->getNameAsReferencedInFile()), $pointer, self::CODE_MISMATCHING_CASE);
             }
             unset($unusedNames[$normalizedNameAsReferencedInFile]);
         }
     }
     foreach ($unusedNames as $value) {
         $fullName = $value->getFullyQualifiedTypeName();
         if ($value->getNameAsReferencedInFile() !== $fullName) {
             if ($value->getNameAsReferencedInFile() !== NamespaceHelper::getUnqualifiedNameFromFullyQualifiedName($fullName)) {
                 $fullName .= sprintf(' (as %s)', $value->getNameAsReferencedInFile());
             }
         }
         $fix = $phpcsFile->addFixableError(sprintf('Type %s is not used in this file', $fullName), $value->getPointer(), self::CODE_UNUSED_USE);
         if ($fix) {
             $phpcsFile->fixer->beginChangeset();
             $endPointer = $phpcsFile->findNext(T_SEMICOLON, $value->getPointer()) + 1;
             for ($i = $value->getPointer(); $i <= $endPointer; $i++) {
                 $phpcsFile->fixer->replaceToken($i, '');
             }
             $phpcsFile->fixer->endChangeset();
         }
     }
 }
 /**
  * @param \PHP_CodeSniffer_File $phpcsFile
  * @param integer $openTagPointer
  */
 public function process(PHP_CodeSniffer_File $phpcsFile, $openTagPointer)
 {
     $tokens = $phpcsFile->getTokens();
     $referencedNames = ReferencedNameHelper::getAllReferencedNames($phpcsFile, $openTagPointer);
     foreach ($referencedNames as $referencedName) {
         $name = $referencedName->getNameAsReferencedInFile();
         $pointer = $referencedName->getPointer();
         if (NamespaceHelper::isFullyQualifiedName($name)) {
             if ((!(StringHelper::endsWith($name, 'Exception') || in_array(NamespaceHelper::normalizeToCanonicalName($name), $this->getSpecialExceptionNames(), true)) || !$this->allowFullyQualifiedExceptions) && $this->isClassRequiredToBeUsed($name)) {
                 $previousKeywordPointer = TokenHelper::findPreviousExcluding($phpcsFile, array_merge(TokenHelper::$nameTokenCodes, [T_WHITESPACE, T_COMMA]), $pointer - 1);
                 if (!in_array($tokens[$previousKeywordPointer]['code'], $this->getFullyQualifiedKeywords(), true)) {
                     if (!NamespaceHelper::hasNamespace($name) && NamespaceHelper::findCurrentNamespaceName($phpcsFile, $pointer) === null) {
                         $phpcsFile->addError(sprintf('Type %s should not be referenced via a fully qualified name, but via an unqualified name without the leading \\, because the file does not have a namespace and the type cannot be put in a use statement', $name), $pointer, self::CODE_REFERENCE_VIA_FULLY_QUALIFIED_NAME_WITHOUT_NAMESPACE);
                     } else {
                         $phpcsFile->addError(sprintf('Type %s should not be referenced via a fully qualified name, but via a use statement', $name), $pointer, self::CODE_REFERENCE_VIA_FULLY_QUALIFIED_NAME);
                     }
                 }
             }
         } elseif (!$this->allowPartialUses) {
             if (NamespaceHelper::isQualifiedName($name)) {
                 $phpcsFile->addError(sprintf('Partial use statements are not allowed, but referencing %s found', $name), $pointer, self::CODE_PARTIAL_USE);
             }
         }
     }
 }
 /**
  * @param \PHP_CodeSniffer_File $phpcsFile
  * @param integer $keywordPointer
  * @param integer $nameStartPointer
  * @return integer Referenced name end pointer (exclusive)
  */
 private function checkReferencedName(PHP_CodeSniffer_File $phpcsFile, $keywordPointer, $nameStartPointer)
 {
     $tokens = $phpcsFile->getTokens();
     $nameStartToken = $tokens[$nameStartPointer];
     $endPointer = ReferencedNameHelper::findReferencedNameEndPointer($phpcsFile, $nameStartPointer);
     if ($nameStartToken['code'] !== T_NS_SEPARATOR) {
         $name = TokenHelper::getContent($phpcsFile, $nameStartPointer, $endPointer);
         $keyword = $tokens[$keywordPointer]['content'];
         $phpcsFile->addError(sprintf('Type %s in %s statement should be referenced via a fully qualified name', $name, $keyword), $keywordPointer, self::getErrorCode($keyword));
     }
     return $endPointer;
 }