Merge branch '3.4' into 4.0

nicolas-grekas · nicolas-grekas · commit 002d3aea642f · 2018-07-26T10:51:09.000+02:00
* 3.4:
  Fix Clidumper tests
  Enable the fixer enforcing fully-qualified calls for compiler-optimized functions
  Apply fixers
  Disable the native_constant_invocation fixer until it can be scoped
  Update the list of excluded files for the CS fixer
diff --git a/Node/AbstractNode.php b/Node/AbstractNode.php
@@ -34,7 +34,7 @@ abstract class AbstractNode implements NodeInterface
     public function getNodeName(): string
     {
         if (null === $this->nodeName) {
-            $this->nodeName = preg_replace('~.*\\\\([^\\\\]+)Node$~', '$1', get_called_class());
+            $this->nodeName = preg_replace('~.*\\\\([^\\\\]+)Node$~', '$1', \get_called_class());
         }
 
         return $this->nodeName;
diff --git a/Parser/Handler/HashHandler.php b/Parser/Handler/HashHandler.php
@@ -51,7 +51,7 @@ public function handle(Reader $reader, TokenStream $stream): bool
 
         $value = $this->escaping->escapeUnicode($match[1]);
         $stream->push(new Token(Token::TYPE_HASH, $value, $reader->getPosition()));
-        $reader->moveForward(strlen($match[0]));
+        $reader->moveForward(\strlen($match[0]));
 
         return true;
     }
diff --git a/Parser/Handler/IdentifierHandler.php b/Parser/Handler/IdentifierHandler.php
@@ -51,7 +51,7 @@ public function handle(Reader $reader, TokenStream $stream): bool
 
         $value = $this->escaping->escapeUnicode($match[0]);
         $stream->push(new Token(Token::TYPE_IDENTIFIER, $value, $reader->getPosition()));
-        $reader->moveForward(strlen($match[0]));
+        $reader->moveForward(\strlen($match[0]));
 
         return true;
     }
diff --git a/Parser/Handler/NumberHandler.php b/Parser/Handler/NumberHandler.php
@@ -47,7 +47,7 @@ public function handle(Reader $reader, TokenStream $stream): bool
         }
 
         $stream->push(new Token(Token::TYPE_NUMBER, $match[0], $reader->getPosition()));
-        $reader->moveForward(strlen($match[0]));
+        $reader->moveForward(\strlen($match[0]));
 
         return true;
     }
diff --git a/Parser/Handler/StringHandler.php b/Parser/Handler/StringHandler.php
@@ -47,7 +47,7 @@ public function handle(Reader $reader, TokenStream $stream): bool
     {
         $quote = $reader->getSubstring(1);
 
-        if (!in_array($quote, array("'", '"'))) {
+        if (!\in_array($quote, array("'", '"'))) {
             return false;
         }
 
@@ -59,18 +59,18 @@ public function handle(Reader $reader, TokenStream $stream): bool
         }
 
         // check unclosed strings
-        if (strlen($match[0]) === $reader->getRemainingLength()) {
+        if (\strlen($match[0]) === $reader->getRemainingLength()) {
             throw SyntaxErrorException::unclosedString($reader->getPosition() - 1);
         }
 
         // check quotes pairs validity
-        if ($quote !== $reader->getSubstring(1, strlen($match[0]))) {
+        if ($quote !== $reader->getSubstring(1, \strlen($match[0]))) {
             throw SyntaxErrorException::unclosedString($reader->getPosition() - 1);
         }
 
         $string = $this->escaping->escapeUnicodeAndNewLine($match[0]);
         $stream->push(new Token(Token::TYPE_STRING, $string, $reader->getPosition()));
-        $reader->moveForward(strlen($match[0]) + 1);
+        $reader->moveForward(\strlen($match[0]) + 1);
 
         return true;
     }
diff --git a/Parser/Handler/WhitespaceHandler.php b/Parser/Handler/WhitespaceHandler.php
@@ -39,7 +39,7 @@ public function handle(Reader $reader, TokenStream $stream): bool
         }
 
         $stream->push(new Token(Token::TYPE_WHITESPACE, $match[0], $reader->getPosition()));
-        $reader->moveForward(strlen($match[0]));
+        $reader->moveForward(\strlen($match[0]));
 
         return true;
     }
diff --git a/Parser/Parser.php b/Parser/Parser.php
@@ -150,7 +150,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =
     {
         $stream->skipWhitespace();
 
-        $selectorStart = count($stream->getUsed());
+        $selectorStart = \count($stream->getUsed());
         $result = $this->parseElementNode($stream);
         $pseudoElement = null;
 
@@ -187,7 +187,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =
                 }
 
                 $identifier = $stream->getNextIdentifier();
