PHP XHPASTNode::selectTokensOfType方法代码示例

 public function process(XHPASTNode $root)
 {
     $logical_ands = $root->selectTokensOfType('T_LOGICAL_AND');
     $logical_ors = $root->selectTokensOfType('T_LOGICAL_OR');
     foreach ($logical_ands as $logical_and) {
         $this->raiseLintAtToken($logical_and, pht('Use `%s` instead of `%s`.', '&&', 'and'), '&&');
     }
     foreach ($logical_ors as $logical_or) {
         $this->raiseLintAtToken($logical_or, pht('Use `%s` instead of `%s`.', '||', 'or'), '||');
     }
 }

 public function process(XHPASTNode $root)
 {
     $tokens = $root->selectTokensOfType('T_ELSEIF');
     foreach ($tokens as $token) {
         $this->raiseLintAtToken($token, pht('Usage of `%s` is preferred over `%s`.', 'else if', 'elseif'), 'else if');
     }
 }

 public function process(XHPASTNode $root)
 {
     $inline_html = $root->selectDescendantsOfType('n_INLINE_HTML');
     if ($inline_html) {
         return;
     }
     foreach ($root->selectTokensOfType('T_CLOSE_TAG') as $token) {
         $this->raiseLintAtToken($token, pht('Do not use the PHP closing tag, "%s".', '?>'));
     }
 }

 public function process(XHPASTNode $root)
 {
     foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
         $value = $comment->getValue();
         if ($value[0] !== '#') {
             continue;
         }
         $this->raiseLintAtOffset($comment->getOffset(), pht('Use `%s` single-line comments, not `%s`.', '//', '#'), '#', preg_match('/^#\\S/', $value) ? '// ' : '//');
     }
 }

 public function process(XHPASTNode $root)
 {
     $tokens = $root->selectTokensOfType(';');
     foreach ($tokens as $token) {
         $prev = $token->getPrevToken();
         if ($prev->isAnyWhitespace()) {
             $this->raiseLintAtToken($prev, pht('Space found before semicolon.'), '');
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
         $value = $comment->getValue();
         if ($value[0] !== '#') {
             $match = null;
             if (preg_match('@^(/[/*]+)[^/*\\s]@', $value, $match)) {
                 $this->raiseLintAtOffset($comment->getOffset(), pht('Put space after comment start.'), $match[1], $match[1] . ' ');
             }
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     $inline_html = $root->selectTokensOfType('T_INLINE_HTML');
     foreach ($inline_html as $html) {
         if (substr($html->getValue(), 0, 2) == '#!') {
             // Ignore shebang lines.
             continue;
         }
         if (preg_match('/^\\s*$/', $html->getValue())) {
             continue;
         }
         $this->raiseLintAtToken($html, pht('PHP files must only contain PHP code.'));
         break;
     }
 }

 public function process(XHPASTNode $root)
 {
     $double_colons = $root->selectTokensOfType('T_PAAMAYIM_NEKUDOTAYIM');
     foreach ($double_colons as $double_colon) {
         $tokens = $double_colon->getNonsemanticTokensBefore() + $double_colon->getNonsemanticTokensAfter();
         foreach ($tokens as $token) {
             if ($token->isAnyWhitespace()) {
                 if (strpos($token->getValue(), "\n") !== false) {
                     continue;
                 }
                 $this->raiseLintAtToken($token, pht('Unnecessary whitespace around paamayim nekudotayim ' . '(double colon) operator.'), '');
             }
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     $class_declarations = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
     foreach ($class_declarations as $class_declaration) {
         $class_name = $class_declaration->getChildOfType(1, 'n_CLASS_NAME')->getConcreteString();
         $class_static_accesses = $class_declaration->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
         $closures = $this->getAnonymousClosures($class_declaration);
         foreach ($class_static_accesses as $class_static_access) {
             $double_colons = $class_static_access->selectTokensOfType('T_PAAMAYIM_NEKUDOTAYIM');
             $class_ref = $class_static_access->getChildByIndex(0);
             if ($class_ref->getTypeName() != 'n_CLASS_NAME') {
                 continue;
             }
             $class_ref_name = $class_ref->getConcreteString();
             if (strtolower($class_name) == strtolower($class_ref_name)) {
                 $in_closure = false;
                 foreach ($closures as $closure) {
                     if ($class_ref->isDescendantOf($closure)) {
                         $in_closure = true;
                         break;
                     }
                 }
                 if (version_compare($this->version, '5.4.0', '>=') || !$in_closure) {
                     $this->raiseLintAtNode($class_ref, pht('Use `%s` for local static member references.', 'self::'), 'self');
                 }
             }
             static $self_refs = array('parent', 'self', 'static');
             if (!in_array(strtolower($class_ref_name), $self_refs)) {
                 continue;
             }
             if ($class_ref_name != strtolower($class_ref_name)) {
                 $this->raiseLintAtNode($class_ref, pht('PHP keywords should be lowercase.'), strtolower($class_ref_name));
             }
         }
     }
     $double_colons = $root->selectTokensOfType('T_PAAMAYIM_NEKUDOTAYIM');
     foreach ($double_colons as $double_colon) {
         $tokens = $double_colon->getNonsemanticTokensBefore() + $double_colon->getNonsemanticTokensAfter();
         foreach ($tokens as $token) {
             if ($token->isAnyWhitespace()) {
                 if (strpos($token->getValue(), "\n") !== false) {
                     continue;
                 }
                 $this->raiseLintAtToken($token, pht('Unnecessary whitespace around double colon operator.'), '');
             }
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     $operators = $root->selectTokensOfType('T_OBJECT_OPERATOR');
     foreach ($operators as $operator) {
         $before = $operator->getNonsemanticTokensBefore();
         $after = $operator->getNonsemanticTokensAfter();
         if ($before) {
             $value = implode('', mpull($before, 'getValue'));
             if (strpos($value, "\n") !== false) {
                 continue;
             }
             $this->raiseLintAtOffset(head($before)->getOffset(), pht('There should be no whitespace before the object operator.'), $value, '');
         }
         if ($after) {
             $this->raiseLintAtOffset(head($after)->getOffset(), pht('There should be no whitespace after the object operator.'), implode('', mpull($before, 'getValue')), '');
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     $tokens = $root->selectTokensOfType('T_OPEN_TAG');
     foreach ($tokens as $token) {
         for ($next = $token->getNextToken(); $next; $next = $next->getNextToken()) {
             if ($next->getTypeName() == 'T_WHITESPACE' && preg_match('/\\n\\s*\\n/', $next->getValue())) {
                 continue 2;
             }
             if ($token->getLineNumber() != $next->getLineNumber()) {
                 break;
             }
             if ($next->getTypeName() == 'T_CLOSE_TAG') {
                 continue 2;
             }
         }
         $next = $token->getNextToken();
         $this->raiseLintAtToken($next, pht('`%s` should be separated from code by an empty line.', '<?php'), "\n" . $next->getValue());
     }
 }

 public function process(XHPASTNode $root)
 {
     $tokens = $root->selectTokensOfType('.');
     foreach ($tokens as $token) {
         $prev = $token->getPrevToken();
         $next = $token->getNextToken();
         foreach (array('prev' => $prev, 'next' => $next) as $wtoken) {
             if ($wtoken->getTypeName() !== 'T_WHITESPACE') {
                 continue;
             }
             $value = $wtoken->getValue();
             if (strpos($value, "\n") !== false) {
                 // If the whitespace has a newline, it's conventional.
                 continue;
             }
             $next = $wtoken->getNextToken();
             if ($next && $next->getTypeName() === 'T_COMMENT') {
                 continue;
             }
             $this->raiseLintAtToken($wtoken, pht('Convention: no spaces around string concatenation operator.'), '');
         }
     }
 }

 private function lintPHP53Features(XHPASTNode $root)
 {
     $functions = $root->selectTokensOfType('T_FUNCTION');
     foreach ($functions as $function) {
         $next = $function->getNextToken();
         while ($next) {
             if ($next->isSemantic()) {
                 break;
             }
             $next = $next->getNextToken();
         }
         if ($next) {
             if ($next->getTypeName() === '(') {
                 $this->raiseLintAtToken($function, pht('This codebase targets PHP %s, but anonymous ' . 'functions were not introduced until PHP 5.3.', $this->version));
             }
         }
     }
     $namespaces = $root->selectTokensOfType('T_NAMESPACE');
     foreach ($namespaces as $namespace) {
         $this->raiseLintAtToken($namespace, pht('This codebase targets PHP %s, but namespaces were not ' . 'introduced until PHP 5.3.', $this->version));
     }
     // NOTE: This is only "use x;", in anonymous functions the node type is
     // n_LEXICAL_VARIABLE_LIST even though both tokens are T_USE.
     $uses = $root->selectDescendantsOfType('n_USE_LIST');
     foreach ($uses as $use) {
         $this->raiseLintAtNode($use, pht('This codebase targets PHP %s, but namespaces were not ' . 'introduced until PHP 5.3.', $this->version));
     }
     $statics = $root->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
     foreach ($statics as $static) {
         $name = $static->getChildByIndex(0);
         if ($name->getTypeName() != 'n_CLASS_NAME') {
             continue;
         }
         if ($name->getConcreteString() === 'static') {
             $this->raiseLintAtNode($name, pht('This codebase targets PHP %s, but `%s` was not ' . 'introduced until PHP 5.3.', $this->version, 'static::'));
         }
     }
     $ternaries = $root->selectDescendantsOfType('n_TERNARY_EXPRESSION');
     foreach ($ternaries as $ternary) {
         $yes = $ternary->getChildByIndex(2);
         if ($yes->getTypeName() === 'n_EMPTY') {
             $this->raiseLintAtNode($ternary, pht('This codebase targets PHP %s, but short ternary was ' . 'not introduced until PHP 5.3.', $this->version));
         }
     }
     $heredocs = $root->selectDescendantsOfType('n_HEREDOC');
     foreach ($heredocs as $heredoc) {
         if (preg_match('/^<<<[\'"]/', $heredoc->getConcreteString())) {
             $this->raiseLintAtNode($heredoc, pht('This codebase targets PHP %s, but nowdoc was not ' . 'introduced until PHP 5.3.', $this->version));
         }
     }
 }

 public function process(XHPASTNode $root)
 {
     foreach ($root->selectTokensOfType('T_CLOSE_TAG') as $token) {
         $this->raiseLintAtToken($token, pht('Do not use the PHP closing tag, "%s".', '?>'));
     }
 }

 public function process(XHPASTNode $root)
 {
     $expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
     foreach ($expressions as $expression) {
         $operator = $expression->getChildByIndex(1);
         $operator_value = $operator->getConcreteString();
         list($before, $after) = $operator->getSurroundingNonsemanticTokens();
         $replace = null;
         if (empty($before) && empty($after)) {
             $replace = " {$operator_value} ";
         } else {
             if (empty($before)) {
                 $replace = " {$operator_value}";
             } else {
                 if (empty($after)) {
                     $replace = "{$operator_value} ";
                 }
             }
         }
         if ($replace !== null) {
             $this->raiseLintAtNode($operator, pht('Convention: logical and arithmetic operators should be ' . 'surrounded by whitespace.'), $replace);
         }
     }
     $tokens = $root->selectTokensOfType(',');
     foreach ($tokens as $token) {
         $next = $token->getNextToken();
         switch ($next->getTypeName()) {
             case ')':
             case 'T_WHITESPACE':
                 break;
             default:
                 $this->raiseLintAtToken($token, pht('Convention: comma should be followed by space.'), ', ');
                 break;
         }
     }
     $tokens = $root->selectTokensOfType('T_DOUBLE_ARROW');
     foreach ($tokens as $token) {
         $prev = $token->getPrevToken();
         $next = $token->getNextToken();
         $prev_type = $prev->getTypeName();
         $next_type = $next->getTypeName();
         $prev_space = $prev_type === 'T_WHITESPACE';
         $next_space = $next_type === 'T_WHITESPACE';
         $replace = null;
         if (!$prev_space && !$next_space) {
             $replace = ' => ';
         } else {
             if ($prev_space && !$next_space) {
                 $replace = '=> ';
             } else {
                 if (!$prev_space && $next_space) {
                     $replace = ' =>';
                 }
             }
         }
         if ($replace !== null) {
             $this->raiseLintAtToken($token, pht('Convention: double arrow should be surrounded by whitespace.'), $replace);
         }
     }
     $parameters = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER');
     foreach ($parameters as $parameter) {
         if ($parameter->getChildByIndex(2)->getTypeName() == 'n_EMPTY') {
             continue;
         }
         $operator = head($parameter->selectTokensOfType('='));
         $before = $operator->getNonsemanticTokensBefore();
         $after = $operator->getNonsemanticTokensAfter();
         $replace = null;
         if (empty($before) && empty($after)) {
             $replace = ' = ';
         } else {
             if (empty($before)) {
                 $replace = ' =';
             } else {
                 if (empty($after)) {
                     $replace = '= ';
                 }
             }
         }
         if ($replace !== null) {
             $this->raiseLintAtToken($operator, pht('Convention: logical and arithmetic operators should be ' . 'surrounded by whitespace.'), $replace);
         }
     }
 }