Upgrade 1-11.38

vendor/symfony/cache/Simple/AbstractCache.php

@@ -12,25 +12,21 @@
 namespace Symfony\Component\Cache\Simple;
 
 use Psr\Log\LoggerAwareInterface;
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
-use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Psr\SimpleCache\CacheInterface;
 use Symfony\Component\Cache\CacheItem;
 use Symfony\Component\Cache\Exception\InvalidArgumentException;
 use Symfony\Component\Cache\ResettableInterface;
 use Symfony\Component\Cache\Traits\AbstractTrait;
-use Symfony\Contracts\Cache\CacheInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', AbstractCache::class, AbstractAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
 
 /**
- * @deprecated since Symfony 4.3, use AbstractAdapter and type-hint for CacheInterface instead.
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterface, ResettableInterface
+abstract class AbstractCache implements CacheInterface, LoggerAwareInterface, ResettableInterface
 {
     /**
      * @internal
      */
-    protected const NS_SEPARATOR = ':';
+    const NS_SEPARATOR = ':';
 
     use AbstractTrait {
         deleteItems as private;
@@ -40,12 +36,16 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
 
     private $defaultLifetime;
 
-    protected function __construct(string $namespace = '', int $defaultLifetime = 0)
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    protected function __construct($namespace = '', $defaultLifetime = 0)
     {
-        $this->defaultLifetime = max(0, $defaultLifetime);
+        $this->defaultLifetime = max(0, (int) $defaultLifetime);
         $this->namespace = '' === $namespace ? '' : CacheItem::validateKey($namespace).':';
         if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
-            throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s")', $this->maxIdLength - 24, \strlen($namespace), $namespace));
+            throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s").', $this->maxIdLength - 24, \strlen($namespace), $namespace));
         }
     }
 
@@ -61,7 +61,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
                 return $value;
             }
         } catch (\Exception $e) {
-            CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e]);
+            CacheItem::log($this->logger, 'Failed to fetch key "{key}"', ['key' => $key, 'exception' => $e]);
         }
 
         return $default;
@@ -85,7 +85,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
         if ($keys instanceof \Traversable) {
             $keys = iterator_to_array($keys, false);
         } elseif (!\is_array($keys)) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
         $ids = [];
 
@@ -95,7 +95,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
         try {
             $values = $this->doFetch($ids);
         } catch (\Exception $e) {
-            CacheItem::log($this->logger, 'Failed to fetch values: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e]);
+            CacheItem::log($this->logger, 'Failed to fetch requested values', ['keys' => $keys, 'exception' => $e]);
             $values = [];
         }
         $ids = array_combine($ids, $keys);
@@ -109,7 +109,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
     public function setMultiple($values, $ttl = null)
     {
         if (!\is_array($values) && !$values instanceof \Traversable) {
-            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given', \is_object($values) ? \get_class($values) : \gettype($values)));
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
         }
         $valuesById = [];
 
@@ -134,8 +134,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
         foreach (\is_array($e) ? $e : array_keys($valuesById) as $id) {
             $keys[] = substr($id, \strlen($this->namespace));
         }
-        $message = 'Failed to save values'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
-        CacheItem::log($this->logger, $message, ['keys' => $keys, 'exception' => $e instanceof \Exception ? $e : null]);
+        CacheItem::log($this->logger, 'Failed to save values', ['keys' => $keys, 'exception' => $e instanceof \Exception ? $e : null]);
 
         return false;
     }
@@ -148,7 +147,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
         if ($keys instanceof \Traversable) {
             $keys = iterator_to_array($keys, false);
         } elseif (!\is_array($keys)) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
 
         return $this->deleteItems($keys);
@@ -166,7 +165,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
             return 0 < $ttl ? $ttl : false;
         }
 
-        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
+        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given.', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
     }
 
     private function generateValues($values, &$keys, $default)
