prop, self::prop and $var[]. * * @since 7.1.2 * * @var string */ const REGEX_COMPLEX_VARS = '`(?:(\{)?(?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)(?:->\$?(?P>varname)|\[[^\]]+\]|::\$?(?P>varname)|\([^\)]*\))*(?(3)\}|)(?(2)\}|)(?(1)\}|)`'; /** * List of superglobals as an array of strings. * * Used by the ForbiddenParameterShadowSuperGlobals and ForbiddenClosureUseVariableNames sniffs. * * @since 7.0.0 * @since 7.1.4 Moved from the `ForbiddenParameterShadowSuperGlobals` sniff to the base `Sniff` class. * * @var array */ protected $superglobals = array( '$GLOBALS' => true, '$_SERVER' => true, '$_GET' => true, '$_POST' => true, '$_FILES' => true, '$_COOKIE' => true, '$_SESSION' => true, '$_REQUEST' => true, '$_ENV' => true, ); /** * List of functions using hash algorithm as parameter (always the first parameter). * * Used by the new/removed hash algorithm sniffs. * Key is the function name, value is the 1-based parameter position in the function call. * * @since 5.5 * @since 7.0.7 Moved from the `RemovedHashAlgorithms` sniff to the base `Sniff` class. * * @var array */ protected $hashAlgoFunctions = array( 'hash_file' => 1, 'hash_hmac_file' => 1, 'hash_hmac' => 1, 'hash_init' => 1, 'hash_pbkdf2' => 1, 'hash' => 1, ); /** * List of functions which take an ini directive as parameter (always the first parameter). * * Used by the new/removed ini directives sniffs. * Key is the function name, value is the 1-based parameter position in the function call. * * @since 7.1.0 * * @var array */ protected $iniFunctions = array( 'ini_get' => 1, 'ini_set' => 1, ); /** * Get the testVersion configuration variable. * * The testVersion configuration variable may be in any of the following formats: * 1) Omitted/empty, in which case no version is specified. This effectively * disables all the checks for new PHP features provided by this standard. * 2) A single PHP version number, e.g. "5.4" in which case the standard checks that * the code will run on that version of PHP (no deprecated features or newer * features being used). * 3) A range, e.g. "5.0-5.5", in which case the standard checks the code will run * on all PHP versions in that range, and that it doesn't use any features that * were deprecated by the final version in the list, or which were not available * for the first version in the list. * We accept ranges where one of the components is missing, e.g. "-5.6" means * all versions up to PHP 5.6, and "7.0-" means all versions above PHP 7.0. * PHP version numbers should always be in Major.Minor format. Both "5", "5.3.2" * would be treated as invalid, and ignored. * * @since 7.0.0 * @since 7.1.3 Now allows for partial ranges such as `5.2-`. * * @return array $arrTestVersions will hold an array containing min/max version * of PHP that we are checking against (see above). If only a * single version number is specified, then this is used as * both the min and max. * * @throws \PHP_CodeSniffer_Exception If testVersion is invalid. */ private function getTestVersion() { static $arrTestVersions = array(); $default = array(null, null); $testVersion = trim(PHPCSHelper::getConfigData('testVersion')); if (empty($testVersion) === false && isset($arrTestVersions[$testVersion]) === false) { $arrTestVersions[$testVersion] = $default; if (preg_match('`^\d+\.\d+$`', $testVersion)) { $arrTestVersions[$testVersion] = array($testVersion, $testVersion); return $arrTestVersions[$testVersion]; } if (preg_match('`^(\d+\.\d+)?\s*-\s*(\d+\.\d+)?$`', $testVersion, $matches)) { if (empty($matches[1]) === false || empty($matches[2]) === false) { // If no lower-limit is set, we set the min version to 4.0. // Whilst development focuses on PHP 5 and above, we also accept // sniffs for PHP 4, so we include that as the minimum. // (It makes no sense to support PHP 3 as this was effectively a // different language). $min = empty($matches[1]) ? '4.0' : $matches[1]; // If no upper-limit is set, we set the max version to 99.9. $max = empty($matches[2]) ? '99.9' : $matches[2]; if (version_compare($min, $max, '>')) { trigger_error( "Invalid range in testVersion setting: '" . $testVersion . "'", \E_USER_WARNING ); return $default; } else { $arrTestVersions[$testVersion] = array($min, $max); return $arrTestVersions[$testVersion]; } } } trigger_error( "Invalid testVersion setting: '" . $testVersion . "'", \E_USER_WARNING ); return $default; } if (isset($arrTestVersions[$testVersion])) { return $arrTestVersions[$testVersion]; } return $default; } /** * Check whether a specific PHP version is equal to or higher than the maximum * supported PHP version as provided by the user in `testVersion`. * * Should be used when sniffing for *old* PHP features (deprecated/removed). * * @since 5.6 * * @param string $phpVersion A PHP version number in 'major.minor' format. * * @return bool True if testVersion has not been provided or if the PHP version * is equal to or higher than the highest supported PHP version * in testVersion. False otherwise. */ public function supportsAbove($phpVersion) { $testVersion = $this->getTestVersion(); $testVersion = $testVersion[1]; if (\is_null($testVersion) || version_compare($testVersion, $phpVersion) >= 0 ) { return true; } else { return false; } } /** * Check whether a specific PHP version is equal to or lower than the minimum * supported PHP version as provided by the user in `testVersion`. * * Should be used when sniffing for *new* PHP features. * * @since 5.6 * * @param string $phpVersion A PHP version number in 'major.minor' format. * * @return bool True if the PHP version is equal to or lower than the lowest * supported PHP version in testVersion. * False otherwise or if no testVersion is provided. */ public function supportsBelow($phpVersion) { $testVersion = $this->getTestVersion(); $testVersion = $testVersion[0]; if (\is_null($testVersion) === false && version_compare($testVersion, $phpVersion) <= 0 ) { return true; } else { return false; } } /** * Add a PHPCS message to the output stack as either a warning or an error. * * @since 7.1.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file the message applies to. * @param string $message The message. * @param int $stackPtr The position of the token * the message relates to. * @param bool $isError Whether to report the message as an * 'error' or 'warning'. * Defaults to true (error). * @param string $code The error code for the message. * Defaults to 'Found'. * @param array $data Optional input for the data replacements. * * @return void */ public function addMessage(File $phpcsFile, $message, $stackPtr, $isError, $code = 'Found', $data = array()) { if ($isError === true) { $phpcsFile->addError($message, $stackPtr, $code, $data); } else { $phpcsFile->addWarning($message, $stackPtr, $code, $data); } } /** * Convert an arbitrary string to an alphanumeric string with underscores. * * Pre-empt issues with arbitrary strings being used as error codes in XML and PHP. * * @since 7.1.0 * * @param string $baseString Arbitrary string. * * @return string */ public function stringToErrorCode($baseString) { return preg_replace('`[^a-z0-9_]`i', '_', strtolower($baseString)); } /** * Strip quotes surrounding an arbitrary string. * * Intended for use with the contents of a T_CONSTANT_ENCAPSED_STRING / T_DOUBLE_QUOTED_STRING. * * @since 7.0.6 * * @param string $string The raw string. * * @return string String without quotes around it. */ public function stripQuotes($string) { return preg_replace('`^([\'"])(.*)\1$`Ds', '$2', $string); } /** * Strip variables from an arbitrary double quoted string. * * Intended for use with the contents of a T_DOUBLE_QUOTED_STRING. * * @since 7.1.2 * * @param string $string The raw string. * * @return string String without variables in it. */ public function stripVariables($string) { if (strpos($string, '$') === false) { return $string; } return preg_replace(self::REGEX_COMPLEX_VARS, '', $string); } /** * Make all top level array keys in an array lowercase. * * @since 7.1.0 * * @param array $array Initial array. * * @return array Same array, but with all lowercase top level keys. */ public function arrayKeysToLowercase($array) { return array_change_key_case($array, \CASE_LOWER); } /** * Checks if a function call has parameters. * * Expects to be passed the T_STRING or T_VARIABLE stack pointer for the function call. * If passed a T_STRING which is *not* a function call, the behaviour is unreliable. * * Extra feature: If passed an T_ARRAY or T_OPEN_SHORT_ARRAY stack pointer, it * will detect whether the array has values or is empty. * * @link https://github.com/PHPCompatibility/PHPCompatibility/issues/120 * @link https://github.com/PHPCompatibility/PHPCompatibility/issues/152 * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the function call token. * * @return bool */ public function doesFunctionCallHaveParameters(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return false; } // Is this one of the tokens this function handles ? if (\in_array($tokens[$stackPtr]['code'], array(\T_STRING, \T_ARRAY, \T_OPEN_SHORT_ARRAY, \T_VARIABLE), true) === false) { return false; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true); // Deal with short array syntax. if ($tokens[$stackPtr]['code'] === \T_OPEN_SHORT_ARRAY) { if (isset($tokens[$stackPtr]['bracket_closer']) === false) { return false; } if ($nextNonEmpty === $tokens[$stackPtr]['bracket_closer']) { // No parameters. return false; } else { return true; } } // Deal with function calls & long arrays. // Next non-empty token should be the open parenthesis. if ($nextNonEmpty === false && $tokens[$nextNonEmpty]['code'] !== \T_OPEN_PARENTHESIS) { return false; } if (isset($tokens[$nextNonEmpty]['parenthesis_closer']) === false) { return false; } $closeParenthesis = $tokens[$nextNonEmpty]['parenthesis_closer']; $nextNextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $nextNonEmpty + 1, $closeParenthesis + 1, true); if ($nextNextNonEmpty === $closeParenthesis) { // No parameters. return false; } return true; } /** * Count the number of parameters a function call has been passed. * * Expects to be passed the T_STRING or T_VARIABLE stack pointer for the function call. * If passed a T_STRING which is *not* a function call, the behaviour is unreliable. * * Extra feature: If passed an T_ARRAY or T_OPEN_SHORT_ARRAY stack pointer, * it will return the number of values in the array. * * @link https://github.com/PHPCompatibility/PHPCompatibility/issues/111 * @link https://github.com/PHPCompatibility/PHPCompatibility/issues/114 * @link https://github.com/PHPCompatibility/PHPCompatibility/issues/151 * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the function call token. * * @return int */ public function getFunctionCallParameterCount(File $phpcsFile, $stackPtr) { if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) { return 0; } return \count($this->getFunctionCallParameters($phpcsFile, $stackPtr)); } /** * Get information on all parameters passed to a function call. * * Expects to be passed the T_STRING or T_VARIABLE stack pointer for the function call. * If passed a T_STRING which is *not* a function call, the behaviour is unreliable. * * Will return an multi-dimentional array with the start token pointer, end token * pointer and raw parameter value for all parameters. Index will be 1-based. * If no parameters are found, will return an empty array. * * Extra feature: If passed an T_ARRAY or T_OPEN_SHORT_ARRAY stack pointer, * it will tokenize the values / key/value pairs contained in the array call. * * @since 7.0.5 Split off from the `getFunctionCallParameterCount()` method. * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the function call token. * * @return array */ public function getFunctionCallParameters(File $phpcsFile, $stackPtr) { if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) { return array(); } // Ok, we know we have a T_STRING, T_VARIABLE, T_ARRAY or T_OPEN_SHORT_ARRAY with parameters // and valid open & close brackets/parenthesis. $tokens = $phpcsFile->getTokens(); // Mark the beginning and end tokens. if ($tokens[$stackPtr]['code'] === \T_OPEN_SHORT_ARRAY) { $opener = $stackPtr; $closer = $tokens[$stackPtr]['bracket_closer']; $nestedParenthesisCount = 0; } else { $opener = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true); $closer = $tokens[$opener]['parenthesis_closer']; $nestedParenthesisCount = 1; } // Which nesting level is the one we are interested in ? if (isset($tokens[$opener]['nested_parenthesis'])) { $nestedParenthesisCount += \count($tokens[$opener]['nested_parenthesis']); } $parameters = array(); $nextComma = $opener; $paramStart = $opener + 1; $cnt = 1; while (($nextComma = $phpcsFile->findNext(array(\T_COMMA, $tokens[$closer]['code'], \T_OPEN_SHORT_ARRAY, \T_CLOSURE), $nextComma + 1, $closer + 1)) !== false) { // Ignore anything within short array definition brackets. if ($tokens[$nextComma]['type'] === 'T_OPEN_SHORT_ARRAY' && (isset($tokens[$nextComma]['bracket_opener']) && $tokens[$nextComma]['bracket_opener'] === $nextComma) && isset($tokens[$nextComma]['bracket_closer']) ) { // Skip forward to the end of the short array definition. $nextComma = $tokens[$nextComma]['bracket_closer']; continue; } // Skip past closures passed as function parameters. if ($tokens[$nextComma]['type'] === 'T_CLOSURE' && (isset($tokens[$nextComma]['scope_condition']) && $tokens[$nextComma]['scope_condition'] === $nextComma) && isset($tokens[$nextComma]['scope_closer']) ) { // Skip forward to the end of the closure declaration. $nextComma = $tokens[$nextComma]['scope_closer']; continue; } // Ignore comma's at a lower nesting level. if ($tokens[$nextComma]['type'] === 'T_COMMA' && isset($tokens[$nextComma]['nested_parenthesis']) && \count($tokens[$nextComma]['nested_parenthesis']) !== $nestedParenthesisCount ) { continue; } // Ignore closing parenthesis/bracket if not 'ours'. if ($tokens[$nextComma]['type'] === $tokens[$closer]['type'] && $nextComma !== $closer) { continue; } // Ok, we've reached the end of the parameter. $parameters[$cnt]['start'] = $paramStart; $parameters[$cnt]['end'] = $nextComma - 1; $parameters[$cnt]['raw'] = trim($phpcsFile->getTokensAsString($paramStart, ($nextComma - $paramStart))); /* * Check if there are more tokens before the closing parenthesis. * Prevents code like the following from setting a third parameter: * `functionCall( $param1, $param2, );`. */ $hasNextParam = $phpcsFile->findNext(Tokens::$emptyTokens, $nextComma + 1, $closer, true, null, true); if ($hasNextParam === false) { break; } // Prepare for the next parameter. $paramStart = $nextComma + 1; $cnt++; } return $parameters; } /** * Get information on a specific parameter passed to a function call. * * Expects to be passed the T_STRING or T_VARIABLE stack pointer for the function call. * If passed a T_STRING which is *not* a function call, the behaviour is unreliable. * * Will return a array with the start token pointer, end token pointer and the raw value * of the parameter at a specific offset. * If the specified parameter is not found, will return false. * * @since 7.0.5 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the function call token. * @param int $paramOffset The 1-based index position of the parameter to retrieve. * * @return array|false */ public function getFunctionCallParameter(File $phpcsFile, $stackPtr, $paramOffset) { $parameters = $this->getFunctionCallParameters($phpcsFile, $stackPtr); if (isset($parameters[$paramOffset]) === false) { return false; } else { return $parameters[$paramOffset]; } } /** * Verify whether a token is within a scoped condition. * * If the optional $validScopes parameter has been passed, the function * will check that the token has at least one condition which is of a * type defined in $validScopes. * * @since 7.0.5 Largely split off from the `inClassScope()` method. * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the token. * @param array|int $validScopes Optional. Array of valid scopes * or int value of a valid scope. * Pass the T_.. constant(s) for the * desired scope to this parameter. * * @return bool Without the optional $scopeTypes: True if within a scope, false otherwise. * If the $scopeTypes are set: True if *one* of the conditions is a * valid scope, false otherwise. */ public function tokenHasScope(File $phpcsFile, $stackPtr, $validScopes = null) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return false; } // No conditions = no scope. if (empty($tokens[$stackPtr]['conditions'])) { return false; } // Ok, there are conditions, do we have to check for specific ones ? if (isset($validScopes) === false) { return true; } return $phpcsFile->hasCondition($stackPtr, $validScopes); } /** * Verify whether a token is within a class scope. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the token. * @param bool $strict Whether to strictly check for the T_CLASS * scope or also accept interfaces and traits * as scope. * * @return bool True if within class scope, false otherwise. */ public function inClassScope(File $phpcsFile, $stackPtr, $strict = true) { $validScopes = array(\T_CLASS); if (\defined('T_ANON_CLASS') === true) { $validScopes[] = \T_ANON_CLASS; } if ($strict === false) { $validScopes[] = \T_INTERFACE; $validScopes[] = \T_TRAIT; } return $phpcsFile->hasCondition($stackPtr, $validScopes); } /** * Returns the fully qualified class name for a new class instantiation. * * Returns an empty string if the class name could not be reliably inferred. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of a T_NEW token. * * @return string */ public function getFQClassNameFromNewToken(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return ''; } if ($tokens[$stackPtr]['code'] !== \T_NEW) { return ''; } $start = $phpcsFile->findNext(Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true); if ($start === false) { return ''; } // Bow out if the next token is a variable as we don't know where it was defined. if ($tokens[$start]['code'] === \T_VARIABLE) { return ''; } // Bow out if the next token is the class keyword. if ($tokens[$start]['type'] === 'T_ANON_CLASS' || $tokens[$start]['code'] === \T_CLASS) { return ''; } $find = array( \T_NS_SEPARATOR, \T_STRING, \T_NAMESPACE, \T_WHITESPACE, ); $end = $phpcsFile->findNext($find, ($start + 1), null, true, null, true); $className = $phpcsFile->getTokensAsString($start, ($end - $start)); $className = trim($className); return $this->getFQName($phpcsFile, $stackPtr, $className); } /** * Returns the fully qualified name of the class that the specified class extends. * * Returns an empty string if the class does not extend another class or if * the class name could not be reliably inferred. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of a T_CLASS token. * * @return string */ public function getFQExtendedClassName(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return ''; } if ($tokens[$stackPtr]['code'] !== \T_CLASS && $tokens[$stackPtr]['type'] !== 'T_ANON_CLASS' && $tokens[$stackPtr]['type'] !== 'T_INTERFACE' ) { return ''; } $extends = PHPCSHelper::findExtendedClassName($phpcsFile, $stackPtr); if (empty($extends) || \is_string($extends) === false) { return ''; } return $this->getFQName($phpcsFile, $stackPtr, $extends); } /** * Returns the class name for the static usage of a class. * This can be a call to a method, the use of a property or constant. * * Returns an empty string if the class name could not be reliably inferred. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of a T_NEW token. * * @return string */ public function getFQClassNameFromDoubleColonToken(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return ''; } if ($tokens[$stackPtr]['code'] !== \T_DOUBLE_COLON) { return ''; } // Nothing to do if previous token is a variable as we don't know where it was defined. if ($tokens[$stackPtr - 1]['code'] === \T_VARIABLE) { return ''; } // Nothing to do if 'parent' or 'static' as we don't know how far the class tree extends. if (\in_array($tokens[$stackPtr - 1]['code'], array(\T_PARENT, \T_STATIC), true)) { return ''; } // Get the classname from the class declaration if self is used. if ($tokens[$stackPtr - 1]['code'] === \T_SELF) { $classDeclarationPtr = $phpcsFile->findPrevious(\T_CLASS, $stackPtr - 1); if ($classDeclarationPtr === false) { return ''; } $className = $phpcsFile->getDeclarationName($classDeclarationPtr); return $this->getFQName($phpcsFile, $classDeclarationPtr, $className); } $find = array( \T_NS_SEPARATOR, \T_STRING, \T_NAMESPACE, \T_WHITESPACE, ); $start = $phpcsFile->findPrevious($find, $stackPtr - 1, null, true, null, true); if ($start === false || isset($tokens[($start + 1)]) === false) { return ''; } $start = ($start + 1); $className = $phpcsFile->getTokensAsString($start, ($stackPtr - $start)); $className = trim($className); return $this->getFQName($phpcsFile, $stackPtr, $className); } /** * Get the Fully Qualified name for a class/function/constant etc. * * Checks if a class/function/constant name is already fully qualified and * if not, enrich it with the relevant namespace information. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the token. * @param string $name The class / function / constant name. * * @return string */ public function getFQName(File $phpcsFile, $stackPtr, $name) { if (strpos($name, '\\') === 0) { // Already fully qualified. return $name; } // Remove the namespace keyword if used. if (strpos($name, 'namespace\\') === 0) { $name = substr($name, 10); } $namespace = $this->determineNamespace($phpcsFile, $stackPtr); if ($namespace === '') { return '\\' . $name; } else { return '\\' . $namespace . '\\' . $name; } } /** * Is the class/function/constant name namespaced or global ? * * @since 7.0.3 * * @param string $FQName Fully Qualified name of a class, function etc. * I.e. should always start with a `\`. * * @return bool True if namespaced, false if global. * * @throws \PHP_CodeSniffer_Exception If the name in the passed parameter * is not fully qualified. */ public function isNamespaced($FQName) { if (strpos($FQName, '\\') !== 0) { throw new PHPCS_Exception('$FQName must be a fully qualified name'); } return (strpos(substr($FQName, 1), '\\') !== false); } /** * Determine the namespace name an arbitrary token lives in. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int $stackPtr The token position for which to determine the namespace. * * @return string Namespace name or empty string if it couldn't be determined or no namespace applies. */ public function determineNamespace(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return ''; } // Check for scoped namespace {}. if (empty($tokens[$stackPtr]['conditions']) === false) { $namespacePtr = $phpcsFile->getCondition($stackPtr, \T_NAMESPACE); if ($namespacePtr !== false) { $namespace = $this->getDeclaredNamespaceName($phpcsFile, $namespacePtr); if ($namespace !== false) { return $namespace; } // We are in a scoped namespace, but couldn't determine the name. Searching for a global namespace is futile. return ''; } } /* * Not in a scoped namespace, so let's see if we can find a non-scoped namespace instead. * Keeping in mind that: * - there can be multiple non-scoped namespaces in a file (bad practice, but it happens). * - the namespace keyword can also be used as part of a function/method call and such. * - that a non-named namespace resolves to the global namespace. */ $previousNSToken = $stackPtr; $namespace = false; do { $previousNSToken = $phpcsFile->findPrevious(\T_NAMESPACE, ($previousNSToken - 1)); // Stop if we encounter a scoped namespace declaration as we already know we're not in one. if (empty($tokens[$previousNSToken]['scope_condition']) === false && $tokens[$previousNSToken]['scope_condition'] === $previousNSToken) { break; } $namespace = $this->getDeclaredNamespaceName($phpcsFile, $previousNSToken); } while ($namespace === false && $previousNSToken !== false); // If we still haven't got a namespace, return an empty string. if ($namespace === false) { return ''; } else { return $namespace; } } /** * Get the complete namespace name for a namespace declaration. * * For hierarchical namespaces, the name will be composed of several tokens, * i.e. MyProject\Sub\Level which will be returned together as one string. * * @since 7.0.3 * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int|bool $stackPtr The position of a T_NAMESPACE token. * * @return string|false Namespace name or false if not a namespace declaration. * Namespace name can be an empty string for global namespace declaration. */ public function getDeclaredNamespaceName(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if ($stackPtr === false || isset($tokens[$stackPtr]) === false) { return false; } if ($tokens[$stackPtr]['code'] !== \T_NAMESPACE) { return false; } if ($tokens[($stackPtr + 1)]['code'] === \T_NS_SEPARATOR) { // Not a namespace declaration, but use of, i.e. `namespace\someFunction();`. return false; } $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true, null, true); if ($tokens[$nextToken]['code'] === \T_OPEN_CURLY_BRACKET) { /* * Declaration for global namespace when using multiple namespaces in a file. * I.e.: `namespace {}`. */ return ''; } // Ok, this should be a namespace declaration, so get all the parts together. $validTokens = array( \T_STRING => true, \T_NS_SEPARATOR => true, \T_WHITESPACE => true, ); $namespaceName = ''; while (isset($validTokens[$tokens[$nextToken]['code']]) === true) { $namespaceName .= trim($tokens[$nextToken]['content']); $nextToken++; } return $namespaceName; } /** * Get the stack pointer for a return type token for a given function. * * Compatible layer for older PHPCS versions which don't recognize * return type hints correctly. * * Expects to be passed T_RETURN_TYPE, T_FUNCTION or T_CLOSURE token. * * @since 7.1.2 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the token. * * @return int|false Stack pointer to the return type token or false if * no return type was found or the passed token was * not of the correct type. */ public function getReturnTypeHintToken(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (\defined('T_RETURN_TYPE') && $tokens[$stackPtr]['code'] === \T_RETURN_TYPE) { return $stackPtr; } if ($tokens[$stackPtr]['code'] !== \T_FUNCTION && $tokens[$stackPtr]['code'] !== \T_CLOSURE) { return false; } if (isset($tokens[$stackPtr]['parenthesis_closer']) === false) { return false; } // Allow for interface and abstract method declarations. $endOfFunctionDeclaration = null; if (isset($tokens[$stackPtr]['scope_opener'])) { $endOfFunctionDeclaration = $tokens[$stackPtr]['scope_opener']; } else { $nextSemiColon = $phpcsFile->findNext(\T_SEMICOLON, ($tokens[$stackPtr]['parenthesis_closer'] + 1), null, false, null, true); if ($nextSemiColon !== false) { $endOfFunctionDeclaration = $nextSemiColon; } } if (isset($endOfFunctionDeclaration) === false) { return false; } $hasColon = $phpcsFile->findNext( array(\T_COLON, \T_INLINE_ELSE), ($tokens[$stackPtr]['parenthesis_closer'] + 1), $endOfFunctionDeclaration ); if ($hasColon === false) { return false; } /* * - `self`, `parent` and `callable` are not being recognized as return types in PHPCS < 2.6.0. * - Return types are not recognized at all in PHPCS < 2.4.0. * - The T_RETURN_TYPE token is defined, but no longer in use since PHPCS 3.3.0+. * The token will now be tokenized as T_STRING. * - An `array` (return) type declaration was tokenized as `T_ARRAY_HINT` in PHPCS 2.3.3 - 3.2.3 * to prevent confusing sniffs looking for array declarations. * As of PHPCS 3.3.0 `array` as a type declaration will be tokenized as `T_STRING`. */ $unrecognizedTypes = array( \T_CALLABLE, \T_SELF, \T_PARENT, \T_ARRAY, // PHPCS < 2.4.0. \T_STRING, ); return $phpcsFile->findPrevious($unrecognizedTypes, ($endOfFunctionDeclaration - 1), $hasColon); } /** * Get the complete return type declaration for a given function. * * Cross-version compatible way to retrieve the complete return type declaration. * * For a classname-based return type, PHPCS, as well as the Sniff::getReturnTypeHintToken() * method will mark the classname as the return type token. * This method will find preceeding namespaces and namespace separators and will return a * string containing the qualified return type declaration. * * Expects to be passed a T_RETURN_TYPE token or the return value from a call to * the Sniff::getReturnTypeHintToken() method. * * @since 8.2.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the return type token. * * @return string The name of the return type token. */ public function getReturnTypeHintName(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // In older PHPCS versions, the nullable indicator will turn a return type colon into a T_INLINE_ELSE. $colon = $phpcsFile->findPrevious(array(\T_COLON, \T_INLINE_ELSE, \T_FUNCTION, \T_CLOSE_PARENTHESIS), ($stackPtr - 1)); if ($colon === false || ($tokens[$colon]['code'] !== \T_COLON && $tokens[$colon]['code'] !== \T_INLINE_ELSE) ) { // Shouldn't happen, just in case. return ''; } $returnTypeHint = ''; for ($i = ($colon + 1); $i <= $stackPtr; $i++) { // As of PHPCS 3.3.0+, all tokens are tokenized as "normal", so T_CALLABLE, T_SELF etc are // all possible, just exclude anything that's regarded as empty and the nullable indicator. if (isset(Tokens::$emptyTokens[$tokens[$i]['code']])) { continue; } if ($tokens[$i]['type'] === 'T_NULLABLE') { continue; } if (\defined('T_NULLABLE') === false && $tokens[$i]['code'] === \T_INLINE_THEN) { // Old PHPCS. continue; } $returnTypeHint .= $tokens[$i]['content']; } return $returnTypeHint; } /** * Check whether a T_VARIABLE token is a class property declaration. * * Compatibility layer for PHPCS cross-version compatibility * as PHPCS 2.4.0 - 2.7.1 does not have good enough support for * anonymous classes. Along the same lines, the`getMemberProperties()` * method does not support the `var` prefix. * * @since 7.1.4 * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int $stackPtr The position in the stack of the * T_VARIABLE token to verify. * * @return bool */ public function isClassProperty(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]) === false || $tokens[$stackPtr]['code'] !== \T_VARIABLE) { return false; } // Note: interfaces can not declare properties. $validScopes = array( 'T_CLASS' => true, 'T_ANON_CLASS' => true, 'T_TRAIT' => true, ); $scopePtr = $this->validDirectScope($phpcsFile, $stackPtr, $validScopes); if ($scopePtr !== false) { // Make sure it's not a method parameter. if (empty($tokens[$stackPtr]['nested_parenthesis']) === true) { return true; } else { $parenthesis = array_keys($tokens[$stackPtr]['nested_parenthesis']); $deepestOpen = array_pop($parenthesis); if ($deepestOpen < $scopePtr || isset($tokens[$deepestOpen]['parenthesis_owner']) === false || $tokens[$tokens[$deepestOpen]['parenthesis_owner']]['code'] !== \T_FUNCTION ) { return true; } } } return false; } /** * Check whether a T_CONST token is a class constant declaration. * * @since 7.1.4 * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int $stackPtr The position in the stack of the * T_CONST token to verify. * * @return bool */ public function isClassConstant(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]) === false || $tokens[$stackPtr]['code'] !== \T_CONST) { return false; } // Note: traits can not declare constants. $validScopes = array( 'T_CLASS' => true, 'T_ANON_CLASS' => true, 'T_INTERFACE' => true, ); if ($this->validDirectScope($phpcsFile, $stackPtr, $validScopes) !== false) { return true; } return false; } /** * Check whether the direct wrapping scope of a token is within a limited set of * acceptable tokens. * * Used to check, for instance, if a T_CONST is a class constant. * * @since 7.1.4 * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int $stackPtr The position in the stack of the * token to verify. * @param array $validScopes Array of token types. * Keys should be the token types in string * format to allow for newer token types. * Value is irrelevant. * * @return int|bool StackPtr to the scope if valid, false otherwise. */ protected function validDirectScope(File $phpcsFile, $stackPtr, $validScopes) { $tokens = $phpcsFile->getTokens(); if (empty($tokens[$stackPtr]['conditions']) === true) { return false; } /* * Check only the direct wrapping scope of the token. */ $conditions = array_keys($tokens[$stackPtr]['conditions']); $ptr = array_pop($conditions); if (isset($tokens[$ptr]) === false) { return false; } if (isset($validScopes[$tokens[$ptr]['type']]) === true) { return $ptr; } return false; } /** * Get an array of just the type hints from a function declaration. * * Expects to be passed T_FUNCTION or T_CLOSURE token. * * Strips potential nullable indicator and potential global namespace * indicator from the type hints before returning them. * * @since 7.1.4 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the token. * * @return array Array with type hints or an empty array if * - the function does not have any parameters * - no type hints were found * - or the passed token was not of the correct type. */ public function getTypeHintsFromFunctionDeclaration(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] !== \T_FUNCTION && $tokens[$stackPtr]['code'] !== \T_CLOSURE) { return array(); } $parameters = PHPCSHelper::getMethodParameters($phpcsFile, $stackPtr); if (empty($parameters) || \is_array($parameters) === false) { return array(); } $typeHints = array(); foreach ($parameters as $param) { if ($param['type_hint'] === '') { continue; } // Strip off potential nullable indication. $typeHint = ltrim($param['type_hint'], '?'); // Strip off potential (global) namespace indication. $typeHint = ltrim($typeHint, '\\'); if ($typeHint !== '') { $typeHints[] = $typeHint; } } return $typeHints; } /** * Get the hash algorithm name from the parameter in a hash function call. * * @since 7.0.7 Logic was originally contained in the `RemovedHashAlgorithms` sniff. * * @param \PHP_CodeSniffer_File $phpcsFile Instance of phpcsFile. * @param int $stackPtr The position of the T_STRING function token. * * @return string|false The algorithm name without quotes if this was a relevant hash * function call or false if it was not. */ public function getHashAlgorithmParameter(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return false; } if ($tokens[$stackPtr]['code'] !== \T_STRING) { return false; } $functionName = $tokens[$stackPtr]['content']; $functionNameLc = strtolower($functionName); // Bow out if not one of the functions we're targetting. if (isset($this->hashAlgoFunctions[$functionNameLc]) === false) { return false; } // Get the parameter from the function call which should contain the algorithm name. $algoParam = $this->getFunctionCallParameter($phpcsFile, $stackPtr, $this->hashAlgoFunctions[$functionNameLc]); if ($algoParam === false) { return false; } // Algorithm is a text string, so we need to remove the quotes. $algo = strtolower(trim($algoParam['raw'])); $algo = $this->stripQuotes($algo); return $algo; } /** * Determine whether an arbitrary T_STRING token is the use of a global constant. * * @since 8.1.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the T_STRING token. * * @return bool */ public function isUseOfGlobalConstant(File $phpcsFile, $stackPtr) { static $isLowPHPCS, $isLowPHP; $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return false; } // Is this one of the tokens this function handles ? if ($tokens[$stackPtr]['code'] !== \T_STRING) { return false; } // Check for older PHP, PHPCS version so we can compensate for misidentified tokens. if (isset($isLowPHPCS, $isLowPHP) === false) { $isLowPHP = false; $isLowPHPCS = false; if (version_compare(\PHP_VERSION_ID, '50400', '<')) { $isLowPHP = true; $isLowPHPCS = version_compare(PHPCSHelper::getVersion(), '2.4.0', '<'); } } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next !== false && ($tokens[$next]['code'] === \T_OPEN_PARENTHESIS || $tokens[$next]['code'] === \T_DOUBLE_COLON) ) { // Function call or declaration. return false; } // Array of tokens which if found preceding the $stackPtr indicate that a T_STRING is not a global constant. $tokensToIgnore = array( 'T_NAMESPACE' => true, 'T_USE' => true, 'T_CLASS' => true, 'T_TRAIT' => true, 'T_INTERFACE' => true, 'T_EXTENDS' => true, 'T_IMPLEMENTS' => true, 'T_NEW' => true, 'T_FUNCTION' => true, 'T_DOUBLE_COLON' => true, 'T_OBJECT_OPERATOR' => true, 'T_INSTANCEOF' => true, 'T_INSTEADOF' => true, 'T_GOTO' => true, 'T_AS' => true, 'T_PUBLIC' => true, 'T_PROTECTED' => true, 'T_PRIVATE' => true, ); $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($prev !== false && (isset($tokensToIgnore[$tokens[$prev]['type']]) === true || ($tokens[$prev]['code'] === \T_STRING && (($isLowPHPCS === true && $tokens[$prev]['content'] === 'trait') || ($isLowPHP === true && $tokens[$prev]['content'] === 'insteadof')))) ) { // Not the use of a constant. return false; } if ($prev !== false && $tokens[$prev]['code'] === \T_NS_SEPARATOR && $tokens[($prev - 1)]['code'] === \T_STRING ) { // Namespaced constant of the same name. return false; } if ($prev !== false && $tokens[$prev]['code'] === \T_CONST && $this->isClassConstant($phpcsFile, $prev) === true ) { // Class constant declaration of the same name. return false; } /* * Deal with a number of variations of use statements. */ for ($i = $stackPtr; $i > 0; $i--) { if ($tokens[$i]['line'] !== $tokens[$stackPtr]['line']) { break; } } $firstOnLine = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true); if ($firstOnLine !== false && $tokens[$firstOnLine]['code'] === \T_USE) { $nextOnLine = $phpcsFile->findNext(Tokens::$emptyTokens, ($firstOnLine + 1), null, true); if ($nextOnLine !== false) { if (($tokens[$nextOnLine]['code'] === \T_STRING && $tokens[$nextOnLine]['content'] === 'const') || $tokens[$nextOnLine]['code'] === \T_CONST // Happens in some PHPCS versions. ) { $hasNsSep = $phpcsFile->findNext(\T_NS_SEPARATOR, ($nextOnLine + 1), $stackPtr); if ($hasNsSep !== false) { // Namespaced const (group) use statement. return false; } } else { // Not a const use statement. return false; } } } return true; } /** * Determine whether the tokens between $start and $end together form a positive number * as recognized by PHP. * * The outcome of this function is reliable for `true`, `false` should be regarded as * "undetermined". * * Note: Zero is *not* regarded as a positive number. * * @since 8.2.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $start Start of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param int $end End of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param bool $allowFloats Whether to only consider integers, or also floats. * * @return bool True if PHP would evaluate the snippet as a positive number. * False if not or if it could not be reliably determined * (variable or calculations and such). */ public function isPositiveNumber(File $phpcsFile, $start, $end, $allowFloats = false) { $number = $this->isNumber($phpcsFile, $start, $end, $allowFloats); if ($number === false) { return false; } return ($number > 0); } /** * Determine whether the tokens between $start and $end together form a negative number * as recognized by PHP. * * The outcome of this function is reliable for `true`, `false` should be regarded as * "undetermined". * * Note: Zero is *not* regarded as a negative number. * * @since 8.2.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $start Start of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param int $end End of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param bool $allowFloats Whether to only consider integers, or also floats. * * @return bool True if PHP would evaluate the snippet as a negative number. * False if not or if it could not be reliably determined * (variable or calculations and such). */ public function isNegativeNumber(File $phpcsFile, $start, $end, $allowFloats = false) { $number = $this->isNumber($phpcsFile, $start, $end, $allowFloats); if ($number === false) { return false; } return ($number < 0); } /** * Determine whether the tokens between $start and $end together form a number * as recognized by PHP. * * The outcome of this function is reliable for "true-ish" values, `false` should * be regarded as "undetermined". * * @link https://3v4l.org/npTeM * * Mainly intended for examining variable assignments, function call parameters, array values * where the start and end of the snippet to examine is very clear. * * @since 8.2.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $start Start of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param int $end End of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param bool $allowFloats Whether to only consider integers, or also floats. * * @return int|float|bool The number found if PHP would evaluate the snippet as a number. * The return type will be int if $allowFloats is false, if * $allowFloats is true, the return type will be float. * False will be returned when the snippet does not evaluate to a * number or if it could not be reliably determined * (variable or calculations and such). */ protected function isNumber(File $phpcsFile, $start, $end, $allowFloats = false) { $stringTokens = Tokens::$heredocTokens + Tokens::$stringTokens; $validTokens = array(); $validTokens[\T_LNUMBER] = true; $validTokens[\T_TRUE] = true; // Evaluates to int 1. $validTokens[\T_FALSE] = true; // Evaluates to int 0. $validTokens[\T_NULL] = true; // Evaluates to int 0. if ($allowFloats === true) { $validTokens[\T_DNUMBER] = true; } $maybeValidTokens = $stringTokens + $validTokens; $tokens = $phpcsFile->getTokens(); $searchEnd = ($end + 1); $negativeNumber = false; if (isset($tokens[$start], $tokens[$searchEnd]) === false) { return false; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, $start, $searchEnd, true); while ($nextNonEmpty !== false && ($tokens[$nextNonEmpty]['code'] === \T_PLUS || $tokens[$nextNonEmpty]['code'] === \T_MINUS) ) { if ($tokens[$nextNonEmpty]['code'] === \T_MINUS) { $negativeNumber = ($negativeNumber === false) ? true : false; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $searchEnd, true); } if ($nextNonEmpty === false || isset($maybeValidTokens[$tokens[$nextNonEmpty]['code']]) === false) { return false; } $content = false; if ($tokens[$nextNonEmpty]['code'] === \T_LNUMBER || $tokens[$nextNonEmpty]['code'] === \T_DNUMBER ) { $content = (float) $tokens[$nextNonEmpty]['content']; } elseif ($tokens[$nextNonEmpty]['code'] === \T_TRUE) { $content = 1.0; } elseif ($tokens[$nextNonEmpty]['code'] === \T_FALSE || $tokens[$nextNonEmpty]['code'] === \T_NULL ) { $content = 0.0; } elseif (isset($stringTokens[$tokens[$nextNonEmpty]['code']]) === true) { if ($tokens[$nextNonEmpty]['code'] === \T_START_HEREDOC || $tokens[$nextNonEmpty]['code'] === \T_START_NOWDOC ) { // Skip past heredoc/nowdoc opener to the first content. $firstDocToken = $phpcsFile->findNext(array(\T_HEREDOC, \T_NOWDOC), ($nextNonEmpty + 1), $searchEnd); if ($firstDocToken === false) { // Live coding or parse error. return false; } $stringContent = $content = $tokens[$firstDocToken]['content']; // Skip forward to the end in preparation for the next part of the examination. $nextNonEmpty = $phpcsFile->findNext(array(\T_END_HEREDOC, \T_END_NOWDOC), ($nextNonEmpty + 1), $searchEnd); if ($nextNonEmpty === false) { // Live coding or parse error. return false; } } else { // Gather subsequent lines for a multi-line string. for ($i = $nextNonEmpty; $i < $searchEnd; $i++) { if ($tokens[$i]['code'] !== $tokens[$nextNonEmpty]['code']) { break; } $content .= $tokens[$i]['content']; } $nextNonEmpty = --$i; $content = $this->stripQuotes($content); $stringContent = $content; } /* * Regexes based on the formats outlined in the manual, created by JRF. * @link https://www.php.net/manual/en/language.types.float.php */ $regexInt = '`^\s*[0-9]+`'; $regexFloat = '`^\s*(?:[+-]?(?:(?:(?P[0-9]+)|(?P([0-9]*\.(?P>LNUM)|(?P>LNUM)\.[0-9]*)))[eE][+-]?(?P>LNUM))|(?P>DNUM))`'; $intString = preg_match($regexInt, $content, $intMatch); $floatString = preg_match($regexFloat, $content, $floatMatch); // Does the text string start with a number ? If so, PHP would juggle it and use it as a number. if ($allowFloats === false) { if ($intString !== 1 || $floatString === 1) { if ($floatString === 1) { // Found float. Only integers targetted. return false; } $content = 0.0; } else { $content = (float) trim($intMatch[0]); } } else { if ($intString !== 1 && $floatString !== 1) { $content = 0.0; } else { $content = ($floatString === 1) ? (float) trim($floatMatch[0]) : (float) trim($intMatch[0]); } } // Allow for different behaviour for hex numeric strings between PHP 5 vs PHP 7. if ($intString === 1 && trim($intMatch[0]) === '0' && preg_match('`^\s*(0x[A-Fa-f0-9]+)`', $stringContent, $hexNumberString) === 1 && $this->supportsBelow('5.6') === true ) { // The filter extension still allows for hex numeric strings in PHP 7, so // use that to get the numeric value if possible. // If the filter extension is not available, the value will be zero, but so be it. if (function_exists('filter_var')) { $filtered = filter_var($hexNumberString[1], \FILTER_VALIDATE_INT, \FILTER_FLAG_ALLOW_HEX); if ($filtered !== false) { $content = $filtered; } } } } // OK, so we have a number, now is there still more code after it ? $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextNonEmpty + 1), $searchEnd, true); if ($nextNonEmpty !== false) { return false; } if ($negativeNumber === true) { $content = -$content; } if ($allowFloats === false) { return (int) $content; } return $content; } /** * Determine whether the tokens between $start and $end together form a numberic calculation * as recognized by PHP. * * The outcome of this function is reliable for `true`, `false` should be regarded as "undetermined". * * Mainly intended for examining variable assignments, function call parameters, array values * where the start and end of the snippet to examine is very clear. * * @since 9.0.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $start Start of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * @param int $end End of the snippet (inclusive), i.e. this * token will be examined as part of the snippet. * * @return bool */ protected function isNumericCalculation(File $phpcsFile, $start, $end) { $arithmeticTokens = Tokens::$arithmeticTokens; // phpcs:disable PHPCompatibility.Constants.NewConstants.t_powFound if (\defined('T_POW') && isset($arithmeticTokens[\T_POW]) === false) { // T_POW was not added to the arithmetic array until PHPCS 2.9.0. $arithmeticTokens[\T_POW] = \T_POW; } // phpcs:enable $skipTokens = Tokens::$emptyTokens; $skipTokens[] = \T_MINUS; $skipTokens[] = \T_PLUS; // Find the first arithmetic operator, but skip past +/- signs before numbers. $nextNonEmpty = ($start - 1); do { $nextNonEmpty = $phpcsFile->findNext($skipTokens, ($nextNonEmpty + 1), ($end + 1), true); $arithmeticOperator = $phpcsFile->findNext($arithmeticTokens, ($nextNonEmpty + 1), ($end + 1)); } while ($nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator); if ($arithmeticOperator === false) { return false; } $tokens = $phpcsFile->getTokens(); $subsetStart = $start; $subsetEnd = ($arithmeticOperator - 1); while ($this->isNumber($phpcsFile, $subsetStart, $subsetEnd, true) !== false && isset($tokens[($arithmeticOperator + 1)]) === true ) { // Recognize T_POW for PHPCS < 2.4.0 on low PHP versions. if (\defined('T_POW') === false && $tokens[$arithmeticOperator]['code'] === \T_MULTIPLY && $tokens[($arithmeticOperator + 1)]['code'] === \T_MULTIPLY && isset($tokens[$arithmeticOperator + 2]) === true ) { // Move operator one forward to the second * in T_POW. ++$arithmeticOperator; } $subsetStart = ($arithmeticOperator + 1); $nextNonEmpty = $arithmeticOperator; do { $nextNonEmpty = $phpcsFile->findNext($skipTokens, ($nextNonEmpty + 1), ($end + 1), true); $arithmeticOperator = $phpcsFile->findNext($arithmeticTokens, ($nextNonEmpty + 1), ($end + 1)); } while ($nextNonEmpty !== false && $arithmeticOperator !== false && $nextNonEmpty === $arithmeticOperator); if ($arithmeticOperator === false) { // Last calculation operator already reached. if ($this->isNumber($phpcsFile, $subsetStart, $end, true) !== false) { return true; } return false; } $subsetEnd = ($arithmeticOperator - 1); } return false; } /** * Determine whether a ternary is a short ternary, i.e. without "middle". * * N.B.: This is a back-fill for a new method which is expected to go into * PHP_CodeSniffer 3.5.0. * Once that method has been merged into PHPCS, this one should be moved * to the PHPCSHelper.php file. * * @since 9.2.0 * * @codeCoverageIgnore Method as pulled upstream is accompanied by unit tests. * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the ternary operator * in the stack. * * @return bool True if short ternary, or false otherwise. */ public function isShortTernary(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]) === false || $tokens[$stackPtr]['code'] !== \T_INLINE_THEN ) { return false; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($nextNonEmpty === false) { // Live coding or parse error. return false; } if ($tokens[$nextNonEmpty]['code'] === \T_INLINE_ELSE) { return true; } return false; } /** * Determine whether a T_OPEN/CLOSE_SHORT_ARRAY token is a list() construct. * * Note: A variety of PHPCS versions have bugs in the tokenizing of short arrays. * In that case, the tokens are identified as T_OPEN/CLOSE_SQUARE_BRACKET. * * @since 8.2.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the function call token. * * @return bool */ public function isShortList(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check for the existence of the token. if (isset($tokens[$stackPtr]) === false) { return false; } // Is this one of the tokens this function handles ? if ($tokens[$stackPtr]['code'] !== \T_OPEN_SHORT_ARRAY && $tokens[$stackPtr]['code'] !== \T_CLOSE_SHORT_ARRAY ) { return false; } switch ($tokens[$stackPtr]['code']) { case \T_OPEN_SHORT_ARRAY: if (isset($tokens[$stackPtr]['bracket_closer']) === true) { $opener = $stackPtr; $closer = $tokens[$stackPtr]['bracket_closer']; } break; case \T_CLOSE_SHORT_ARRAY: if (isset($tokens[$stackPtr]['bracket_opener']) === true) { $opener = $tokens[$stackPtr]['bracket_opener']; $closer = $stackPtr; } break; } if (isset($opener, $closer) === false) { // Parse error, live coding or real square bracket. return false; } /* * PHPCS cross-version compatibility: work around for square brackets misidentified * as short array when preceded by a variable variable in older PHPCS versions. */ $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true, null, true); if ($prevNonEmpty !== false && $tokens[$prevNonEmpty]['code'] === \T_CLOSE_CURLY_BRACKET && isset($tokens[$prevNonEmpty]['bracket_opener']) === true ) { $maybeVariableVariable = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($tokens[$prevNonEmpty]['bracket_opener'] - 1), null, true, null, true ); if ($tokens[$maybeVariableVariable]['code'] === \T_VARIABLE || $tokens[$maybeVariableVariable]['code'] === \T_DOLLAR ) { return false; } } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($closer + 1), null, true, null, true); if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['code'] === \T_EQUAL) { return true; } if ($prevNonEmpty !== false && $tokens[$prevNonEmpty]['code'] === \T_AS && isset($tokens[$prevNonEmpty]['nested_parenthesis']) === true ) { $parentheses = array_reverse($tokens[$prevNonEmpty]['nested_parenthesis'], true); foreach ($parentheses as $open => $close) { if (isset($tokens[$open]['parenthesis_owner']) && $tokens[$tokens[$open]['parenthesis_owner']]['code'] === \T_FOREACH ) { return true; } } } // Maybe this is a short list syntax nested inside another short list syntax ? $parentOpener = $opener; do { $parentOpener = $phpcsFile->findPrevious( array(\T_OPEN_SHORT_ARRAY, \T_OPEN_SQUARE_BRACKET), ($parentOpener - 1), null, false, null, true ); if ($parentOpener === false) { return false; } } while (isset($tokens[$parentOpener]['bracket_closer']) === true && $tokens[$parentOpener]['bracket_closer'] < $opener ); if (isset($tokens[$parentOpener]['bracket_closer']) === true && $tokens[$parentOpener]['bracket_closer'] > $closer ) { // Work around tokenizer issue in PHPCS 2.0 - 2.7. $phpcsVersion = PHPCSHelper::getVersion(); if ((version_compare($phpcsVersion, '2.0', '>') === true && version_compare($phpcsVersion, '2.8', '<') === true) && $tokens[$parentOpener]['code'] === \T_OPEN_SQUARE_BRACKET ) { $nextNonEmpty = $phpcsFile->findNext( Tokens::$emptyTokens, ($tokens[$parentOpener]['bracket_closer'] + 1), null, true, null, true ); if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['code'] === \T_EQUAL) { return true; } return false; } return $this->isShortList($phpcsFile, $parentOpener); } return false; } /** * Determine whether the tokens between $start and $end could together represent a variable. * * @since 9.0.0 * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $start Starting point stack pointer. Inclusive. * I.e. this token should be taken into account. * @param int $end End point stack pointer. Exclusive. * I.e. this token should not be taken into account. * @param int $targetNestingLevel The nesting level the variable should be at. * * @return bool */ public function isVariable(File $phpcsFile, $start, $end, $targetNestingLevel) { static $tokenBlackList, $bracketTokens; // Create the token arrays only once. if (isset($tokenBlackList, $bracketTokens) === false) { $tokenBlackList = array( \T_OPEN_PARENTHESIS => \T_OPEN_PARENTHESIS, \T_STRING_CONCAT => \T_STRING_CONCAT, ); $tokenBlackList += Tokens::$assignmentTokens; $tokenBlackList += Tokens::$equalityTokens; $tokenBlackList += Tokens::$comparisonTokens; $tokenBlackList += Tokens::$operators; $tokenBlackList += Tokens::$booleanOperators; $tokenBlackList += Tokens::$castTokens; /* * List of brackets which can be part of a variable variable. * * Key is the open bracket token, value the close bracket token. */ $bracketTokens = array( \T_OPEN_CURLY_BRACKET => \T_CLOSE_CURLY_BRACKET, \T_OPEN_SQUARE_BRACKET => \T_CLOSE_SQUARE_BRACKET, ); } $tokens = $phpcsFile->getTokens(); // If no variable at all was found, then it's definitely a no-no. $hasVariable = $phpcsFile->findNext(\T_VARIABLE, $start, $end); if ($hasVariable === false) { return false; } // Check if the variable found is at the right level. Deeper levels are always an error. if (isset($tokens[$hasVariable]['nested_parenthesis']) && \count($tokens[$hasVariable]['nested_parenthesis']) !== $targetNestingLevel ) { return false; } // Ok, so the first variable is at the right level, now are there any // blacklisted tokens within the empty() ? $hasBadToken = $phpcsFile->findNext($tokenBlackList, $start, $end); if ($hasBadToken === false) { return true; } // If there are also bracket tokens, the blacklisted token might be part of a variable // variable, but if there are no bracket tokens, we know we have an error. $hasBrackets = $phpcsFile->findNext($bracketTokens, $start, $end); if ($hasBrackets === false) { return false; } // Ok, we have both a blacklisted token as well as brackets, so we need to walk // the tokens of the variable variable. for ($i = $start; $i < $end; $i++) { // If this is a bracket token, skip to the end of the bracketed expression. if (isset($bracketTokens[$tokens[$i]['code']], $tokens[$i]['bracket_closer'])) { $i = $tokens[$i]['bracket_closer']; continue; } // If it's a blacklisted token, not within brackets, we have an error. if (isset($tokenBlackList[$tokens[$i]['code']])) { return false; } } return true; } /** * Determine whether a T_MINUS/T_PLUS token is a unary operator. * * N.B.: This is a back-fill for a new method which is expected to go into * PHP_CodeSniffer 3.5.0. * Once that method has been merged into PHPCS, this one should be moved * to the PHPCSHelper.php file. * * @since 9.2.0 * * @codeCoverageIgnore Method as pulled upstream is accompanied by unit tests. * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr The position of the plus/minus token. * * @return bool True if the token passed is a unary operator. * False otherwise or if the token is not a T_PLUS/T_MINUS token. */ public static function isUnaryPlusMinus(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]) === false || ($tokens[$stackPtr]['code'] !== \T_PLUS && $tokens[$stackPtr]['code'] !== \T_MINUS) ) { return false; } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next === false) { // Live coding or parse error. return false; } if (isset(Tokens::$operators[$tokens[$next]['code']]) === true) { // Next token is an operator, so this is not a unary. return false; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === \T_RETURN) { // Just returning a positive/negative value; eg. (return -1). return true; } if (isset(Tokens::$operators[$tokens[$prev]['code']]) === true) { // Just trying to operate on a positive/negative value; eg. ($var * -1). return true; } if (isset(Tokens::$comparisonTokens[$tokens[$prev]['code']]) === true) { // Just trying to compare a positive/negative value; eg. ($var === -1). return true; } if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === true) { // Just trying to compare a positive/negative value; eg. ($var || -1 === $b). return true; } if (isset(Tokens::$assignmentTokens[$tokens[$prev]['code']]) === true) { // Just trying to assign a positive/negative value; eg. ($var = -1). return true; } if (isset(Tokens::$castTokens[$tokens[$prev]['code']]) === true) { // Just casting a positive/negative value; eg. (string) -$var. return true; } // Other indicators that a plus/minus sign is a unary operator. $invalidTokens = array( \T_COMMA => true, \T_OPEN_PARENTHESIS => true, \T_OPEN_SQUARE_BRACKET => true, \T_OPEN_SHORT_ARRAY => true, \T_COLON => true, \T_INLINE_THEN => true, \T_INLINE_ELSE => true, \T_CASE => true, \T_OPEN_CURLY_BRACKET => true, \T_STRING_CONCAT => true, ); if (isset($invalidTokens[$tokens[$prev]['code']]) === true) { // Just trying to use a positive/negative value; eg. myFunction($var, -2). return true; } return false; } /** * Get the complete contents of a multi-line text string. * * N.B.: This is a back-fill for a new method which is expected to go into * PHP_CodeSniffer 3.5.0. * Once that method has been merged into PHPCS, this one should be moved * to the PHPCSHelper.php file. * * @since 9.3.0 * * @codeCoverageIgnore Method as pulled upstream is accompanied by unit tests. * * @param \PHP_CodeSniffer_File $phpcsFile The file being scanned. * @param int $stackPtr Pointer to the first text string token * of a multi-line text string or to a * Nowdoc/Heredoc opener. * @param bool $stripQuotes Optional. Whether to strip text delimiter * quotes off the resulting text string. * Defaults to true. * * @return string * * @throws \PHP_CodeSniffer_Exception If the specified position is not a * valid text string token or if the * token is not the first text string token. */ public function getCompleteTextString(File $phpcsFile, $stackPtr, $stripQuotes = true) { $tokens = $phpcsFile->getTokens(); // Must be the start of a text string token. if ($tokens[$stackPtr]['code'] !== \T_START_HEREDOC && $tokens[$stackPtr]['code'] !== \T_START_NOWDOC && $tokens[$stackPtr]['code'] !== \T_CONSTANT_ENCAPSED_STRING && $tokens[$stackPtr]['code'] !== \T_DOUBLE_QUOTED_STRING ) { throw new PHPCS_Exception('$stackPtr must be of type T_START_HEREDOC, T_START_NOWDOC, T_CONSTANT_ENCAPSED_STRING or T_DOUBLE_QUOTED_STRING'); } if ($tokens[$stackPtr]['code'] === \T_CONSTANT_ENCAPSED_STRING || $tokens[$stackPtr]['code'] === \T_DOUBLE_QUOTED_STRING ) { $prev = $phpcsFile->findPrevious(\T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$stackPtr]['code'] === $tokens[$prev]['code']) { throw new PHPCS_Exception('$stackPtr must be the start of the text string'); } } switch ($tokens[$stackPtr]['code']) { case \T_START_HEREDOC: $stripQuotes = false; $targetType = \T_HEREDOC; $current = ($stackPtr + 1); break; case \T_START_NOWDOC: $stripQuotes = false; $targetType = \T_NOWDOC; $current = ($stackPtr + 1); break; default: $targetType = $tokens[$stackPtr]['code']; $current = $stackPtr; break; } $string = ''; do { $string .= $tokens[$current]['content']; ++$current; } while ($tokens[$current]['code'] === $targetType); if ($stripQuotes === true) { return $this->stripQuotes($string); } return $string; } }