-                if (in_array(strtolower($identifier), array('first-line', 'first-letter', 'before', 'after'))) {
+                if (\in_array(strtolower($identifier), array('first-line', 'first-letter', 'before', 'after'))) {
                     // Special case: CSS 2.1 pseudo-elements can have a single ':'.
                     // Any new pseudo-element must have two.
                     $pseudoElement = $identifier;
@@ -253,7 +253,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =
             }
         }
 
-        if (count($stream->getUsed()) === $selectorStart) {
+        if (\count($stream->getUsed()) === $selectorStart) {
             throw SyntaxErrorException::unexpectedToken('selector', $stream->getPeek());
         }
 
diff --git a/Parser/Reader.php b/Parser/Reader.php
@@ -30,7 +30,7 @@ class Reader
     public function __construct(string $source)
     {
         $this->source = $source;
-        $this->length = strlen($source);
+        $this->length = \strlen($source);
     }
 
     public function isEOF(): bool
diff --git a/Parser/Token.php b/Parser/Token.php
@@ -72,7 +72,7 @@ public function isDelimiter(array $values = array()): bool
             return true;
         }
 
-        return in_array($this->value, $values);
+        return \in_array($this->value, $values);
     }
 
     public function isWhitespace(): bool
diff --git a/Parser/Tokenizer/TokenizerEscaping.php b/Parser/Tokenizer/TokenizerEscaping.php
@@ -50,13 +50,13 @@ private function replaceUnicodeSequences(string $value): string
             $c = hexdec($match[1]);
 
             if (0x80 > $c %= 0x200000) {
-                return chr($c);
+                return \chr($c);
             }
             if (0x800 > $c) {
-                return chr(0xC0 | $c >> 6).chr(0x80 | $c & 0x3F);
+                return \chr(0xC0 | $c >> 6).\chr(0x80 | $c & 0x3F);
             }
             if (0x10000 > $c) {
-                return chr(0xE0 | $c >> 12).chr(0x80 | $c >> 6 & 0x3F).chr(0x80 | $c & 0x3F);
+                return \chr(0xE0 | $c >> 12).\chr(0x80 | $c >> 6 & 0x3F).\chr(0x80 | $c & 0x3F);
             }
         }, $value);
     }
diff --git a/Tests/Parser/Handler/AbstractHandlerTest.php b/Tests/Parser/Handler/AbstractHandlerTest.php
@@ -63,7 +63,7 @@ protected function assertRemainingContent(Reader $reader, $remainingContent)
             $this->assertEquals(0, $reader->getRemainingLength());
             $this->assertTrue($reader->isEOF());
         } else {
-            $this->assertEquals(strlen($remainingContent), $reader->getRemainingLength());
+            $this->assertEquals(\strlen($remainingContent), $reader->getRemainingLength());
             $this->assertEquals(0, $reader->getOffset($remainingContent));
         }
     }
diff --git a/Tests/XPath/TranslatorTest.php b/Tests/XPath/TranslatorTest.php
@@ -37,9 +37,9 @@ public function testXmlLang($css, array $elementsId)
         $translator = new Translator();
         $document = new \SimpleXMLElement(file_get_contents(__DIR__.'/Fixtures/lang.xml'));
         $elements = $document->xpath($translator->cssToXPath($css));
-        $this->assertCount(count($elementsId), $elements);
+        $this->assertCount(\count($elementsId), $elements);
         foreach ($elements as $element) {
-            $this->assertTrue(in_array($element->attributes()->id, $elementsId));
+            $this->assertTrue(\in_array($element->attributes()->id, $elementsId));
         }
     }
 
@@ -54,10 +54,10 @@ public function testHtmlIds($css, array $elementsId)
         $document->loadHTMLFile(__DIR__.'/Fixtures/ids.html');
         $document = simplexml_import_dom($document);
         $elements = $document->xpath($translator->cssToXPath($css));
-        $this->assertCount(count($elementsId), $elementsId);
+        $this->assertCount(\count($elementsId), $elementsId);
         foreach ($elements as $element) {
             if (null !== $element->attributes()->id) {
-                $this->assertTrue(in_array($element->attributes()->id, $elementsId));
+                $this->assertTrue(\in_array($element->attributes()->id, $elementsId));
             }
         }
         libxml_clear_errors();
diff --git a/XPath/Extension/AttributeMatchingExtension.php b/XPath/Extension/AttributeMatchingExtension.php
@@ -86,7 +86,7 @@ public function translateSuffixMatch(XPathExpr $xpath, string $attribute, ?strin
         return $xpath->addCondition($value ? sprintf(
             '%1$s and substring(%1$s, string-length(%1$s)-%2$s) = %3$s',
             $attribute,
-            strlen($value) - 1,
+            \strlen($value) - 1,
             Translator::getXpathLiteral($value)
         ) : '0');
     }
