vendor/symfony/debug/DebugClassLoader.php line 200

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\Debug;
  11. use PHPUnit\Framework\MockObject\Matcher\StatelessInvocation;
  12. /**
  13.  * Autoloader checking if the class is really defined in the file found.
  14.  *
  15.  * The ClassLoader will wrap all registered autoloaders
  16.  * and will throw an exception if a file is found but does
  17.  * not declare the class.
  18.  *
  19.  * @author Fabien Potencier <fabien@symfony.com>
  20.  * @author Christophe Coevoet <stof@notk.org>
  21.  * @author Nicolas Grekas <p@tchwork.com>
  22.  * @author Guilhem Niot <guilhem.niot@gmail.com>
  23.  */
  24. class DebugClassLoader
  25. {
  26.     private $classLoader;
  27.     private $isFinder;
  28.     private $loaded = [];
  29.     private static $caseCheck;
  30.     private static $checkedClasses = [];
  31.     private static $final = [];
  32.     private static $finalMethods = [];
  33.     private static $deprecated = [];
  34.     private static $internal = [];
  35.     private static $internalMethods = [];
  36.     private static $annotatedParameters = [];
  37.     private static $darwinCache = ['/' => ['/', []]];
  38.     private static $method = [];
  39.     public function __construct(callable $classLoader)
  40.     {
  41.         $this->classLoader $classLoader;
  42.         $this->isFinder = \is_array($classLoader) && method_exists($classLoader[0], 'findFile');
  43.         if (!isset(self::$caseCheck)) {
  44.             $file file_exists(__FILE__) ? __FILE__ rtrim(realpath('.'), \DIRECTORY_SEPARATOR);
  45.             $i strrpos($file, \DIRECTORY_SEPARATOR);
  46.             $dir substr($file0$i);
  47.             $file substr($file$i);
  48.             $test strtoupper($file) === $file strtolower($file) : strtoupper($file);
  49.             $test realpath($dir.$test);
  50.             if (false === $test || false === $i) {
  51.                 // filesystem is case sensitive
  52.                 self::$caseCheck 0;
  53.             } elseif (substr($test, -\strlen($file)) === $file) {
  54.                 // filesystem is case insensitive and realpath() normalizes the case of characters
  55.                 self::$caseCheck 1;
  56.             } elseif (false !== stripos(PHP_OS'darwin')) {
  57.                 // on MacOSX, HFS+ is case insensitive but realpath() doesn't normalize the case of characters
  58.                 self::$caseCheck 2;
  59.             } else {
  60.                 // filesystem case checks failed, fallback to disabling them
  61.                 self::$caseCheck 0;
  62.             }
  63.         }
  64.     }
  65.     /**
  66.      * Gets the wrapped class loader.
  67.      *
  68.      * @return callable The wrapped class loader
  69.      */
  70.     public function getClassLoader()
  71.     {
  72.         return $this->classLoader;
  73.     }
  74.     /**
  75.      * Wraps all autoloaders.
  76.      */
  77.     public static function enable()
  78.     {
  79.         // Ensures we don't hit https://bugs.php.net/42098
  80.         class_exists('Symfony\Component\Debug\ErrorHandler');
  81.         class_exists('Psr\Log\LogLevel');
  82.         if (!\is_array($functions spl_autoload_functions())) {
  83.             return;
  84.         }
  85.         foreach ($functions as $function) {
  86.             spl_autoload_unregister($function);
  87.         }
  88.         foreach ($functions as $function) {
  89.             if (!\is_array($function) || !$function[0] instanceof self) {
  90.                 $function = [new static($function), 'loadClass'];
  91.             }
  92.             spl_autoload_register($function);
  93.         }
  94.     }
  95.     /**
  96.      * Disables the wrapping.
  97.      */
  98.     public static function disable()
  99.     {
  100.         if (!\is_array($functions spl_autoload_functions())) {
  101.             return;
  102.         }
  103.         foreach ($functions as $function) {
  104.             spl_autoload_unregister($function);
  105.         }
  106.         foreach ($functions as $function) {
  107.             if (\is_array($function) && $function[0] instanceof self) {
  108.                 $function $function[0]->getClassLoader();
  109.             }
  110.             spl_autoload_register($function);
  111.         }
  112.     }
  113.     /**
  114.      * @return string|null
  115.      */
  116.     public function findFile($class)
  117.     {
  118.         return $this->isFinder $this->classLoader[0]->findFile($class) ?: null null;
  119.     }
  120.     /**
  121.      * Loads the given class or interface.
  122.      *
  123.      * @param string $class The name of the class
  124.      *
  125.      * @throws \RuntimeException
  126.      */
  127.     public function loadClass($class)
  128.     {
  129.         $e error_reporting(error_reporting() | E_PARSE E_ERROR E_CORE_ERROR E_COMPILE_ERROR);
  130.         try {
  131.             if ($this->isFinder && !isset($this->loaded[$class])) {
  132.                 $this->loaded[$class] = true;
  133.                 if (!$file $this->classLoader[0]->findFile($class) ?: false) {
  134.                     // no-op
  135.                 } elseif (\function_exists('opcache_is_script_cached') && @opcache_is_script_cached($file)) {
  136.                     include $file;
  137.                     return;
  138.                 } elseif (false === include $file) {
  139.                     return;
  140.                 }
  141.             } else {
  142.                 ($this->classLoader)($class);
  143.                 $file false;
  144.             }
  145.         } finally {
  146.             error_reporting($e);
  147.         }
  148.         $this->checkClass($class$file);
  149.     }
  150.     private function checkClass($class$file null)
  151.     {
  152.         $exists null === $file || class_exists($classfalse) || interface_exists($classfalse) || trait_exists($classfalse);
  153.         if (null !== $file && $class && '\\' === $class[0]) {
  154.             $class substr($class1);
  155.         }
  156.         if ($exists) {
  157.             if (isset(self::$checkedClasses[$class])) {
  158.                 return;
  159.             }
  160.             self::$checkedClasses[$class] = true;
  161.             $refl = new \ReflectionClass($class);
  162.             if (null === $file && $refl->isInternal()) {
  163.                 return;
  164.             }
  165.             $name $refl->getName();
  166.             if ($name !== $class && === strcasecmp($name$class)) {
  167.                 throw new \RuntimeException(sprintf('Case mismatch between loaded and declared class names: "%s" vs "%s".'$class$name));
  168.             }
  169.             $deprecations $this->checkAnnotations($refl$name);
  170.             foreach ($deprecations as $message) {
  171.                 @trigger_error($messageE_USER_DEPRECATED);
  172.             }
  173.         }
  174.         if (!$file) {
  175.             return;
  176.         }
  177.         if (!$exists) {
  178.             if (false !== strpos($class'/')) {
  179.                 throw new \RuntimeException(sprintf('Trying to autoload a class with an invalid name "%s". Be careful that the namespace separator is "\" in PHP, not "/".'$class));
  180.             }
  181.             throw new \RuntimeException(sprintf('The autoloader expected class "%s" to be defined in file "%s". The file was found but the class was not in it, the class name or namespace probably has a typo.'$class$file));
  182.         }
  183.         if (self::$caseCheck && $message $this->checkCase($refl$file$class)) {
  184.             throw new \RuntimeException(sprintf('Case mismatch between class and real file names: "%s" vs "%s" in "%s".'$message[0], $message[1], $message[2]));
  185.         }
  186.     }
  187.     public function checkAnnotations(\ReflectionClass $refl$class)
  188.     {
  189.         $deprecations = [];
  190.         // Don't trigger deprecations for classes in the same vendor
  191.         if ($len + (strpos($class'\\') ?: strpos($class'_'))) {
  192.             $len 0;
  193.             $ns '';
  194.         } else {
  195.             $ns str_replace('_''\\'substr($class0$len));
  196.         }
  197.         // Detect annotations on the class
  198.         if (false !== $doc $refl->getDocComment()) {
  199.             foreach (['final''deprecated''internal'] as $annotation) {
  200.                 if (false !== strpos($doc$annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$|\r?\n)#s'$doc$notice)) {
  201.                     self::${$annotation}[$class] = isset($notice[1]) ? preg_replace('#\.?\r?\n( \*)? *(?= |\r?\n|$)#'''$notice[1]) : '';
  202.                 }
  203.             }
  204.             if ($refl->isInterface() && false !== strpos($doc'method') && preg_match_all('#\n \* @method\s+(static\s+)?+(?:[\w\|&\[\]\\\]+\s+)?(\w+(?:\s*\([^\)]*\))?)+(.+?([[:punct:]]\s*)?)?(?=\r?\n \*(?: @|/$|\r?\n))#'$doc$noticePREG_SET_ORDER)) {
  205.                 foreach ($notice as $method) {
  206.                     $static '' !== $method[1];
  207.                     $name $method[2];
  208.                     $description $method[3] ?? null;
  209.                     if (false === strpos($name'(')) {
  210.                         $name .= '()';
  211.                     }
  212.                     if (null !== $description) {
  213.                         $description trim($description);
  214.                         if (!isset($method[4])) {
  215.                             $description .= '.';
  216.                         }
  217.                     }
  218.                     self::$method[$class][] = [$class$name$static$description];
  219.                 }
  220.             }
  221.         }
  222.         $parent get_parent_class($class);
  223.         $parentAndOwnInterfaces $this->getOwnInterfaces($class$parent);
  224.         if ($parent) {
  225.             $parentAndOwnInterfaces[$parent] = $parent;
  226.             if (!isset(self::$checkedClasses[$parent])) {
  227.                 $this->checkClass($parent);
  228.             }
  229.             if (isset(self::$final[$parent])) {
  230.                 $deprecations[] = sprintf('The "%s" class is considered final%s. It may change without further notice as of its next major version. You should not extend it from "%s".'$parentself::$final[$parent], $class);
  231.             }
  232.         }
  233.         // Detect if the parent is annotated
  234.         foreach ($parentAndOwnInterfaces class_uses($classfalse) as $use) {
  235.             if (!isset(self::$checkedClasses[$use])) {
  236.                 $this->checkClass($use);
  237.             }
  238.             if (isset(self::$deprecated[$use]) && strncmp($nsstr_replace('_''\\'$use), $len) && !isset(self::$deprecated[$class])) {
  239.                 $type class_exists($classfalse) ? 'class' : (interface_exists($classfalse) ? 'interface' 'trait');
  240.                 $verb class_exists($usefalse) || interface_exists($classfalse) ? 'extends' : (interface_exists($usefalse) ? 'implements' 'uses');
  241.                 $deprecations[] = sprintf('The "%s" %s %s "%s" that is deprecated%s.'$class$type$verb$useself::$deprecated[$use]);
  242.             }
  243.             if (isset(self::$internal[$use]) && strncmp($nsstr_replace('_''\\'$use), $len)) {
  244.                 $deprecations[] = sprintf('The "%s" %s is considered internal%s. It may change without further notice. You should not use it from "%s".'$useclass_exists($usefalse) ? 'class' : (interface_exists($usefalse) ? 'interface' 'trait'), self::$internal[$use], $class);
  245.             }
  246.             if (isset(self::$method[$use])) {
  247.                 if ($refl->isAbstract()) {
  248.                     if (isset(self::$method[$class])) {
  249.                         self::$method[$class] = array_merge(self::$method[$class], self::$method[$use]);
  250.                     } else {
  251.                         self::$method[$class] = self::$method[$use];
  252.                     }
  253.                 } elseif (!$refl->isInterface()) {
  254.                     $hasCall $refl->hasMethod('__call');
  255.                     $hasStaticCall $refl->hasMethod('__callStatic');
  256.                     foreach (self::$method[$use] as $method) {
  257.                         list($interface$name$static$description) = $method;
  258.                         if ($static $hasStaticCall $hasCall) {
  259.                             continue;
  260.                         }
  261.                         $realName substr($name0strpos($name'('));
  262.                         if (!$refl->hasMethod($realName) || !($methodRefl $refl->getMethod($realName))->isPublic() || ($static && !$methodRefl->isStatic()) || (!$static && $methodRefl->isStatic())) {
  263.                             $deprecations[] = sprintf('Class "%s" should implement method "%s::%s"%s'$class, ($static 'static ' '').$interface$namenull == $description '.' ': '.$description);
  264.                         }
  265.                     }
  266.                 }
  267.             }
  268.         }
  269.         if (trait_exists($class)) {
  270.             return $deprecations;
  271.         }
  272.         // Inherit @final, @internal and @param annotations for methods
  273.         self::$finalMethods[$class] = [];
  274.         self::$internalMethods[$class] = [];
  275.         self::$annotatedParameters[$class] = [];
  276.         foreach ($parentAndOwnInterfaces as $use) {
  277.             foreach (['finalMethods''internalMethods''annotatedParameters'] as $property) {
  278.                 if (isset(self::${$property}[$use])) {
  279.                     self::${$property}[$class] = self::${$property}[$class] ? self::${$property}[$use] + self::${$property}[$class] : self::${$property}[$use];
  280.                 }
  281.             }
  282.         }
  283.         foreach ($refl->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED) as $method) {
  284.             if ($method->class !== $class) {
  285.                 continue;
  286.             }
  287.             if ($parent && isset(self::$finalMethods[$parent][$method->name])) {
  288.                 list($declaringClass$message) = self::$finalMethods[$parent][$method->name];
  289.                 $deprecations[] = sprintf('The "%s::%s()" method is considered final%s. It may change without further notice as of its next major version. You should not extend it from "%s".'$declaringClass$method->name$message$class);
  290.             }
  291.             if (isset(self::$internalMethods[$class][$method->name])) {
  292.                 list($declaringClass$message) = self::$internalMethods[$class][$method->name];
  293.                 if (strncmp($ns$declaringClass$len)) {
  294.                     $deprecations[] = sprintf('The "%s::%s()" method is considered internal%s. It may change without further notice. You should not extend it from "%s".'$declaringClass$method->name$message$class);
  295.                 }
  296.             }
  297.             // To read method annotations
  298.             $doc $method->getDocComment();
  299.             if (isset(self::$annotatedParameters[$class][$method->name])) {
  300.                 $definedParameters = [];
  301.                 foreach ($method->getParameters() as $parameter) {
  302.                     $definedParameters[$parameter->name] = true;
  303.                 }
  304.                 foreach (self::$annotatedParameters[$class][$method->name] as $parameterName => $deprecation) {
  305.                     if (!isset($definedParameters[$parameterName]) && !($doc && preg_match("/\\n\\s+\\* @param +((?(?!callable *\().*?|callable *\(.*\).*?))(?<= )\\\${$parameterName}\\b/"$doc))) {
  306.                         $deprecations[] = sprintf($deprecation$class);
  307.                     }
  308.                 }
  309.             }
  310.             if (!$doc) {
  311.                 continue;
  312.             }
  313.             $finalOrInternal false;
  314.             foreach (['final''internal'] as $annotation) {
  315.                 if (false !== strpos($doc$annotation) && preg_match('#\n\s+\* @'.$annotation.'(?:( .+?)\.?)?\r?\n\s+\*(?: @|/$|\r?\n)#s'$doc$notice)) {
  316.                     $message = isset($notice[1]) ? preg_replace('#\.?\r?\n( \*)? *(?= |\r?\n|$)#'''$notice[1]) : '';
  317.                     self::${$annotation.'Methods'}[$class][$method->name] = [$class$message];
  318.                     $finalOrInternal true;
  319.                 }
  320.             }
  321.             if ($finalOrInternal || $method->isConstructor() || false === strpos($doc'@param') || StatelessInvocation::class === $class) {
  322.                 continue;
  323.             }
  324.             if (!preg_match_all('#\n\s+\* @param +((?(?!callable *\().*?|callable *\(.*\).*?))(?<= )\$([a-zA-Z0-9_\x7f-\xff]++)#'$doc$matchesPREG_SET_ORDER)) {
  325.                 continue;
  326.             }
  327.             if (!isset(self::$annotatedParameters[$class][$method->name])) {
  328.                 $definedParameters = [];
  329.                 foreach ($method->getParameters() as $parameter) {
  330.                     $definedParameters[$parameter->name] = true;
  331.                 }
  332.             }
  333.             foreach ($matches as list(, $parameterType$parameterName)) {
  334.                 if (!isset($definedParameters[$parameterName])) {
  335.                     $parameterType trim($parameterType);
  336.                     self::$annotatedParameters[$class][$method->name][$parameterName] = sprintf('The "%%s::%s()" method will require a new "%s$%s" argument in the next major version of its parent class "%s", not defining it is deprecated.'$method->name$parameterType $parameterType.' ' ''$parameterName$method->class);
  337.                 }
  338.             }
  339.         }
  340.         return $deprecations;
  341.     }
  342.     /**
  343.      * @param string $file
  344.      * @param string $class
  345.      *
  346.      * @return array|null
  347.      */
  348.     public function checkCase(\ReflectionClass $refl$file$class)
  349.     {
  350.         $real explode('\\'$class.strrchr($file'.'));
  351.         $tail explode(\DIRECTORY_SEPARATORstr_replace('/', \DIRECTORY_SEPARATOR$file));
  352.         $i = \count($tail) - 1;
  353.         $j = \count($real) - 1;
  354.         while (isset($tail[$i], $real[$j]) && $tail[$i] === $real[$j]) {
  355.             --$i;
  356.             --$j;
  357.         }
  358.         array_splice($tail0$i 1);
  359.         if (!$tail) {
  360.             return null;
  361.         }
  362.         $tail = \DIRECTORY_SEPARATOR.implode(\DIRECTORY_SEPARATOR$tail);
  363.         $tailLen = \strlen($tail);
  364.         $real $refl->getFileName();
  365.         if (=== self::$caseCheck) {
  366.             $real $this->darwinRealpath($real);
  367.         }
  368.         if (=== substr_compare($real$tail, -$tailLen$tailLentrue)
  369.             && !== substr_compare($real$tail, -$tailLen$tailLenfalse)
  370.         ) {
  371.             return [substr($tail, -$tailLen 1), substr($real, -$tailLen 1), substr($real0, -$tailLen 1)];
  372.         }
  373.         return null;
  374.     }
  375.     /**
  376.      * `realpath` on MacOSX doesn't normalize the case of characters.
  377.      */
  378.     private function darwinRealpath($real)
  379.     {
  380.         $i strrpos($real'/');
  381.         $file substr($real$i);
  382.         $real substr($real0$i);
  383.         if (isset(self::$darwinCache[$real])) {
  384.             $kDir $real;
  385.         } else {
  386.             $kDir strtolower($real);
  387.             if (isset(self::$darwinCache[$kDir])) {
  388.                 $real self::$darwinCache[$kDir][0];
  389.             } else {
  390.                 $dir getcwd();
  391.                 chdir($real);
  392.                 $real getcwd().'/';
  393.                 chdir($dir);
  394.                 $dir $real;
  395.                 $k $kDir;
  396.                 $i = \strlen($dir) - 1;
  397.                 while (!isset(self::$darwinCache[$k])) {
  398.                     self::$darwinCache[$k] = [$dir, []];
  399.                     self::$darwinCache[$dir] = &self::$darwinCache[$k];
  400.                     while ('/' !== $dir[--$i]) {
  401.                     }
  402.                     $k substr($k0, ++$i);
  403.                     $dir substr($dir0$i--);
  404.                 }
  405.             }
  406.         }
  407.         $dirFiles self::$darwinCache[$kDir][1];
  408.         if (!isset($dirFiles[$file]) && ') : eval()\'d code' === substr($file, -17)) {
  409.             // Get the file name from "file_name.php(123) : eval()'d code"
  410.             $file substr($file0strrpos($file'(', -17));
  411.         }
  412.         if (isset($dirFiles[$file])) {
  413.             return $real .= $dirFiles[$file];
  414.         }
  415.         $kFile strtolower($file);
  416.         if (!isset($dirFiles[$kFile])) {
  417.             foreach (scandir($real2) as $f) {
  418.                 if ('.' !== $f[0]) {
  419.                     $dirFiles[$f] = $f;
  420.                     if ($f === $file) {
  421.                         $kFile $k $file;
  422.                     } elseif ($f !== $k strtolower($f)) {
  423.                         $dirFiles[$k] = $f;
  424.                     }
  425.                 }
  426.             }
  427.             self::$darwinCache[$kDir][1] = $dirFiles;
  428.         }
  429.         return $real .= $dirFiles[$kFile];
  430.     }
  431.     /**
  432.      * `class_implements` includes interfaces from the parents so we have to manually exclude them.
  433.      *
  434.      * @param string       $class
  435.      * @param string|false $parent
  436.      *
  437.      * @return string[]
  438.      */
  439.     private function getOwnInterfaces($class$parent)
  440.     {
  441.         $ownInterfaces class_implements($classfalse);
  442.         if ($parent) {
  443.             foreach (class_implements($parentfalse) as $interface) {
  444.                 unset($ownInterfaces[$interface]);
  445.             }
  446.         }
  447.         foreach ($ownInterfaces as $interface) {
  448.             foreach (class_implements($interface) as $interface) {
  449.                 unset($ownInterfaces[$interface]);
  450.             }
  451.         }
  452.         return $ownInterfaces;
  453.     }
  454. }