@@ -181,7 +180,7 @@ abstract class AbstractCache implements Psr16CacheInterface, LoggerAwareInterfac
                 yield $key => $value;
             }
         } catch (\Exception $e) {
-            CacheItem::log($this->logger, 'Failed to fetch values: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e]);
+            CacheItem::log($this->logger, 'Failed to fetch requested values', ['keys' => array_values($keys), 'exception' => $e]);
         }
 
         foreach ($keys as $key) {

vendor/symfony/cache/Simple/ApcuCache.php

@@ -11,20 +11,18 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\ApcuAdapter;
 use Symfony\Component\Cache\Traits\ApcuTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', ApcuCache::class, ApcuAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use ApcuAdapter and type-hint for CacheInterface instead.
- */
 class ApcuCache extends AbstractCache
 {
     use ApcuTrait;
 
-    public function __construct(string $namespace = '', int $defaultLifetime = 0, string $version = null)
+    /**
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $version
+     */
+    public function __construct($namespace = '', $defaultLifetime = 0, $version = null)
     {
         $this->init($namespace, $defaultLifetime, $version);
     }

vendor/symfony/cache/Simple/ArrayCache.php

@@ -12,20 +12,16 @@
 namespace Symfony\Component\Cache\Simple;
 
 use Psr\Log\LoggerAwareInterface;
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
-use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Psr\SimpleCache\CacheInterface;
 use Symfony\Component\Cache\CacheItem;
 use Symfony\Component\Cache\Exception\InvalidArgumentException;
 use Symfony\Component\Cache\ResettableInterface;
 use Symfony\Component\Cache\Traits\ArrayTrait;
-use Symfony\Contracts\Cache\CacheInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', ArrayCache::class, ArrayAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
 
 /**
- * @deprecated since Symfony 4.3, use ArrayAdapter and type-hint for CacheInterface instead.
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, ResettableInterface
+class ArrayCache implements CacheInterface, LoggerAwareInterface, ResettableInterface
 {
     use ArrayTrait {
         ArrayTrait::deleteItem as delete;
@@ -35,11 +31,12 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
     private $defaultLifetime;
 
     /**
+     * @param int  $defaultLifetime
      * @param bool $storeSerialized Disabling serialization can lead to cache corruptions when storing mutable values but increases performance otherwise
      */
-    public function __construct(int $defaultLifetime = 0, bool $storeSerialized = true)
+    public function __construct($defaultLifetime = 0, $storeSerialized = true)
     {
-        $this->defaultLifetime = $defaultLifetime;
+        $this->defaultLifetime = (int) $defaultLifetime;
         $this->storeSerialized = $storeSerialized;
     }
 
@@ -48,20 +45,9 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
      */
     public function get($key, $default = null)
     {
-        if (!\is_string($key) || !isset($this->expiries[$key])) {
-            CacheItem::validateKey($key);
+        foreach ($this->getMultiple([$key], $default) as $v) {
+            return $v;
         }
-        if (!$isHit = isset($this->expiries[$key]) && ($this->expiries[$key] > microtime(true) || !$this->delete($key))) {
-            $this->values[$key] = null;
-
-            return $default;
-        }
-        if (!$this->storeSerialized) {
-            return $this->values[$key];
-        }
-        $value = $this->unfreeze($key, $isHit);
-
-        return $isHit ? $value : $default;
     }
 
     /**
@@ -72,15 +58,13 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
         if ($keys instanceof \Traversable) {
             $keys = iterator_to_array($keys, false);
         } elseif (!\is_array($keys)) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
         foreach ($keys as $key) {
-            if (!\is_string($key) || !isset($this->expiries[$key])) {
-                CacheItem::validateKey($key);
-            }
+            CacheItem::validateKey($key);
         }
 
-        return $this->generateItems($keys, microtime(true), function ($k, $v, $hit) use ($default) { return $hit ? $v : $default; });
+        return $this->generateItems($keys, time(), function ($k, $v, $hit) use ($default) { return $hit ? $v : $default; });
     }
 
     /**
@@ -89,7 +73,7 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
     public function deleteMultiple($keys)
     {
         if (!\is_array($keys) && !$keys instanceof \Traversable) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
         foreach ($keys as $key) {
             $this->delete($key);
@@ -103,9 +87,7 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
      */
     public function set($key, $value, $ttl = null)
     {
-        if (!\is_string($key)) {
-            CacheItem::validateKey($key);
-        }
+        CacheItem::validateKey($key);
 
         return $this->setMultiple([$key => $value], $ttl);
     }
@@ -116,25 +98,32 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
     public function setMultiple($values, $ttl = null)
     {
         if (!\is_array($values) && !$values instanceof \Traversable) {
-            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given', \is_object($values) ? \get_class($values) : \gettype($values)));
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
         }
         $valuesArray = [];
 
         foreach ($values as $key => $value) {
-            if (!\is_int($key) && !(\is_string($key) && isset($this->expiries[$key]))) {
-                CacheItem::validateKey($key);
-            }
+            \is_int($key) || CacheItem::validateKey($key);
             $valuesArray[$key] = $value;
         }
         if (false === $ttl = $this->normalizeTtl($ttl)) {
             return $this->deleteMultiple(array_keys($valuesArray));
         }
-        $expiry = 0 < $ttl ? microtime(true) + $ttl : PHP_INT_MAX;
+        if ($this->storeSerialized) {
+            foreach ($valuesArray as $key => $value) {
+                try {
+                    $valuesArray[$key] = serialize($value);
+                } catch (\Exception $e) {
+                    $type = \is_object($value) ? \get_class($value) : \gettype($value);
+                    CacheItem::log($this->logger, 'Failed to save key "{key}" ({type})', ['key' => $key, 'type' => $type, 'exception' => $e]);
+
+                    return false;
+                }
+            }
+        }
+        $expiry = 0 < $ttl ? time() + $ttl : \PHP_INT_MAX;
 
         foreach ($valuesArray as $key => $value) {
-            if ($this->storeSerialized && null === $value = $this->freeze($value, $key)) {
-                return false;
-            }
             $this->values[$key] = $value;
             $this->expiries[$key] = $expiry;
         }
@@ -154,6 +143,6 @@ class ArrayCache implements Psr16CacheInterface, LoggerAwareInterface, Resettabl
             return 0 < $ttl ? $ttl : false;
         }
 
-        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
+        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given.', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
     }
 }

vendor/symfony/cache/Simple/ChainCache.php

@@ -11,15 +11,10 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
-use Symfony\Component\Cache\Adapter\ChainAdapter;
+use Psr\SimpleCache\CacheInterface;
 use Symfony\Component\Cache\Exception\InvalidArgumentException;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\ResettableInterface;
-use Symfony\Contracts\Cache\CacheInterface;
-use Symfony\Contracts\Service\ResetInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', ChainCache::class, ChainAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
 
 /**
  * Chains several caches together.
@@ -27,9 +22,9 @@ use Symfony\Contracts\Service\ResetInterface;
  * Cached items are fetched from the first cache having them in its data store.
  * They are saved and deleted in all caches at once.
  *
- * @deprecated since Symfony 4.3, use ChainAdapter and type-hint for CacheInterface instead.
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class ChainCache implements Psr16CacheInterface, PruneableInterface, ResettableInterface
+class ChainCache implements CacheInterface, PruneableInterface, ResettableInterface
 {
     private $miss;
     private $caches = [];
@@ -37,25 +32,25 @@ class ChainCache implements Psr16CacheInterface, PruneableInterface, ResettableI
     private $cacheCount;
 
     /**
-     * @param Psr16CacheInterface[] $caches          The ordered list of caches used to fetch cached items
-     * @param int                   $defaultLifetime The lifetime of items propagated from lower caches to upper ones
+     * @param CacheInterface[] $caches          The ordered list of caches used to fetch cached items
+     * @param int              $defaultLifetime The lifetime of items propagated from lower caches to upper ones
      */
-    public function __construct(array $caches, int $defaultLifetime = 0)
+    public function __construct(array $caches, $defaultLifetime = 0)
     {
         if (!$caches) {
             throw new InvalidArgumentException('At least one cache must be specified.');
         }
 
         foreach ($caches as $cache) {
-            if (!$cache instanceof Psr16CacheInterface) {
-                throw new InvalidArgumentException(sprintf('The class "%s" does not implement the "%s" interface.', \get_class($cache), Psr16CacheInterface::class));
+            if (!$cache instanceof CacheInterface) {
+                throw new InvalidArgumentException(sprintf('The class "%s" does not implement the "%s" interface.', \get_class($cache), CacheInterface::class));
             }
         }
 
         $this->miss = new \stdClass();
         $this->caches = array_values($caches);
         $this->cacheCount = \count($this->caches);
-        $this->defaultLifetime = 0 < $defaultLifetime ? $defaultLifetime : null;
+        $this->defaultLifetime = 0 < $defaultLifetime ? (int) $defaultLifetime : null;
     }
 
     /**
@@ -249,7 +244,7 @@ class ChainCache implements Psr16CacheInterface, PruneableInterface, ResettableI
     public function reset()
     {
         foreach ($this->caches as $cache) {
-            if ($cache instanceof ResetInterface) {
+            if ($cache instanceof ResettableInterface) {
                 $cache->reset();
             }
         }

vendor/symfony/cache/Simple/DoctrineCache.php

@@ -12,20 +12,17 @@
 namespace Symfony\Component\Cache\Simple;
 
 use Doctrine\Common\Cache\CacheProvider;
-use Symfony\Component\Cache\Adapter\DoctrineAdapter;
 use Symfony\Component\Cache\Traits\DoctrineTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', DoctrineCache::class, DoctrineAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use DoctrineAdapter and type-hint for CacheInterface instead.
- */
 class DoctrineCache extends AbstractCache
 {
     use DoctrineTrait;
 
-    public function __construct(CacheProvider $provider, string $namespace = '', int $defaultLifetime = 0)
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    public function __construct(CacheProvider $provider, $namespace = '', $defaultLifetime = 0)
     {
         parent::__construct('', $defaultLifetime);
         $this->provider = $provider;

vendor/symfony/cache/Simple/FilesystemCache.php

@@ -11,25 +11,20 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\FilesystemAdapter;
-use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
-use Symfony\Component\Cache\Marshaller\MarshallerInterface;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\Traits\FilesystemTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', FilesystemCache::class, FilesystemAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use FilesystemAdapter and type-hint for CacheInterface instead.
- */
 class FilesystemCache extends AbstractCache implements PruneableInterface
 {
     use FilesystemTrait;
 
-    public function __construct(string $namespace = '', int $defaultLifetime = 0, string $directory = null, MarshallerInterface $marshaller = null)
+    /**
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $directory
+     */
+    public function __construct($namespace = '', $defaultLifetime = 0, $directory = null)
     {
-        $this->marshaller = $marshaller ?? new DefaultMarshaller();
         parent::__construct('', $defaultLifetime);
         $this->init($namespace, $directory);
     }

vendor/symfony/cache/Simple/MemcachedCache.php

@@ -11,24 +11,20 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\MemcachedAdapter;
-use Symfony\Component\Cache\Marshaller\MarshallerInterface;
 use Symfony\Component\Cache\Traits\MemcachedTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', MemcachedCache::class, MemcachedAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use MemcachedAdapter and type-hint for CacheInterface instead.
- */
 class MemcachedCache extends AbstractCache
 {
     use MemcachedTrait;
 
     protected $maxIdLength = 250;
 
-    public function __construct(\Memcached $client, string $namespace = '', int $defaultLifetime = 0, MarshallerInterface $marshaller = null)
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    public function __construct(\Memcached $client, $namespace = '', $defaultLifetime = 0)
     {
-        $this->init($client, $namespace, $defaultLifetime, $marshaller);
+        $this->init($client, $namespace, $defaultLifetime);
     }
 }

vendor/symfony/cache/Simple/NullCache.php

@@ -11,16 +11,12 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
-use Symfony\Component\Cache\Adapter\NullAdapter;
-use Symfony\Contracts\Cache\CacheInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', NullCache::class, NullAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
+use Psr\SimpleCache\CacheInterface;
 
 /**
- * @deprecated since Symfony 4.3, use NullAdapter and type-hint for CacheInterface instead.
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class NullCache implements Psr16CacheInterface
+class NullCache implements CacheInterface
 {
     /**
      * {@inheritdoc}

vendor/symfony/cache/Simple/PdoCache.php

@@ -11,17 +11,9 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\PdoAdapter;
-use Symfony\Component\Cache\Marshaller\MarshallerInterface;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\Traits\PdoTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', PdoCache::class, PdoAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use PdoAdapter and type-hint for CacheInterface instead.
- */
 class PdoCache extends AbstractCache implements PruneableInterface
 {
     use PdoTrait;
@@ -33,9 +25,6 @@ class PdoCache extends AbstractCache implements PruneableInterface
      * a Doctrine DBAL Connection or a DSN string that will be used to
      * lazy-connect to the database when the cache is actually used.
      *
-     * When a Doctrine DBAL Connection is passed, the cache table is created
-     * automatically when possible. Otherwise, use the createTable() method.
-     *
      * List of available options:
      *  * db_table: The name of the table [default: cache_items]
      *  * db_id_col: The column where to store the cache id [default: item_id]
@@ -46,14 +35,17 @@ class PdoCache extends AbstractCache implements PruneableInterface
      *  * db_password: The password when lazy-connect [default: '']
      *  * db_connection_options: An array of driver-specific connection options [default: []]
      *
-     * @param \PDO|Connection|string $connOrDsn a \PDO or Connection instance or DSN string or null
+     * @param \PDO|Connection|string $connOrDsn       A \PDO or Connection instance or DSN string or null
+     * @param string                 $namespace
+     * @param int                    $defaultLifetime
+     * @param array                  $options         An associative array of options
      *
      * @throws InvalidArgumentException When first argument is not PDO nor Connection nor string
      * @throws InvalidArgumentException When PDO error mode is not PDO::ERRMODE_EXCEPTION
      * @throws InvalidArgumentException When namespace contains invalid characters
      */
-    public function __construct($connOrDsn, string $namespace = '', int $defaultLifetime = 0, array $options = [], MarshallerInterface $marshaller = null)
+    public function __construct($connOrDsn, $namespace = '', $defaultLifetime = 0, array $options = [])
     {
-        $this->init($connOrDsn, $namespace, $defaultLifetime, $options, $marshaller);
+        $this->init($connOrDsn, $namespace, $defaultLifetime, $options);
     }
 }

vendor/symfony/cache/Simple/PhpArrayCache.php

@@ -11,44 +11,51 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
-use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
+use Psr\SimpleCache\CacheInterface;
 use Symfony\Component\Cache\Exception\InvalidArgumentException;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\ResettableInterface;
 use Symfony\Component\Cache\Traits\PhpArrayTrait;
-use Symfony\Contracts\Cache\CacheInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', PhpArrayCache::class, PhpArrayAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
 
 /**
- * @deprecated since Symfony 4.3, use PhpArrayAdapter and type-hint for CacheInterface instead.
+ * Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
+ * Warmed up items are read-only and run-time discovered items are cached using a fallback adapter.
+ *
+ * @author Titouan Galopin <galopintitouan@gmail.com>
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, ResettableInterface
+class PhpArrayCache implements CacheInterface, PruneableInterface, ResettableInterface
 {
     use PhpArrayTrait;
 
     /**
-     * @param string              $file         The PHP file were values are cached
-     * @param Psr16CacheInterface $fallbackPool A pool to fallback on when an item is not hit
+     * @param string         $file         The PHP file were values are cached
+     * @param CacheInterface $fallbackPool A pool to fallback on when an item is not hit
      */
-    public function __construct(string $file, Psr16CacheInterface $fallbackPool)
+    public function __construct($file, CacheInterface $fallbackPool)
     {
         $this->file = $file;
         $this->pool = $fallbackPool;
+        $this->zendDetectUnicode = filter_var(ini_get('zend.detect_unicode'), \FILTER_VALIDATE_BOOLEAN);
     }
 
     /**
-     * This adapter takes advantage of how PHP stores arrays in its latest versions.
+     * This adapter should only be used on PHP 7.0+ to take advantage of how PHP
+     * stores arrays in its latest versions. This factory method decorates the given
+     * fallback pool with this adapter only if the current PHP version is supported.
      *
      * @param string         $file         The PHP file were values are cached
      * @param CacheInterface $fallbackPool A pool to fallback on when an item is not hit
      *
-     * @return Psr16CacheInterface
+     * @return CacheInterface
      */
-    public static function create($file, Psr16CacheInterface $fallbackPool)
+    public static function create($file, CacheInterface $fallbackPool)
     {
-        return new static($file, $fallbackPool);
+        if (\PHP_VERSION_ID >= 70000) {
+            return new static($file, $fallbackPool);
+        }
+
+        return $fallbackPool;
     }
 
     /**
@@ -62,18 +69,22 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
         if (null === $this->values) {
             $this->initialize();
         }
-        if (!isset($this->keys[$key])) {
+        if (!isset($this->values[$key])) {
             return $this->pool->get($key, $default);
         }
-        $value = $this->values[$this->keys[$key]];
+
+        $value = $this->values[$key];
 
         if ('N;' === $value) {
-            return null;
-        }
-        if ($value instanceof \Closure) {
+            $value = null;
+        } elseif (\is_string($value) && isset($value[2]) && ':' === $value[1]) {
             try {
-                return $value();
-            } catch (\Throwable $e) {
+                $e = null;
+                $value = unserialize($value);
+            } catch (\Error $e) {
+            } catch (\Exception $e) {
+            }
+            if (null !== $e) {
                 return $default;
             }
         }
@@ -89,7 +100,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
         if ($keys instanceof \Traversable) {
             $keys = iterator_to_array($keys, false);
         } elseif (!\is_array($keys)) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
         foreach ($keys as $key) {
             if (!\is_string($key)) {
@@ -115,7 +126,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
             $this->initialize();
         }
 
-        return isset($this->keys[$key]) || $this->pool->has($key);
+        return isset($this->values[$key]) || $this->pool->has($key);
     }
 
     /**
@@ -130,7 +141,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
             $this->initialize();
         }
 
-        return !isset($this->keys[$key]) && $this->pool->delete($key);
+        return !isset($this->values[$key]) && $this->pool->delete($key);
     }
 
     /**
@@ -139,7 +150,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
     public function deleteMultiple($keys)
     {
         if (!\is_array($keys) && !$keys instanceof \Traversable) {
-            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
         }
 
         $deleted = true;
@@ -150,7 +161,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
                 throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
             }
 
-            if (isset($this->keys[$key])) {
+            if (isset($this->values[$key])) {
                 $deleted = false;
             } else {
                 $fallbackKeys[] = $key;
@@ -179,7 +190,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
             $this->initialize();
         }
 
-        return !isset($this->keys[$key]) && $this->pool->set($key, $value, $ttl);
+        return !isset($this->values[$key]) && $this->pool->set($key, $value, $ttl);
     }
 
     /**
@@ -188,7 +199,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
     public function setMultiple($values, $ttl = null)
     {
         if (!\is_array($values) && !$values instanceof \Traversable) {
-            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given', \is_object($values) ? \get_class($values) : \gettype($values)));
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
         }
 
         $saved = true;
@@ -199,7 +210,7 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
                 throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
             }
 
-            if (isset($this->keys[$key])) {
+            if (isset($this->values[$key])) {
                 $saved = false;
             } else {
                 $fallbackValues[$key] = $value;
@@ -218,15 +229,17 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
         $fallbackKeys = [];
 
         foreach ($keys as $key) {
-            if (isset($this->keys[$key])) {
-                $value = $this->values[$this->keys[$key]];
+            if (isset($this->values[$key])) {
+                $value = $this->values[$key];
 
                 if ('N;' === $value) {
                     yield $key => null;
-                } elseif ($value instanceof \Closure) {
+                } elseif (\is_string($value) && isset($value[2]) && ':' === $value[1]) {
                     try {
-                        yield $key => $value();
-                    } catch (\Throwable $e) {
+                        yield $key => unserialize($value);
+                    } catch (\Error $e) {
+                        yield $key => $default;
+                    } catch (\Exception $e) {
                         yield $key => $default;
                     }
                 } else {
@@ -238,7 +251,9 @@ class PhpArrayCache implements Psr16CacheInterface, PruneableInterface, Resettab
         }
 
         if ($fallbackKeys) {
-            yield from $this->pool->getMultiple($fallbackKeys, $default);
+            foreach ($this->pool->getMultiple($fallbackKeys, $default) as $key => $item) {
+                yield $key => $item;
+            }
         }
     }
 }

vendor/symfony/cache/Simple/PhpFilesCache.php

@@ -11,35 +11,31 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\PhpFilesAdapter;
 use Symfony\Component\Cache\Exception\CacheException;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\Traits\PhpFilesTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', PhpFilesCache::class, PhpFilesAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use PhpFilesAdapter and type-hint for CacheInterface instead.
- */
 class PhpFilesCache extends AbstractCache implements PruneableInterface
 {
     use PhpFilesTrait;
 
     /**
-     * @param $appendOnly Set to `true` to gain extra performance when the items stored in this pool never expire.
-     *                    Doing so is encouraged because it fits perfectly OPcache's memory model.
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $directory
      *
      * @throws CacheException if OPcache is not enabled
      */
-    public function __construct(string $namespace = '', int $defaultLifetime = 0, string $directory = null, bool $appendOnly = false)
+    public function __construct($namespace = '', $defaultLifetime = 0, $directory = null)
     {
-        $this->appendOnly = $appendOnly;
-        self::$startTime = self::$startTime ?? $_SERVER['REQUEST_TIME'] ?? time();
+        if (!static::isSupported()) {
+            throw new CacheException('OPcache is not enabled.');
+        }
         parent::__construct('', $defaultLifetime);
         $this->init($namespace, $directory);
-        $this->includeHandler = static function ($type, $msg, $file, $line) {
-            throw new \ErrorException($msg, 0, $type, $file, $line);
-        };
+
+        $e = new \Exception();
+        $this->includeHandler = function () use ($e) { throw $e; };
+        $this->zendDetectUnicode = filter_var(ini_get('zend.detect_unicode'), \FILTER_VALIDATE_BOOLEAN);
     }
 }

vendor/symfony/cache/Simple/Psr6Cache.php

@@ -11,13 +11,231 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Psr16Cache;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" instead.', Psr6Cache::class, Psr16Cache::class), E_USER_DEPRECATED);
+use Psr\Cache\CacheException as Psr6CacheException;
+use Psr\Cache\CacheItemPoolInterface;
+use Psr\SimpleCache\CacheException as SimpleCacheException;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Adapter\AdapterInterface;
+use Symfony\Component\Cache\CacheItem;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\ResettableInterface;
+use Symfony\Component\Cache\Traits\ProxyTrait;
 
 /**
- * @deprecated since Symfony 4.3, use Psr16Cache instead.
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class Psr6Cache extends Psr16Cache
+class Psr6Cache implements CacheInterface, PruneableInterface, ResettableInterface
 {
+    use ProxyTrait;
+
+    private $createCacheItem;
+    private $cacheItemPrototype;
+
+    public function __construct(CacheItemPoolInterface $pool)
+    {
+        $this->pool = $pool;
+
+        if (!$pool instanceof AdapterInterface) {
+            return;
+        }
+        $cacheItemPrototype = &$this->cacheItemPrototype;
+        $createCacheItem = \Closure::bind(
+            static function ($key, $value, $allowInt = false) use (&$cacheItemPrototype) {
+                $item = clone $cacheItemPrototype;
+                $item->key = $allowInt && \is_int($key) ? (string) $key : CacheItem::validateKey($key);
+                $item->value = $value;
+                $item->isHit = false;
+
+                return $item;
+            },
+            null,
+            CacheItem::class
+        );
+        $this->createCacheItem = function ($key, $value, $allowInt = false) use ($createCacheItem) {
+            if (null === $this->cacheItemPrototype) {
+                $this->get($allowInt && \is_int($key) ? (string) $key : $key);
+            }
+            $this->createCacheItem = $createCacheItem;
+
+            return $createCacheItem($key, $value, $allowInt);
+        };
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        try {
+            $item = $this->pool->getItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        if (null === $this->cacheItemPrototype) {
+            $this->cacheItemPrototype = clone $item;
+            $this->cacheItemPrototype->set(null);
+        }
+
+        return $item->isHit() ? $item->get() : $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        try {
+            if (null !== $f = $this->createCacheItem) {
+                $item = $f($key, $value);
+            } else {
+                $item = $this->pool->getItem($key)->set($value);
+            }
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        if (null !== $ttl) {
+            $item->expiresAfter($ttl);
+        }
+
+        return $this->pool->save($item);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        try {
+            return $this->pool->deleteItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        return $this->pool->clear();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        try {
+            $items = $this->pool->getItems($keys);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        $values = [];
+
+        foreach ($items as $key => $item) {
+            $values[$key] = $item->isHit() ? $item->get() : $default;
+        }
+
+        return $values;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        $valuesIsArray = \is_array($values);
+        if (!$valuesIsArray && !$values instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
+        }
+        $items = [];
+
+        try {
+            if (null !== $f = $this->createCacheItem) {
+                $valuesIsArray = false;
+                foreach ($values as $key => $value) {
+                    $items[$key] = $f($key, $value, true);
+                }
+            } elseif ($valuesIsArray) {
+                $items = [];
+                foreach ($values as $key => $value) {
+                    $items[] = (string) $key;
+                }
+                $items = $this->pool->getItems($items);
+            } else {
+                foreach ($values as $key => $value) {
+                    if (\is_int($key)) {
+                        $key = (string) $key;
+                    }
+                    $items[$key] = $this->pool->getItem($key)->set($value);
+                }
+            }
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        $ok = true;
+
+        foreach ($items as $key => $item) {
+            if ($valuesIsArray) {
+                $item->set($values[$key]);
+            }
+            if (null !== $ttl) {
+                $item->expiresAfter($ttl);
+            }
+            $ok = $this->pool->saveDeferred($item) && $ok;
+        }
+
+        return $this->pool->commit() && $ok;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        try {
+            return $this->pool->deleteItems($keys);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        try {
+            return $this->pool->hasItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
 }

vendor/symfony/cache/Simple/RedisCache.php

@@ -11,25 +11,19 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Symfony\Component\Cache\Adapter\RedisAdapter;
-use Symfony\Component\Cache\Marshaller\MarshallerInterface;
 use Symfony\Component\Cache\Traits\RedisTrait;
-use Symfony\Contracts\Cache\CacheInterface;
 
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', RedisCache::class, RedisAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
-
-/**
- * @deprecated since Symfony 4.3, use RedisAdapter and type-hint for CacheInterface instead.
- */
 class RedisCache extends AbstractCache
 {
     use RedisTrait;
 
     /**
-     * @param \Redis|\RedisArray|\RedisCluster|\Predis\ClientInterface $redisClient
+     * @param \Redis|\RedisArray|\RedisCluster|\Predis\Client $redisClient
+     * @param string                                          $namespace
+     * @param int                                             $defaultLifetime
      */
-    public function __construct($redisClient, string $namespace = '', int $defaultLifetime = 0, MarshallerInterface $marshaller = null)
+    public function __construct($redisClient, $namespace = '', $defaultLifetime = 0)
     {
-        $this->init($redisClient, $namespace, $defaultLifetime, $marshaller);
+        $this->init($redisClient, $namespace, $defaultLifetime);
     }
 }

vendor/symfony/cache/Simple/TraceableCache.php

@@ -11,24 +11,22 @@
 
 namespace Symfony\Component\Cache\Simple;
 
-use Psr\SimpleCache\CacheInterface as Psr16CacheInterface;
+use Psr\SimpleCache\CacheInterface;
 use Symfony\Component\Cache\PruneableInterface;
 use Symfony\Component\Cache\ResettableInterface;
-use Symfony\Contracts\Cache\CacheInterface;
-use Symfony\Contracts\Service\ResetInterface;
-
-@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" and type-hint for "%s" instead.', TraceableCache::class, TraceableAdapter::class, CacheInterface::class), E_USER_DEPRECATED);
 
 /**
- * @deprecated since Symfony 4.3, use TraceableAdapter and type-hint for CacheInterface instead.
+ * An adapter that collects data about all cache calls.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
  */
-class TraceableCache implements Psr16CacheInterface, PruneableInterface, ResettableInterface
+class TraceableCache implements CacheInterface, PruneableInterface, ResettableInterface
 {
     private $pool;
     private $miss;
     private $calls = [];
 
-    public function __construct(Psr16CacheInterface $pool)
+    public function __construct(CacheInterface $pool)
     {
         $this->pool = $pool;
         $this->miss = new \stdClass();
@@ -202,7 +200,7 @@ class TraceableCache implements Psr16CacheInterface, PruneableInterface, Resetta
      */
     public function reset()
     {
-        if (!$this->pool instanceof ResetInterface) {
+        if (!$this->pool instanceof ResettableInterface) {
             return;
         }
         $event = $this->start(__FUNCTION__);