diff --git a/XPath/Translator.php b/XPath/Translator.php
@@ -155,7 +155,7 @@ public function nodeToXPath(NodeInterface $node): XPathExpr
             throw new ExpressionErrorException(sprintf('Node "%s" not supported.', $node->getNodeName()));
         }
 
-        return call_user_func($this->nodeTranslators[$node->getNodeName()], $node, $this);
+        return \call_user_func($this->nodeTranslators[$node->getNodeName()], $node, $this);
     }
 
     /**
@@ -167,7 +167,7 @@ public function addCombination(string $combiner, NodeInterface $xpath, NodeInter
             throw new ExpressionErrorException(sprintf('Combiner "%s" not supported.', $combiner));
         }
 
-        return call_user_func($this->combinationTranslators[$combiner], $this->nodeToXPath($xpath), $this->nodeToXPath($combinedXpath));
+        return \call_user_func($this->combinationTranslators[$combiner], $this->nodeToXPath($xpath), $this->nodeToXPath($combinedXpath));
     }
 
     /**
@@ -179,7 +179,7 @@ public function addFunction(XPathExpr $xpath, FunctionNode $function): XPathExpr
             throw new ExpressionErrorException(sprintf('Function "%s" not supported.', $function->getName()));
         }
 
-        return call_user_func($this->functionTranslators[$function->getName()], $xpath, $function);
+        return \call_user_func($this->functionTranslators[$function->getName()], $xpath, $function);
     }
 
     /**
@@ -191,7 +191,7 @@ public function addPseudoClass(XPathExpr $xpath, string $pseudoClass): XPathExpr
             throw new ExpressionErrorException(sprintf('Pseudo-class "%s" not supported.', $pseudoClass));
         }
 
-        return call_user_func($this->pseudoClassTranslators[$pseudoClass], $xpath);
+        return \call_user_func($this->pseudoClassTranslators[$pseudoClass], $xpath);
     }
 
     /**
@@ -203,7 +203,7 @@ public function addAttributeMatching(XPathExpr $xpath, string $operator, string
             throw new ExpressionErrorException(sprintf('Attribute matcher operator "%s" not supported.', $operator));
         }
 
-        return call_user_func($this->attributeMatchingTranslators[$operator], $xpath, $attribute, $value);
+        return \call_user_func($this->attributeMatchingTranslators[$operator], $xpath, $attribute, $value);
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ abstract class AbstractNode implements NodeInterface`
`34`	`34`	`public function getNodeName(): string`
`35`	`35`	`{`
`36`	`36`	`if (null === $this->nodeName) {`
`37`		`- $this->nodeName = preg_replace('~.*\\\\([^\\\\]+)Node$~', '$1', get_called_class());`
	`37`	`+ $this->nodeName = preg_replace('~.*\\\\([^\\\\]+)Node$~', '$1', \get_called_class());`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`return $this->nodeName;`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public function handle(Reader $reader, TokenStream $stream): bool`
`51`	`51`
`52`	`52`	`$value = $this->escaping->escapeUnicode($match[1]);`
`53`	`53`	`$stream->push(new Token(Token::TYPE_HASH, $value, $reader->getPosition()));`
`54`		`- $reader->moveForward(strlen($match[0]));`
	`54`	`+ $reader->moveForward(\strlen($match[0]));`
`55`	`55`
`56`	`56`	`return true;`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public function handle(Reader $reader, TokenStream $stream): bool`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`$stream->push(new Token(Token::TYPE_NUMBER, $match[0], $reader->getPosition()));`
`50`		`- $reader->moveForward(strlen($match[0]));`
	`50`	`+ $reader->moveForward(\strlen($match[0]));`
`51`	`51`
`52`	`52`	`return true;`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public function handle(Reader $reader, TokenStream $stream): bool`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`$stream->push(new Token(Token::TYPE_WHITESPACE, $match[0], $reader->getPosition()));`
`42`		`- $reader->moveForward(strlen($match[0]));`
	`42`	`+ $reader->moveForward(\strlen($match[0]));`
`43`	`43`
`44`	`44`	`return true;`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =`
`150`	`150`	`{`
`151`	`151`	`$stream->skipWhitespace();`
`152`	`152`
`153`		`- $selectorStart = count($stream->getUsed());`
	`153`	`+ $selectorStart = \count($stream->getUsed());`
`154`	`154`	`$result = $this->parseElementNode($stream);`
`155`	`155`	`$pseudoElement = null;`
`156`	`156`
`@@ -187,7 +187,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`$identifier = $stream->getNextIdentifier();`
`190`		`- if (in_array(strtolower($identifier), array('first-line', 'first-letter', 'before', 'after'))) {`
	`190`	`+ if (\in_array(strtolower($identifier), array('first-line', 'first-letter', 'before', 'after'))) {`
`191`	`191`	`// Special case: CSS 2.1 pseudo-elements can have a single ':'.`
`192`	`192`	`// Any new pseudo-element must have two.`
`193`	`193`	`$pseudoElement = $identifier;`
`@@ -253,7 +253,7 @@ private function parseSimpleSelector(TokenStream $stream, bool $insideNegation =`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`
`256`		`- if (count($stream->getUsed()) === $selectorStart) {`
	`256`	`+ if (\count($stream->getUsed()) === $selectorStart) {`
`257`	`257`	`throw SyntaxErrorException::unexpectedToken('selector', $stream->getPeek());`
`258`	`258`	`}`
`259`	`259`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class Reader`
`30`	`30`	`public function __construct(string $source)`
`31`	`31`	`{`
`32`	`32`	`$this->source = $source;`
`33`		`- $this->length = strlen($source);`
	`33`	`+ $this->length = \strlen($source);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public function isEOF(): bool`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public function isDelimiter(array $values = array()): bool`
`72`	`72`	`return true;`
`73`	`73`	`}`
`74`	`74`
`75`		`- return in_array($this->value, $values);`
	`75`	`+ return \in_array($this->value, $values);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`public function isWhitespace(): bool`
Original file line number	Diff line number	Diff line change
`@@ -50,13 +50,13 @@ private function replaceUnicodeSequences(string $value): string`
`50`	`50`	`$c = hexdec($match[1]);`
`51`	`51`
`52`	`52`	`if (0x80 > $c %= 0x200000) {`
`53`		`- return chr($c);`
	`53`	`+ return \chr($c);`
`54`	`54`	`}`
`55`	`55`	`if (0x800 > $c) {`
`56`		`- return chr(0xC0 \| $c >> 6).chr(0x80 \| $c & 0x3F);`
	`56`	`+ return \chr(0xC0 \| $c >> 6).\chr(0x80 \| $c & 0x3F);`
`57`	`57`	`}`
`58`	`58`	`if (0x10000 > $c) {`
`59`		`- return chr(0xE0 \| $c >> 12).chr(0x80 \| $c >> 6 & 0x3F).chr(0x80 \| $c & 0x3F);`
	`59`	`+ return \chr(0xE0 \| $c >> 12).\chr(0x80 \| $c >> 6 & 0x3F).\chr(0x80 \| $c & 0x3F);`
`60`	`60`	`}`
`61`	`61`	`}, $value);`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ protected function assertRemainingContent(Reader $reader, $remainingContent)`
`63`	`63`	`$this->assertEquals(0, $reader->getRemainingLength());`
`64`	`64`	`$this->assertTrue($reader->isEOF());`
`65`	`65`	`} else {`
`66`		`- $this->assertEquals(strlen($remainingContent), $reader->getRemainingLength());`
	`66`	`+ $this->assertEquals(\strlen($remainingContent), $reader->getRemainingLength());`
`67`	`67`	`$this->assertEquals(0, $reader->getOffset($remainingContent));`
`68`	`68`	`}`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,9 +37,9 @@ public function testXmlLang($css, array $elementsId)`
`37`	`37`	`$translator = new Translator();`
`38`	`38`	`$document = new \SimpleXMLElement(file_get_contents(__DIR__.'/Fixtures/lang.xml'));`
`39`	`39`	`$elements = $document->xpath($translator->cssToXPath($css));`
`40`		`- $this->assertCount(count($elementsId), $elements);`
	`40`	`+ $this->assertCount(\count($elementsId), $elements);`
`41`	`41`	`foreach ($elements as $element) {`
`42`		`- $this->assertTrue(in_array($element->attributes()->id, $elementsId));`
	`42`	`+ $this->assertTrue(\in_array($element->attributes()->id, $elementsId));`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`@@ -54,10 +54,10 @@ public function testHtmlIds($css, array $elementsId)`
`54`	`54`	`$document->loadHTMLFile(__DIR__.'/Fixtures/ids.html');`
`55`	`55`	`$document = simplexml_import_dom($document);`
`56`	`56`	`$elements = $document->xpath($translator->cssToXPath($css));`
`57`		`- $this->assertCount(count($elementsId), $elementsId);`
	`57`	`+ $this->assertCount(\count($elementsId), $elementsId);`
`58`	`58`	`foreach ($elements as $element) {`
`59`	`59`	`if (null !== $element->attributes()->id) {`
`60`		`- $this->assertTrue(in_array($element->attributes()->id, $elementsId));`
	`60`	`+ $this->assertTrue(\in_array($element->attributes()->id, $elementsId));`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`libxml_clear_errors();`