/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
for ($index = $tokens->count() - 1; $index >= 0; --$index) {
$token = $tokens[$index];
if (!$token->isGivenKind(T_FUNCTION)) {
continue;
}
$startParenthesisIndex = $tokens->getNextTokenOfKind($index, array('('));
$endParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startParenthesisIndex);
for ($iter = $endParenthesisIndex - 1; $iter > $startParenthesisIndex; --$iter) {
if (!$tokens[$iter]->isGivenKind(T_VARIABLE)) {
continue;
}
// skip ... before $variable for variadic parameter
if (defined('T_ELLIPSIS')) {
$prevNonWhitespaceIndex = $tokens->getPrevNonWhitespace($iter);
if ($tokens[$prevNonWhitespaceIndex]->isGivenKind(T_ELLIPSIS)) {
$iter = $prevNonWhitespaceIndex;
}
}
// skip & before $variable for parameter passed by reference
$prevNonWhitespaceIndex = $tokens->getPrevNonWhitespace($iter);
if ($tokens[$prevNonWhitespaceIndex]->equals('&')) {
$iter = $prevNonWhitespaceIndex;
}
if (!$tokens[$iter - 1]->equalsAny(array(array(T_WHITESPACE), array(T_COMMENT), array(T_DOC_COMMENT), '(', ','))) {
$tokens->insertAt($iter, new Token(array(T_WHITESPACE, ' ')));
}
}
}
}
/**
* @param Tokens|Token[] $tokens
*
* @return void
*/
protected function fixContent(Tokens $tokens)
{
$wrongTokens = [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW];
foreach ($tokens as $index => $token) {
$tokenContent = strtolower($token->getContent());
if (strtolower($tokenContent) !== 'php_sapi_name') {
continue;
}
$openingBrace = $tokens->getNextMeaningfulToken($index);
if ($openingBrace === null || $tokens[$openingBrace]->getContent() !== '(') {
continue;
}
$closingBrace = $tokens->getNextMeaningfulToken($openingBrace);
if ($closingBrace === null || $tokens[$closingBrace]->getContent() !== ')') {
continue;
}
$prevIndex = $tokens->getPrevNonWhitespace($index);
if ($prevIndex === null || in_array($tokens[$prevIndex]->getId(), $wrongTokens, true)) {
continue;
}
$tokens[$index]->setContent('PHP_SAPI');
for ($i = $openingBrace; $i <= $closingBrace; ++$i) {
$tokens[$i]->clear();
}
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
for ($index = $tokens->count() - 1; $index >= 0; --$index) {
$token = $tokens[$index];
if (!$token->isGivenKind(T_NEW)) {
continue;
}
$nextIndex = $tokens->getNextTokenOfKind($index, array(':', ';', ',', '(', ')', '[', ']', array(CT_ARRAY_SQUARE_BRACE_OPEN), array(CT_ARRAY_SQUARE_BRACE_CLOSE), array(CT_BRACE_CLASS_INSTANTIATION_OPEN), array(CT_BRACE_CLASS_INSTANTIATION_CLOSE)));
$nextToken = $tokens[$nextIndex];
// entrance into array index syntax - need to look for exit
while ($nextToken->equals('[')) {
$nextIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_INDEX_SQUARE_BRACE, $nextIndex) + 1;
$nextToken = $tokens[$nextIndex];
}
// new statement has a gap in it - advance to the next token
if ($nextToken->isGivenKind(T_WHITESPACE)) {
$nextIndex = $tokens->getNextNonWhitespace($nextIndex);
$nextToken = $tokens[$nextIndex];
}
// new statement with () - nothing to do
if ($nextToken->equals('(')) {
continue;
}
$meaningBeforeNextIndex = $tokens->getPrevNonWhitespace($nextIndex);
$tokens->insertAt($meaningBeforeNextIndex + 1, array(new Token('('), new Token(')')));
}
}
/**
* @param Tokens|Token[] $tokens
*
* @return void
*/
protected function fixContent(Tokens $tokens)
{
$wrongTokens = [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW];
foreach ($tokens as $index => $token) {
$tokenContent = strtolower($token->getContent());
if (empty($tokenContent) || !isset(self::$matching[$tokenContent])) {
continue;
}
$prevIndex = $tokens->getPrevNonWhitespace($index);
if (in_array($tokens[$prevIndex]->getId(), $wrongTokens, true)) {
continue;
}
$openingBrace = $tokens->getNextMeaningfulToken($index);
if ($tokens[$openingBrace]->getContent() !== '(') {
continue;
}
$closingBrace = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $openingBrace);
// Skip for non-trivial cases
for ($i = $openingBrace + 1; $i < $closingBrace; ++$i) {
if ($tokens[$i]->equals(',')) {
continue 2;
}
}
$cast = '(' . self::$matching[$tokenContent] . ')';
$tokens[$index]->setContent($cast);
$tokens[$openingBrace]->setContent('');
$tokens[$closingBrace]->setContent('');
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
$functionyTokens = $this->getFunctionyTokenKinds();
$languageConstructionTokens = $this->getLanguageConstructionTokenKinds();
foreach ($tokens as $index => $token) {
// looking for start brace
if (!$token->equals('(')) {
continue;
}
// last non-whitespace token
$lastTokenIndex = $tokens->getPrevNonWhitespace($index);
if (null === $lastTokenIndex) {
continue;
}
// check for ternary operator
$endParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
$nextNonWhiteSpace = $tokens->getNextMeaningfulToken($endParenthesisIndex);
if (!empty($nextNonWhiteSpace) && $tokens[$nextNonWhiteSpace]->equals('?') && $tokens[$lastTokenIndex]->isGivenKind($languageConstructionTokens)) {
continue;
}
// check if it is a function call
if ($tokens[$lastTokenIndex]->isGivenKind($functionyTokens)) {
$this->fixFunctionCall($tokens, $index);
}
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
foreach ($tokens as $index => $token) {
if (!$token->isGivenKind(array(T_CASE, T_DEFAULT))) {
continue;
}
$ternariesCount = 0;
for ($colonIndex = $index + 1;; ++$colonIndex) {
// We have to skip ternary case for colons.
if ($tokens[$colonIndex]->equals('?')) {
++$ternariesCount;
}
if ($tokens[$colonIndex]->equals(':')) {
if (0 === $ternariesCount) {
break;
}
--$ternariesCount;
}
}
$valueIndex = $tokens->getPrevNonWhitespace($colonIndex);
if (2 + $valueIndex === $colonIndex) {
$tokens[$valueIndex + 1]->clear();
}
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
for ($index = 0, $limit = $tokens->count(); $index < $limit; ++$index) {
$token = $tokens[$index];
if (!$token->isGivenKind(T_RETURN)) {
continue;
}
$prevNonWhitespaceToken = $tokens[$tokens->getPrevNonWhitespace($index)];
if (!$prevNonWhitespaceToken->equalsAny(array(';', '}'))) {
continue;
}
$prevToken = $tokens[$index - 1];
if ($prevToken->isWhitespace()) {
$parts = explode("\n", $prevToken->getContent());
$countParts = count($parts);
if (1 === $countParts) {
$prevToken->setContent(rtrim($prevToken->getContent(), " \t") . "\n\n");
} elseif (count($parts) <= 2) {
$prevToken->setContent("\n" . $prevToken->getContent());
}
} else {
$tokens->insertAt($index, new Token(array(T_WHITESPACE, "\n\n")));
++$index;
++$limit;
}
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
for ($index = $tokens->count() - 1; $index >= 0; --$index) {
$token = $tokens[$index];
if (!$token->isGivenKind(T_LIST)) {
continue;
}
$openIndex = $tokens->getNextMeaningfulToken($index);
$closeIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $openIndex);
$markIndex = null;
$prevIndex = $tokens->getPrevNonWhitespace($closeIndex);
while ($tokens[$prevIndex]->equals(',')) {
$markIndex = $prevIndex;
$prevIndex = $tokens->getPrevNonWhitespace($prevIndex);
}
if (null !== $markIndex) {
$tokens->clearRange($tokens->getPrevNonWhitespace($markIndex) + 1, $closeIndex - 1);
}
}
}
public function fixSpace(Tokens $tokens, $index)
{
if ($tokens[$index - 1]->isWhitespace()) {
$prevIndex = $tokens->getPrevNonWhitespace($index - 1);
if (!$tokens[$prevIndex]->equalsAny(array(',', array(T_END_HEREDOC)))) {
$tokens[$index - 1]->clear();
}
}
if (!$tokens[$index + 1]->isWhitespace()) {
$tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, ' ')));
}
}
/**
* Method to insert space after comma and remove space before comma.
*
* @param Tokens $tokens
* @param int $index
*/
public function fixSpace(Tokens $tokens, $index)
{
// remove space before comma if exist
if ($tokens[$index - 1]->isWhitespace()) {
$prevIndex = $tokens->getPrevNonWhitespace($index - 1);
if (!$tokens[$prevIndex]->equalsAny(array(',', array(T_END_HEREDOC)))) {
$tokens[$index - 1]->clear();
}
}
// add space after comma if not exist
if (!$tokens[$index + 1]->isWhitespace()) {
$tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, ' ')));
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
foreach ($tokens as $index => $token) {
if (!$token->equals('.')) {
continue;
}
if (!$tokens[$tokens->getPrevNonWhitespace($index)]->isGivenKind(T_LNUMBER)) {
$tokens->removeLeadingWhitespace($index, " \t");
}
if (!$tokens[$tokens->getNextNonWhitespace($index)]->isGivenKind(T_LNUMBER)) {
$tokens->removeTrailingWhitespace($index, " \t");
}
}
}
private function fixFunction(Tokens $tokens, $functionIndex, array $functionParams)
{
$startBraceIndex = $tokens->getNextTokenOfKind($functionIndex, array('('));
$endBraceIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startBraceIndex);
$commaCounter = 0;
$sawParameter = false;
for ($index = $startBraceIndex + 1; $index < $endBraceIndex; ++$index) {
$token = $tokens[$index];
if (!$token->isWhitespace() && !$token->isComment()) {
$sawParameter = true;
}
if ($token->equals('(')) {
$index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
continue;
}
if ($token->equals('[')) {
$index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_SQUARE_BRACE, $index);
continue;
}
if ($token->equals(',')) {
++$commaCounter;
continue;
}
}
$functionParamsQuantity = count($functionParams);
$paramsQuantity = ($sawParameter ? 1 : 0) + $commaCounter;
if ($paramsQuantity === $functionParamsQuantity) {
return;
}
$tokensToInsert = array();
for ($i = $paramsQuantity; $i < $functionParamsQuantity; ++$i) {
// function call do not have all params that are required to set useStrict flag, exit from method!
if (!$functionParams[$i]) {
return;
}
$tokensToInsert[] = new Token(',');
$tokensToInsert[] = new Token(array(T_WHITESPACE, ' '));
if (!is_array($functionParams[$i])) {
$tokensToInsert[] = clone $functionParams[$i];
continue;
}
foreach ($functionParams[$i] as $param) {
$tokensToInsert[] = clone $param;
}
}
$beforeEndBraceIndex = $tokens->getPrevNonWhitespace($endBraceIndex, array());
$tokens->insertAt($beforeEndBraceIndex + 1, $tokensToInsert);
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
if (!$tokens->isMonolithicPhp()) {
return;
}
$closeTags = $tokens->findGivenKind(T_CLOSE_TAG);
if (empty($closeTags)) {
return;
}
list($index, $token) = each($closeTags);
$tokens->removeLeadingWhitespace($index);
$token->clear();
$prevIndex = $tokens->getPrevNonWhitespace($index);
$prevToken = $tokens[$prevIndex];
if (!$prevToken->equalsAny(array(';', '}'))) {
$tokens->insertAt($prevIndex + 1, new Token(';'));
}
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
$functionyTokens = $this->getFunctionyTokens();
foreach ($tokens as $index => $token) {
// looking for start brace
if (!$token->equals('(')) {
continue;
}
// last non-whitespace token
$lastTokenIndex = $tokens->getPrevNonWhitespace($index);
if (null === $lastTokenIndex) {
continue;
}
// check if it is a function call
if ($tokens[$lastTokenIndex]->isGivenKind($functionyTokens)) {
$this->fixFunctionCall($tokens, $index);
}
}
}
/**
* Method to trim leading/trailing whitespace within single line arrays.
*
* @param Tokens $tokens
* @param int $index
*/
private static function fixArray(Tokens $tokens, $index)
{
$startIndex = $index;
if ($tokens[$startIndex]->isGivenKind(T_ARRAY)) {
$startIndex = $tokens->getNextMeaningfulToken($startIndex);
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startIndex);
} else {
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $startIndex);
}
$nextToken = $tokens[$startIndex + 1];
if ($nextToken->isWhitespace(" \t")) {
$nextToken->clear();
}
$prevToken = $tokens[$endIndex - 1];
$prevNonWhitespaceToken = $tokens[$tokens->getPrevNonWhitespace($endIndex)];
if ($prevToken->isWhitespace(" \t") && !$prevNonWhitespaceToken->equals(',')) {
$prevToken->clear();
}
}
/**
* @param Tokens|Token[] $tokens
*
* @return void
*/
protected function fixContent(Tokens $tokens)
{
$wrongTokens = [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW];
foreach ($tokens as $index => $token) {
$tokenContent = strtolower($token->getContent());
if (empty($tokenContent) || !isset(self::$matching[$tokenContent])) {
continue;
}
$prevIndex = $tokens->getPrevNonWhitespace($index);
if (in_array($tokens[$prevIndex]->getId(), $wrongTokens, true)) {
continue;
}
$next = $tokens->getNextMeaningfulToken($index);
if ($tokens[$next]->getContent() !== '(') {
continue;
}
$tokens[$index]->setContent(self::$matching[$tokenContent]);
}
}
/**
* Method to trim leading/trailing whitespace within single line arrays.
*
* @param Tokens $tokens
* @param int $index
*/
private static function fixArray(Tokens $tokens, $index)
{
static $whitespaceOptions = array('whitespaces' => " \t");
$startIndex = $index;
if ($tokens[$startIndex]->isGivenKind(T_ARRAY)) {
$startIndex = $tokens->getNextMeaningfulToken($startIndex);
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startIndex);
} else {
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_SQUARE_BRACE, $startIndex);
}
$nextToken = $tokens[$startIndex + 1];
if ($nextToken->isWhitespace($whitespaceOptions)) {
$nextToken->clear();
}
$prevToken = $tokens[$endIndex - 1];
$prevNonWhitespaceToken = $tokens[$tokens->getPrevNonWhitespace($endIndex)];
if ($prevToken->isWhitespace($whitespaceOptions) && !$prevNonWhitespaceToken->equals(',') && !($prevNonWhitespaceToken->isComment() && $prevNonWhitespaceToken->getContent() !== rtrim($prevNonWhitespaceToken->getContent()))) {
$prevToken->clear();
}
}
private function findIncludies(Tokens $tokens)
{
static $includyTokenKinds = array(T_REQUIRE, T_REQUIRE_ONCE, T_INCLUDE, T_INCLUDE_ONCE);
$includies = array();
foreach ($tokens->findGivenKind($includyTokenKinds) as $includyTokens) {
foreach ($includyTokens as $index => $token) {
$includy = array('begin' => $index, 'braces' => null, 'end' => $tokens->getNextTokenOfKind($index, array(';')));
// Don't remove when the statement is wrapped. include is also legal as function parameter
// but requires being wrapped then
if (!$tokens[$tokens->getPrevNonWhitespace($index)]->equals('(')) {
$nextTokenIndex = $tokens->getNextNonWhitespace($index);
$nextToken = $tokens[$nextTokenIndex];
if ($nextToken->equals('(')) {
$includy['braces'] = array('open' => $nextTokenIndex, 'close' => $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $nextTokenIndex));
}
}
$includies[] = $includy;
}
}
return $includies;
}
/**
* {@inheritdoc}
*/
public function fix(\SplFileInfo $file, Tokens $tokens)
{
$limit = $tokens->count();
for ($index = 0; $index < $limit; ++$index) {
$token = $tokens[$index];
// skip T_FOR parenthesis to ignore duplicated `;` like `for ($i = 1; ; ++$i) {...}`
if ($token->isGivenKind(T_FOR)) {
$index = $tokens->getNextMeaningfulToken($index);
$index = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $index);
continue;
}
if (!$token->equals(';')) {
continue;
}
$prevIndex = $tokens->getPrevNonWhitespace($index);
if (!$tokens[$prevIndex]->equals(';')) {
continue;
}
$tokens->removeLeadingWhitespace($index);
$token->clear();
}
}
/**
* Method to trim leading/trailing whitespace within single line arrays.
*
* @param Tokens $tokens
* @param int $index
*/
private static function fixArray(Tokens $tokens, $index)
{
$startIndex = $index;
if ($tokens[$startIndex]->isGivenKind(T_ARRAY)) {
$startIndex = $tokens->getNextMeaningfulToken($startIndex);
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $startIndex);
} else {
$endIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_ARRAY_SQUARE_BRACE, $startIndex);
}
$nextToken = $tokens[$startIndex + 1];
$nextNonWhitespaceIndex = $tokens->getNextNonWhitespace($startIndex);
$nextNonWhitespaceToken = $tokens[$nextNonWhitespaceIndex];
$tokenAfterNextNonWhitespaceToken = $tokens[$nextNonWhitespaceIndex + 1];
$prevToken = $tokens[$endIndex - 1];
$prevNonWhitespaceIndex = $tokens->getPrevNonWhitespace($endIndex);
$prevNonWhitespaceToken = $tokens[$prevNonWhitespaceIndex];
if ($nextToken->isWhitespace(" \t") && (!$nextNonWhitespaceToken->isComment() || $nextNonWhitespaceIndex === $prevNonWhitespaceIndex || $tokenAfterNextNonWhitespaceToken->isWhitespace(" \t") || '/*' === substr($nextNonWhitespaceToken->getContent(), 0, 2))) {
$nextToken->clear();
}
if ($prevToken->isWhitespace(" \t") && !$prevNonWhitespaceToken->equals(',')) {
$prevToken->clear();
}
}
private function fixWhiteSpaceAroundOperator(Tokens $tokens, $index)
{
// do not change the alignment of `=>` or `=`, see `(un)align_double_arrow`, `(un)align_equals`
$preserveAlignment = $tokens[$index]->isGivenKind(T_DOUBLE_ARROW) || $tokens[$index]->equals('=');
// fix white space after operator
if ($tokens[$index + 1]->isWhitespace()) {
$content = $tokens[$index + 1]->getContent();
if (!$preserveAlignment && ' ' !== $content && false === strpos($content, "\n") && !$tokens[$tokens->getNextNonWhitespace($index + 1)]->isComment()) {
$tokens[$index + 1]->setContent(' ');
}
} else {
$tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, ' ')));
}
// fix white space before operator
if ($tokens[$index - 1]->isWhitespace()) {
$content = $tokens[$index - 1]->getContent();
if (!$preserveAlignment && ' ' !== $content && false === strpos($content, "\n") && !$tokens[$tokens->getPrevNonWhitespace($index - 1)]->isComment()) {
$tokens[$index - 1]->setContent(' ');
}
} else {
$tokens->insertAt($index, new Token(array(T_WHITESPACE, ' ')));
}
}
/**
* Method to insert space after comma and remove space before comma.
*
* @param Tokens $tokens
* @param int $index
*/
public function fixSpace(Tokens $tokens, $index)
{
// remove space before comma if exist
if ($tokens[$index - 1]->isWhitespace()) {
$prevIndex = $tokens->getPrevNonWhitespace($index - 1);
if (!$tokens[$prevIndex]->equalsAny(array(',', array(T_END_HEREDOC)))) {
$tokens[$index - 1]->clear();
}
}
$nextToken = $tokens[$index + 1];
// Two cases for fix space after comma (exclude multiline comments)
// 1) multiple spaces after comma
// 2) no space after comma
if ($nextToken->isWhitespace()) {
if ($this->isCommentLastLineToken($tokens, $index + 2)) {
return;
}
$newContent = ltrim($nextToken->getContent(), " \t");
if ('' === $newContent) {
$newContent = ' ';
}
$nextToken->setContent($newContent);
return;
}
if (!$this->isCommentLastLineToken($tokens, $index + 1)) {
$tokens->insertAt($index + 1, new Token(array(T_WHITESPACE, ' ')));
}
}
private function detectIndent(Tokens $tokens, $index)
{
static $goBackTokens = array(T_ABSTRACT, T_FINAL, T_PUBLIC, T_PROTECTED, T_PRIVATE, T_STATIC);
$token = $tokens[$index];
if ($token->isGivenKind($goBackTokens) || $token->isClassy() || $token->isGivenKind(T_FUNCTION)) {
$prevIndex = $tokens->getPrevNonWhitespace($index);
$prevToken = $tokens[$prevIndex];
if ($prevToken->isGivenKind($goBackTokens)) {
return $this->detectIndent($tokens, $prevIndex);
}
}
$prevIndex = $index - 1;
$prevToken = $tokens[$prevIndex];
if ($prevToken->equals('}')) {
return $this->detectIndent($tokens, $prevIndex);
}
// if can not detect indent:
if (!$prevToken->isWhitespace()) {
return '';
}
$explodedContent = explode("\n", $prevToken->getContent());
// proper decect indent for code: ` } else {`
if (1 === count($explodedContent)) {
if ($tokens[$index - 2]->equals('}')) {
return $this->detectIndent($tokens, $index - 2);
}
}
return end($explodedContent);
}
/**
* @param Tokens|Token[] $tokens
*
* @return void
*/
protected function fixContent(Tokens $tokens)
{
$wrongTokens = [T_FUNCTION, T_OBJECT_OPERATOR, T_NEW];
foreach ($tokens as $index => $token) {
$tokenContent = strtolower($token->getContent());
if ($tokenContent !== self::STRING_MATCH) {
continue;
}
$prevIndex = $tokens->getPrevNonWhitespace($index);
if (in_array($tokens[$prevIndex]->getId(), $wrongTokens, true)) {
continue;
}
$nextIndex = $tokens->getNextMeaningfulToken($index);
if ($tokens[$nextIndex]->getContent() !== '(') {
continue;
}
$lastIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $nextIndex);
$needsBrackets = false;
if ($tokens[$prevIndex]->isCast() || $tokens[$prevIndex]->isGivenKind([T_IS_NOT_EQUAL, T_IS_EQUAL, T_IS_IDENTICAL, T_IS_NOT_IDENTICAL])) {
$needsBrackets = true;
}
$endBraceIndex = $tokens->getNextTokenOfKind($nextIndex, [')']);
$nextEndBraceIndex = $tokens->getNextMeaningfulToken($endBraceIndex);
if ($tokens[$nextEndBraceIndex]->isGivenKind([T_IS_NOT_EQUAL, T_IS_EQUAL, T_IS_IDENTICAL, T_IS_NOT_IDENTICAL])) {
$needsBrackets = true;
}
// Special fix: true/false === is_null() => !==/=== null
if ($this->isFixableComparison($tokens, $prevIndex, $nextEndBraceIndex)) {
$needsBrackets = false;
}
$negated = false;
if ($tokens[$prevIndex]->getContent() === '!') {
$negated = true;
}
$replacement = '';
for ($i = $nextIndex + 1; $i < $lastIndex; ++$i) {
// We should only change trivial cases to avoid changing code behavior
if (!$tokens[$i]->isGivenKind([T_VARIABLE, T_OBJECT_OPERATOR, T_STRING, T_CONST, T_DOUBLE_COLON, T_CONSTANT_ENCAPSED_STRING, T_LNUMBER])) {
continue 2;
}
$replacement .= $tokens[$i]->getContent();
}
if ($this->startIndex !== null) {
$index = $this->startIndex;
$this->endIndex = $lastIndex;
$negated = $tokens[$this->startIndex]->getContent() === 'false' ? true : false;
$needsBrackets = false;
}
if ($this->endIndex !== null) {
$lastIndex = $this->endIndex;
if ($this->startIndex !== null) {
$token = $tokens[$this->startIndex];
} else {
$token = $tokens[$this->endIndex];
}
$negated = $token->getContent() === 'false' ? true : false;
$needsBrackets = false;
}
$replacement .= ' ' . ($negated ? '!' : '=') . '== null';
if ($needsBrackets) {
$replacement = '(' . $replacement . ')';
}
$offset = 0;
if ($negated && $this->startIndex === null && $this->endIndex === null) {
$offset = -($index - $prevIndex);
}
$index += $offset;
for ($i = $index; $i < $lastIndex; ++$i) {
$tokens[$i]->clear();
}
$tokens[$lastIndex]->setContent($replacement);
}
}
/**
* Method to remove incorrect default values.
*
* @param Tokens $tokens
* @param int $index
* @param int $endIndex
*
* @return void
*/
protected function fixDefaultValues(Tokens $tokens, $index, $endIndex)
{
$hasDefaultValue = false;
for ($i = $endIndex; $i > $index; $i--) {
if ($tokens[$i]->equals('=')) {
$hasDefaultValue = true;
break;
}
}
if (!$hasDefaultValue) {
$this->defaultValueForbidden = true;
return;
}
if ($hasDefaultValue && !$this->defaultValueForbidden) {
return;
}
$positionOfEqualSign = $i;
// Remove wrong default value
for ($i = $positionOfEqualSign; $i <= $endIndex; $i++) {
if ($tokens[$i]->equals(',')) {
break;
}
$tokens[$i]->clear();
}
// Also remove whitespace then before the equal sign
$prevIndex = $tokens->getPrevNonWhitespace($positionOfEqualSign);
for ($i = $positionOfEqualSign - 1; $i > $prevIndex; $i--) {
$tokens[$i]->clear();
}
}
/**
* Returns an array with `implements` data.
*
* Returns array:
* * int 'breakAt' index of the Token of type T_IMPLEMENTS for the definition, or 0
* * int 'numberOfInterfaces'
* * bool 'multiLine'
*
* @param Tokens $tokens
* @param int $start
* @param int $classyOpen
*
* @return array
*/
private function getMultiLineInfo(Tokens $tokens, $start, $classyOpen)
{
$implementsInfo = array('breakAt' => 0, 'numberOfInterfaces' => 0, 'multiLine' => false);
$breakAtToken = $tokens->findGivenKind($tokens[$start]->isGivenKind(T_INTERFACE) ? T_EXTENDS : T_IMPLEMENTS, $start, $classyOpen);
if (count($breakAtToken) < 1) {
return $implementsInfo;
}
$implementsInfo['breakAt'] = key($breakAtToken);
$classyOpen = $tokens->getPrevNonWhitespace($classyOpen);
for ($j = $implementsInfo['breakAt'] + 1; $j < $classyOpen; ++$j) {
if ($tokens[$j]->isGivenKind(T_STRING)) {
++$implementsInfo['numberOfInterfaces'];
continue;
}
if (!$implementsInfo['multiLine'] && ($tokens[$j]->isWhitespace() || $tokens[$j]->isComment()) && false !== strpos($tokens[$j]->getContent(), "\n")) {
$implementsInfo['multiLine'] = true;
}
}
return $implementsInfo;
}