diff --git a/.gitignore b/.gitignore
index 46466ef9..5dee4506 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 /laminas-mkdoc-theme/
 /phpunit.xml
 /vendor/
+/.phpcs-cache
diff --git a/composer.json b/composer.json
index 90d83b2f..d6d54d18 100644
--- a/composer.json
+++ b/composer.json
@@ -34,7 +34,7 @@
     },
     "require-dev": {
         "container-interop/container-interop": "^1.2.0",
-        "laminas/laminas-coding-standard": "~1.0.0",
+        "laminas/laminas-coding-standard": "^2",
         "laminas/laminas-servicemanager": "^3.4",
         "mikey179/vfsstream": "^1.6.7",
         "phpstan/phpstan": "^0.12",
diff --git a/phpcs.xml b/phpcs.xml
index 5afc06b1..c6e2a6d0 100644
--- a/phpcs.xml
+++ b/phpcs.xml
@@ -1,6 +1,15 @@
 <?xml version="1.0"?>
-<ruleset name="Laminas Coding Standard">
-    <rule ref="./vendor/laminas/laminas-coding-standard/ruleset.xml"/>
+<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
+
+    <arg name="basepath" value="."/>
+    <arg name="cache" value=".phpcs-cache"/>
+    <arg name="colors"/>
+    <arg name="extensions" value="php"/>
+    <arg name="parallel" value="80"/>
+    
+    <!-- Show progress -->
+    <arg value="p"/>
+
 
     <!--
         Don't make it bail at the file level deprecation of AbstactInjection (Intented side effect).
@@ -18,4 +27,5 @@
     <file>test</file>
 
     <exclude-pattern><![CDATA[*/test/_files/*]]></exclude-pattern>
+    <rule ref="LaminasCodingStandard"/>
 </ruleset>
diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
index d3e00d86..2335f9c9 100644
--- a/phpstan-baseline.neon
+++ b/phpstan-baseline.neon
@@ -1,10 +1,5 @@
 parameters:
 	ignoreErrors:
-		-
-			message: "#^Method Laminas\\\\Di\\\\CodeGenerator\\\\AbstractInjector\\:\\:getFactory\\(\\) has parameter \\$type with no typehint specified\\.$#"
-			count: 1
-			path: src/CodeGenerator/AbstractInjector.php
-
 		-
 			message: "#^Method Laminas\\\\Di\\\\CodeGenerator\\\\AbstractInjector\\:\\:create\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
 			count: 1
@@ -126,17 +121,22 @@ parameters:
 			path: src/Config.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:setParameters\\(\\) has no return typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:setParameters\\(\\) has parameter \\$params with no value type specified in iterable type array\\.$#"
 			count: 1
 			path: src/Config.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:setParameters\\(\\) has parameter \\$params with no value type specified in iterable type array\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:ensureArrayOrArrayAccess\\(\\) has parameter \\$options with generic interface ArrayAccess but does not specify its types\\: TKey, TValue$#"
 			count: 1
 			path: src/Config.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:ensureArrayOrArrayAccess\\(\\) has parameter \\$options with no typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Config\\:\\:ensureArrayOrArrayAccess\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
+			count: 1
+			path: src/Config.php
+
+		-
+			message: "#^Result of && is always false\\.$#"
 			count: 1
 			path: src/Config.php
 
@@ -165,43 +165,28 @@ parameters:
 			count: 1
 			path: src/ConfigProvider.php
 
-		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:canCreate\\(\\) has no return typehint specified\\.$#"
-			count: 1
-			path: src/Container/AutowireFactory.php
-
-		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:canCreate\\(\\) has parameter \\$requestedName with no typehint specified\\.$#"
-			count: 1
-			path: src/Container/AutowireFactory.php
-
-		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:create\\(\\) has no return typehint specified\\.$#"
-			count: 1
-			path: src/Container/AutowireFactory.php
-
 		-
 			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:create\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
 			count: 1
 			path: src/Container/AutowireFactory.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:__invoke\\(\\) has no return typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:__invoke\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
 			count: 1
 			path: src/Container/AutowireFactory.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:__invoke\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Container\\\\ServiceManager\\\\AutowireFactory\\:\\:__invoke\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
 			count: 1
-			path: src/Container/AutowireFactory.php
+			path: src/Container/ServiceManager/AutowireFactory.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\AutowireFactory\\:\\:__invoke\\(\\) has parameter \\$requestedName with no typehint specified\\.$#"
-			count: 1
-			path: src/Container/AutowireFactory.php
+			message: "#^Return type \\(bool\\) of method Laminas\\\\Di\\\\Container\\\\ServiceManager\\\\AutowireFactory\\:\\:__invoke\\(\\) should be compatible with return type \\(object\\) of method Laminas\\\\ServiceManager\\\\Factory\\\\FactoryInterface\\:\\:__invoke\\(\\)$#"
+			count: 2
+			path: src/Container/ServiceManager/AutowireFactory.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\Container\\\\ServiceManager\\\\AutowireFactory\\:\\:__invoke\\(\\) has parameter \\$options with no value type specified in iterable type array\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\Container\\\\ServiceManager\\\\AutowireFactory\\:\\:__invoke\\(\\) should return bool but returns object\\.$#"
 			count: 1
 			path: src/Container/ServiceManager/AutowireFactory.php
 
@@ -230,11 +215,21 @@ parameters:
 			count: 1
 			path: src/Definition/Reflection/ClassDefinition.php
 
+		-
+			message: "#^Method Laminas\\\\Di\\\\Definition\\\\Reflection\\\\ClassDefinition\\:\\:reflectSupertypes\\(\\) has no return typehint specified\\.$#"
+			count: 1
+			path: src/Definition/Reflection/ClassDefinition.php
+
 		-
 			message: "#^Method Laminas\\\\Di\\\\Definition\\\\Reflection\\\\ClassDefinition\\:\\:getReflection\\(\\) return type with generic class ReflectionClass does not specify its types\\: T$#"
 			count: 1
 			path: src/Definition/Reflection/ClassDefinition.php
 
+		-
+			message: "#^Method Laminas\\\\Di\\\\Definition\\\\Reflection\\\\ClassDefinition\\:\\:reflectParameters\\(\\) has no return typehint specified\\.$#"
+			count: 1
+			path: src/Definition/Reflection/ClassDefinition.php
+
 		-
 			message: "#^Call to an undefined method ReflectionType\\:\\:getName\\(\\)\\.$#"
 			count: 1
@@ -276,17 +271,12 @@ parameters:
 			path: src/InjectorInterface.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:__construct\\(\\) has parameter \\$config with no typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:__construct\\(\\) has parameter \\$config with generic interface ArrayAccess but does not specify its types\\: TKey, TValue$#"
 			count: 1
 			path: src/LegacyConfig.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:prepareParametersArray\\(\\) has no return typehint specified\\.$#"
-			count: 1
-			path: src/LegacyConfig.php
-
-		-
-			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:prepareParametersArray\\(\\) has parameter \\$parameters with no typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:__construct\\(\\) has parameter \\$config with no value type specified in iterable type array\\.$#"
 			count: 1
 			path: src/LegacyConfig.php
 
@@ -296,7 +286,7 @@ parameters:
 			path: src/LegacyConfig.php
 
 		-
-			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:configureInstance\\(\\) has parameter \\$config with no typehint specified\\.$#"
+			message: "#^Method Laminas\\\\Di\\\\LegacyConfig\\:\\:configureInstance\\(\\) has parameter \\$config with no value type specified in iterable type iterable\\.$#"
 			count: 1
 			path: src/LegacyConfig.php
 
@@ -340,8 +330,3 @@ parameters:
 			count: 1
 			path: src/Resolver/ValueInjection.php
 
-		-
-			message: "#^Method Laminas\\\\Di\\\\Resolver\\\\ValueInjection\\:\\:getValue\\(\\) has no return typehint specified\\.$#"
-			count: 1
-			path: src/Resolver/ValueInjection.php
-
diff --git a/src/CodeGenerator/AbstractInjector.php b/src/CodeGenerator/AbstractInjector.php
index c35080ab..91f9fb7a 100644
--- a/src/CodeGenerator/AbstractInjector.php
+++ b/src/CodeGenerator/AbstractInjector.php
@@ -19,32 +19,24 @@
  */
 abstract class AbstractInjector implements InjectorInterface
 {
-    /**
-     * @var string[]|FactoryInterface[]
-     */
+    /** @var string[]|FactoryInterface[] */
     protected $factories = [];
 
-    /**
-     * @var FactoryInterface[]
-     */
+    /** @var FactoryInterface[] */
     private $factoryInstances = [];
 
-    /**
-     * @var ContainerInterface
-     */
+    /** @var ContainerInterface */
     private $container;
 
-    /**
-     * @var InjectorInterface
-     */
+    /** @var InjectorInterface */
     private $injector;
 
     /**
      * {@inheritDoc}
      */
-    public function __construct(InjectorInterface $injector, ContainerInterface $container = null)
+    public function __construct(InjectorInterface $injector, ?ContainerInterface $container = null)
     {
-        $this->injector = $injector;
+        $this->injector  = $injector;
         $this->container = $container ?: new DefaultContainer($this);
 
         $this->loadFactoryList();
@@ -53,32 +45,33 @@ public function __construct(InjectorInterface $injector, ContainerInterface $con
     /**
      * Init factory list
      */
-    abstract protected function loadFactoryList() : void;
+    abstract protected function loadFactoryList(): void;
 
-    private function setFactory(string $type, FactoryInterface $factory) : void
+    private function setFactory(string $type, FactoryInterface $factory): void
     {
         $this->factoryInstances[$type] = $factory;
     }
-
-    private function getFactory($type) : FactoryInterface
+    
+    private function getFactory(string $type): FactoryInterface
     {
         if (isset($this->factoryInstances[$type])) {
             return $this->factoryInstances[$type];
         }
 
         $factoryClass = $this->factories[$type];
-        $factory = ($factoryClass instanceof FactoryInterface) ? $factoryClass : new $factoryClass();
+        $factory      = $factoryClass instanceof FactoryInterface ? $factoryClass : new $factoryClass();
 
         $this->setFactory($type, $factory);
 
         return $factory;
     }
 
-    public function canCreate(string $name) : bool
+    public function canCreate(string $name): bool
     {
-        return (isset($this->factories[$name]) || $this->injector->canCreate($name));
+        return isset($this->factories[$name]) || $this->injector->canCreate($name);
     }
 
+    /** @return mixed */
     public function create(string $name, array $options = [])
     {
         if (isset($this->factories[$name])) {
diff --git a/src/CodeGenerator/AutoloadGenerator.php b/src/CodeGenerator/AutoloadGenerator.php
index 9e80e7f0..2e8a5668 100644
--- a/src/CodeGenerator/AutoloadGenerator.php
+++ b/src/CodeGenerator/AutoloadGenerator.php
@@ -16,6 +16,7 @@
 
 use function array_keys;
 use function array_map;
+use function assert;
 use function file_get_contents;
 use function implode;
 use function is_string;
@@ -29,11 +30,9 @@ class AutoloadGenerator
     use GeneratorTrait;
 
     private const CLASS_TEMPLATE = __DIR__ . '/../../templates/autoloader-class.template';
-    private const FILE_TEMPLATE = __DIR__ . '/../../templates/autoloader-file.template';
+    private const FILE_TEMPLATE  = __DIR__ . '/../../templates/autoloader-file.template';
 
-    /**
-     * @var string
-     */
+    /** @var string */
     private $namespace;
 
     public function __construct(string $namespace)
@@ -41,7 +40,7 @@ public function __construct(string $namespace)
         $this->namespace = $namespace;
     }
 
-    private function writeFile(string $filename, string $code) : void
+    private function writeFile(string $filename, string $code): void
     {
         try {
             $file = new SplFileObject($filename, 'w');
@@ -51,7 +50,7 @@ private function writeFile(string $filename, string $code) : void
         }
     }
 
-    private function buildFromTemplate(string $templateFile, string $outputFile, array $replacements) : void
+    private function buildFromTemplate(string $templateFile, string $outputFile, array $replacements): void
     {
         $template = file_get_contents($templateFile);
 
@@ -66,7 +65,7 @@ private function buildFromTemplate(string $templateFile, string $outputFile, arr
         );
     }
 
-    private function generateClassmapCode(array &$classmap) : string
+    private function generateClassmapCode(array &$classmap): string
     {
         $lines = array_map(
             function (string $class, string $file): string {
@@ -84,15 +83,15 @@ function (string $class, string $file): string {
         return implode($indentation, $lines);
     }
 
-    private function generateAutoloaderClass(array &$classmap) : void
+    private function generateAutoloaderClass(array &$classmap): void
     {
         $this->buildFromTemplate(self::CLASS_TEMPLATE, 'Autoloader.php', [
             '%namespace%' => $this->namespace ? sprintf("namespace %s;\n", $this->namespace) : '',
-            '%classmap%' => $this->generateClassmapCode($classmap),
+            '%classmap%'  => $this->generateClassmapCode($classmap),
         ]);
     }
 
-    private function generateAutoloadFile() : void
+    private function generateAutoloadFile(): void
     {
         $this->buildFromTemplate(self::FILE_TEMPLATE, 'autoload.php', [
             '%namespace%' => $this->namespace ? sprintf("namespace %s;\n", $this->namespace) : '',
@@ -102,7 +101,7 @@ private function generateAutoloadFile() : void
     /**
      * @param string[] $classmap
      */
-    public function generate(array &$classmap) : void
+    public function generate(array &$classmap): void
     {
         $this->ensureOutputDirectory();
         $this->generateAutoloaderClass($classmap);
diff --git a/src/CodeGenerator/FactoryGenerator.php b/src/CodeGenerator/FactoryGenerator.php
index 8c4cf04f..9647e827 100644
--- a/src/CodeGenerator/FactoryGenerator.php
+++ b/src/CodeGenerator/FactoryGenerator.php
@@ -17,11 +17,19 @@
 use Laminas\Di\Resolver\TypeInjection;
 use SplFileObject;
 
+use function assert;
+use function dirname;
 use function file_get_contents;
+use function implode;
 use function is_string;
+use function preg_replace;
+use function sprintf;
+use function str_repeat;
+use function str_replace;
 use function strrpos;
 use function strtr;
 use function substr;
+use function var_export;
 
 /**
  * Generates factory classes
@@ -30,9 +38,9 @@ class FactoryGenerator
 {
     use GeneratorTrait;
 
-    private const INDENTATION_SPACES = 4;
-    private const TEMPLATE_FILE = __DIR__ . '/../../templates/factory.template';
-    private const PARAMETERS_TEMPLATE = <<< '__CODE__'
+    private const INDENTATION_SPACES  = 4;
+    private const TEMPLATE_FILE       = __DIR__ . '/../../templates/factory.template';
+    private const PARAMETERS_TEMPLATE = <<<'__CODE__'
 
         $args = empty($options)
             ? [
@@ -44,45 +52,34 @@ class FactoryGenerator
 
 __CODE__;
 
-    /**
-     * @var string
-     */
+    /** @var string */
     private $namespace;
 
-    /**
-     * @var DependencyResolverInterface
-     */
+    /** @var DependencyResolverInterface */
     private $resolver;
 
-    /**
-     * @var ConfigInterface
-     */
+    /** @var ConfigInterface */
     private $config;
 
-    /**
-     * @var array
-     */
+    /** @var array */
     private $classmap = [];
 
-    /**
-     * @param DependencyResolverInterface $resolver
-     */
     public function __construct(
         ConfigInterface $config,
         DependencyResolverInterface $resolver,
         ?string $namespace = null
     ) {
-        $this->resolver = $resolver;
-        $this->config = $config;
+        $this->resolver  = $resolver;
+        $this->config    = $config;
         $this->namespace = $namespace ?: 'LaminasDiGenerated';
     }
 
-    protected function buildClassName(string $name) : string
+    protected function buildClassName(string $name): string
     {
         return preg_replace('~[^a-z0-9\\\\]+~i', '_', $name) . 'Factory';
     }
 
-    protected function buildFileName(string $name) : string
+    protected function buildFileName(string $name): string
     {
         return str_replace('\\', '/', $this->buildClassName($name)) . '.php';
     }
@@ -90,7 +87,7 @@ protected function buildFileName(string $name) : string
     /**
      * @return string[] The resulting parts as [$namspace, $unqualifiedClassName]
      */
-    private function splitFullyQualifiedClassName(string $class) : array
+    private function splitFullyQualifiedClassName(string $class): array
     {
         $pos = strrpos($class, '\\');
 
@@ -98,13 +95,13 @@ private function splitFullyQualifiedClassName(string $class) : array
             return ['', $class];
         }
 
-        $namespace = substr($class, 0, $pos);
+        $namespace            = substr($class, 0, $pos);
         $unqualifiedClassName = substr($class, $pos + 1);
 
         return [$namespace, $unqualifiedClassName];
     }
 
-    private function getClassName(string $type) : string
+    private function getClassName(string $type): string
     {
         if ($this->config->isAlias($type)) {
             return $this->config->getClassForAlias($type) ?? $type;
@@ -116,7 +113,7 @@ private function getClassName(string $type) : string
     /**
      * @param InjectionInterface[] $injections
      */
-    private function canGenerateForParameters(iterable $injections) : bool
+    private function canGenerateForParameters(iterable $injections): bool
     {
         foreach ($injections as $injection) {
             if (! $injection->isExportable()) {
@@ -132,9 +129,9 @@ private function canGenerateForParameters(iterable $injections) : bool
      *
      * @param InjectionInterface[] $injections
      */
-    private function buildParametersCode(iterable $injections) : ?string
+    private function buildParametersCode(iterable $injections): ?string
     {
-        $withOptions = [];
+        $withOptions    = [];
         $withoutOptions = [];
 
         foreach ($injections as $name => $injection) {
@@ -172,11 +169,11 @@ private function buildParametersCode(iterable $injections) : ?string
     }
 
     /**
-     * @throws RuntimeException When generating the factory failed
+     * @throws RuntimeException When generating the factory failed.
      */
     public function generate(string $class): string
     {
-        $className = $this->getClassName($class);
+        $className  = $this->getClassName($class);
         $injections = $this->resolver->resolveParameters($className);
 
         if (! $this->canGenerateForParameters($injections)) {
@@ -187,10 +184,10 @@ public function generate(string $class): string
             ));
         }
 
-        $paramsCode = $this->buildParametersCode($injections);
-        $absoluteClassName = '\\' . $className;
-        $factoryClassName = $this->namespace . '\\' . $this->buildClassName($class);
-        list($namespace, $unqualifiedFactoryClassName) = $this->splitFullyQualifiedClassName($factoryClassName);
+        $paramsCode                                = $this->buildParametersCode($injections);
+        $absoluteClassName                         = '\\' . $className;
+        $factoryClassName                          = $this->namespace . '\\' . $this->buildClassName($class);
+        [$namespace, $unqualifiedFactoryClassName] = $this->splitFullyQualifiedClassName($factoryClassName);
 
         $filename = $this->buildFileName($class);
         $filepath = $this->outputDirectory . '/' . $filename;
@@ -201,12 +198,12 @@ public function generate(string $class): string
         $code = strtr(
             $template,
             [
-                '%class%' => $absoluteClassName,
-                '%namespace%' => $namespace ? "namespace $namespace;\n" : '',
-                '%factory_class%' => $unqualifiedFactoryClassName,
+                '%class%'                => $absoluteClassName,
+                '%namespace%'            => $namespace ? "namespace $namespace;\n" : '',
+                '%factory_class%'        => $unqualifiedFactoryClassName,
                 '%options_to_args_code%' => $paramsCode,
                 '%use_array_key_exists%' => $paramsCode ? "\nuse function array_key_exists;" : '',
-                '%args%' => $paramsCode ? '...$args' : '',
+                '%args%'                 => $paramsCode ? '...$args' : '',
             ]
         );
 
@@ -219,10 +216,7 @@ public function generate(string $class): string
         return $factoryClassName;
     }
 
-    /**
-     * @return array
-     */
-    public function getClassmap() : array
+    public function getClassmap(): array
     {
         return $this->classmap;
     }
diff --git a/src/CodeGenerator/FactoryInterface.php b/src/CodeGenerator/FactoryInterface.php
index bf4dfed1..5c880517 100644
--- a/src/CodeGenerator/FactoryInterface.php
+++ b/src/CodeGenerator/FactoryInterface.php
@@ -17,7 +17,6 @@ interface FactoryInterface
     /**
      * Create an instance
      *
-     * @param array $options
      * @return object
      */
     public function create(ContainerInterface $container, array $options);
diff --git a/src/CodeGenerator/GeneratorTrait.php b/src/CodeGenerator/GeneratorTrait.php
index f8c28f96..e9a8239a 100644
--- a/src/CodeGenerator/GeneratorTrait.php
+++ b/src/CodeGenerator/GeneratorTrait.php
@@ -13,27 +13,26 @@
 use Laminas\Di\Exception\GenerateCodeException;
 use Laminas\Di\Exception\LogicException;
 
+use function is_dir;
+use function mkdir;
+use function sprintf;
+
 /**
  * Trait with generic generator utility methods
  */
 trait GeneratorTrait
 {
-    /**
-     * @var int
-     */
+    /** @var int */
     protected $mode = 0755;
 
-    /**
-     * @var string
-     */
-    protected $outputDirectory = null;
+    /** @var string */
+    protected $outputDirectory;
 
     /**
      * Ensure that the given directory exists
      *
      * This will check the path at $dir if it exsits and if it is a directory
      *
-     * @param string $dir
      * @throws GenerateCodeException
      */
     protected function ensureDirectory(string $dir)
@@ -69,11 +68,11 @@ protected function ensureOutputDirectory()
      *
      * The compiler will attempt to create this directory if it does not exist
      *
-     * @param string $dir The path to the output directory
-     * @param int $mode The creation mode for the directory
-     * @return self Provides a fluent interface
+     * @param string   $dir The path to the output directory
+     * @param null|int $mode The creation mode for the directory
+     * @return $this Provides a fluent interface
      */
-    public function setOutputDirectory(string $dir, ?int $mode = null) : self
+    public function setOutputDirectory(string $dir, ?int $mode = null): self
     {
         $this->outputDirectory = $dir;
 
@@ -84,7 +83,7 @@ public function setOutputDirectory(string $dir, ?int $mode = null) : self
         return $this;
     }
 
-    public function getOutputDirectory() : ?string
+    public function getOutputDirectory(): ?string
     {
         return $this->outputDirectory;
     }
diff --git a/src/CodeGenerator/InjectorGenerator.php b/src/CodeGenerator/InjectorGenerator.php
index eacf9ed7..a74fa20a 100644
--- a/src/CodeGenerator/InjectorGenerator.php
+++ b/src/CodeGenerator/InjectorGenerator.php
@@ -20,9 +20,11 @@
 
 use function array_keys;
 use function array_map;
+use function assert;
 use function file_get_contents;
 use function implode;
 use function is_string;
+use function sprintf;
 use function str_repeat;
 use function strtr;
 use function var_export;
@@ -39,70 +41,55 @@ class InjectorGenerator
     use GeneratorTrait;
 
     private const FACTORY_LIST_TEMPLATE = __DIR__ . '/../../templates/factory-list.template';
-    private const INJECTOR_TEMPLATE = __DIR__ . '/../../templates/injector.template';
-    private const INDENTATION_SPACES = 4;
+    private const INJECTOR_TEMPLATE     = __DIR__ . '/../../templates/injector.template';
+    private const INDENTATION_SPACES    = 4;
 
-    /**
-     * @var ConfigInterface
-     */
+    /** @var ConfigInterface */
     private $config;
 
-    /**
-     * @var DependencyResolverInterface
-     */
-    private $resolver;
-
     /**
      * @deprecated
+     *
      * @var DefinitionInterface
      */
     protected $definition;
 
-    /**
-     * @var string
-     */
+    /** @var string */
     private $namespace;
 
-    /**
-     * @var FactoryGenerator
-     */
+    /** @var FactoryGenerator */
     private $factoryGenerator;
 
-    /**
-     * @var AutoloadGenerator
-     */
+    /** @var AutoloadGenerator */
     private $autoloadGenerator;
 
-    /**
-     * @var LoggerInterface
-     */
+    /** @var LoggerInterface */
     private $logger;
 
     /**
      * Constructs the compiler instance
      *
-     * @param ConfigInterface $config The configuration to compile from
+     * @param ConfigInterface             $config The configuration to compile from
      * @param DependencyResolverInterface $resolver The resolver to utilize
-     * @param string|null $namespace Namespace to use for generated class; defaults
-     *     to Laminas\Di\Generated.
-     * @param LoggerInterface|null $logger An optional logger instance to log failures
-     *     and processed classes.
+     * @param string|null                 $namespace Namespace to use for generated class; defaults
+     *                     to Laminas\Di\Generated.
+     * @param LoggerInterface|null        $logger An optional logger instance to log failures
+     *            and processed classes.
      */
     public function __construct(
         ConfigInterface $config,
         DependencyResolverInterface $resolver,
-        string $namespace = null,
-        LoggerInterface $logger = null
+        ?string $namespace = null,
+        ?LoggerInterface $logger = null
     ) {
-        $this->config = $config;
-        $this->resolver = $resolver;
-        $this->namespace = $namespace ? : 'Laminas\Di\Generated';
-        $this->factoryGenerator = new FactoryGenerator($config, $resolver, $this->namespace . '\Factory');
+        $this->config            = $config;
+        $this->namespace         = $namespace ? : 'Laminas\Di\Generated';
+        $this->factoryGenerator  = new FactoryGenerator($config, $resolver, $this->namespace . '\Factory');
         $this->autoloadGenerator = new AutoloadGenerator($this->namespace);
-        $this->logger = $logger ?? new NullLogger();
+        $this->logger            = $logger ?? new NullLogger();
     }
 
-    private function buildFromTemplate(string $templateFile, string $outputFile, array $replacements) : void
+    private function buildFromTemplate(string $templateFile, string $outputFile, array $replacements): void
     {
         $template = file_get_contents($templateFile);
 
@@ -115,7 +102,7 @@ private function buildFromTemplate(string $templateFile, string $outputFile, arr
         $file->fflush();
     }
 
-    private function generateInjector() : void
+    private function generateInjector(): void
     {
         $this->buildFromTemplate(
             self::INJECTOR_TEMPLATE,
@@ -126,11 +113,11 @@ private function generateInjector() : void
         );
     }
 
-    private function generateFactoryList(array $factories) : void
+    private function generateFactoryList(array $factories): void
     {
         $indentation = sprintf("\n%s", str_repeat(' ', self::INDENTATION_SPACES));
-        $codeLines = array_map(
-            function (string $key, string $value) : string {
+        $codeLines   = array_map(
+            function (string $key, string $value): string {
                 return sprintf('%s => %s,', var_export($key, true), var_export($value, true));
             },
             array_keys($factories),
@@ -142,7 +129,7 @@ function (string $key, string $value) : string {
         ]);
     }
 
-    private function generateTypeFactory(string $class, array &$factories) : void
+    private function generateTypeFactory(string $class, array &$factories): void
     {
         if (isset($factories[$class])) {
             return;
@@ -165,13 +152,14 @@ private function generateTypeFactory(string $class, array &$factories) : void
         }
     }
 
-    private function generateAutoload() : void
+    private function generateAutoload(): void
     {
         $addFactoryPrefix = function ($value) {
             return 'Factory/' . $value;
         };
 
         $classmap = array_map($addFactoryPrefix, $this->factoryGenerator->getClassmap());
+        
         $classmap[$this->namespace . '\\GeneratedInjector'] = 'GeneratedInjector.php';
 
         $this->autoloadGenerator->generate($classmap);
@@ -180,7 +168,7 @@ private function generateAutoload() : void
     /**
      * Returns the namespace this generator uses
      */
-    public function getNamespace() : string
+    public function getNamespace(): string
     {
         return $this->namespace;
     }
@@ -192,7 +180,7 @@ public function getNamespace() : string
      *
      * @param string[] $classes
      */
-    public function generate($classes = []) : void
+    public function generate($classes = []): void
     {
         $this->ensureOutputDirectory();
         $this->factoryGenerator->setOutputDirectory($this->outputDirectory . '/Factory');
diff --git a/src/Config.php b/src/Config.php
index 6525032d..b48d738a 100644
--- a/src/Config.php
+++ b/src/Config.php
@@ -12,6 +12,9 @@
 
 use ArrayAccess;
 
+use function array_keys;
+use function class_exists;
+use function interface_exists;
 use function is_array;
 
 /**
@@ -79,14 +82,10 @@
  */
 class Config implements ConfigInterface
 {
-    /**
-     * @var array
-     */
+    /** @var array */
     protected $preferences = [];
 
-    /**
-     * @var array
-     */
+    /** @var array */
     protected $types = [];
 
     /**
@@ -101,14 +100,14 @@ class Config implements ConfigInterface
     public function __construct($options = [])
     {
         $this->ensureArrayOrArrayAccess($options);
-        $this->preferences = $this->getDataFromArray($options, 'preferences')?: [];
-        $this->types = $this->getDataFromArray($options, 'types')?: [];
+        $this->preferences = $this->getDataFromArray($options, 'preferences') ?: [];
+        $this->types       = $this->getDataFromArray($options, 'types') ?: [];
     }
 
     /**
      * @param array|ArrayAccess $data
      */
-    private function getDataFromArray($data, string $key) : array
+    private function getDataFromArray($data, string $key): array
     {
         $result = $data[$key] ?? [];
         return is_array($result) ? $result : [];
@@ -116,9 +115,10 @@ private function getDataFromArray($data, string $key) : array
 
     /**
      * {@inheritDoc}
+     *
      * @see Laminas\Di\ConfigInterface::getClassForAlias()
      */
-    public function getClassForAlias(string $name) : ?string
+    public function getClassForAlias(string $name): ?string
     {
         if (isset($this->types[$name]['typeOf'])) {
             return $this->types[$name]['typeOf'];
@@ -133,7 +133,7 @@ public function getClassForAlias(string $name) : ?string
      * @param string $type The alias or class name
      * @return array The configured parameters
      */
-    public function getParameters(string $type) : array
+    public function getParameters(string $type): array
     {
         if (! isset($this->types[$type]['parameters']) || ! is_array($this->types[$type]['parameters'])) {
             return [];
@@ -144,7 +144,10 @@ public function getParameters(string $type) : array
 
     /**
      * {@inheritDoc}
+     *
      * @see Laminas\Di\ConfigInterface::setParameters()
+     *
+     * @return $this
      */
     public function setParameters(string $type, array $params)
     {
@@ -152,12 +155,7 @@ public function setParameters(string $type, array $params)
         return $this;
     }
 
-    /**
-     * @param string $type
-     * @param string $context
-     * @return string|null
-     */
-    public function getTypePreference(string $type, ?string $context = null) : ?string
+    public function getTypePreference(string $type, ?string $context = null): ?string
     {
         if ($context) {
             return $this->getTypePreferenceForClass($type, $context);
@@ -168,47 +166,45 @@ public function getTypePreference(string $type, ?string $context = null) : ?stri
         }
 
         $preference = $this->preferences[$type];
-        return ($preference != '') ? (string)$preference : null;
+        return $preference !== '' ? (string) $preference : null;
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see Laminas\Di\ConfigInterface::getTypePreferencesForClass()
      */
-    private function getTypePreferenceForClass(string $type, ?string $context) : ?string
+    private function getTypePreferenceForClass(string $type, ?string $context): ?string
     {
         if (! isset($this->types[$context]['preferences'][$type])) {
             return null;
         }
 
         $preference = $this->types[$context]['preferences'][$type];
-        return ($preference != '') ? (string)$preference : null;
+        return $preference !== '' ? (string) $preference : null;
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see ConfigInterface::isAlias()
      */
-    public function isAlias(string $name) : bool
+    public function isAlias(string $name): bool
     {
         return isset($this->types[$name]['typeOf']);
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see ConfigInterface::getConfiguredTypeNames()
      */
-    public function getConfiguredTypeNames() : array
+    public function getConfiguredTypeNames(): array
     {
         return array_keys($this->types);
     }
 
-    /**
-     * @param string $type
-     * @param string $preference
-     * @param string $context
-     */
-    public function setTypePreference(string $type, string $preference, ?string $context = null) : self
+    public function setTypePreference(string $type, string $preference, ?string $context = null): self
     {
         if ($context) {
             $this->types[$context]['preferences'][$type] = $preference;
@@ -222,10 +218,9 @@ public function setTypePreference(string $type, string $preference, ?string $con
     /**
      * @param string $name The name of the alias
      * @param string $class The class name this alias points to
-     * @throws Exception\ClassNotFoundException When `$class` does not exist
-     * @return self
+     * @throws Exception\ClassNotFoundException When `$class` does not exist.
      */
-    public function setAlias(string $name, string $class) : self
+    public function setAlias(string $name, string $class): self
     {
         if (! class_exists($class) && ! interface_exists($class)) {
             throw new Exception\ClassNotFoundException($class);
@@ -235,7 +230,8 @@ public function setAlias(string $name, string $class) : self
         return $this;
     }
 
-    private function ensureArrayOrArrayAccess($options) : void
+    /** @param array|ArrayAccess $options */
+    private function ensureArrayOrArrayAccess($options): void
     {
         if (! is_array($options) && ! $options instanceof ArrayAccess) {
             throw new Exception\InvalidArgumentException(
diff --git a/src/ConfigInterface.php b/src/ConfigInterface.php
index bf346e5f..52ac12d2 100644
--- a/src/ConfigInterface.php
+++ b/src/ConfigInterface.php
@@ -12,31 +12,23 @@
 
 /**
  * Provides the instance and resolver configuration
- *
- * @api
  */
 interface ConfigInterface
 {
     /**
      * Check if the provided type name is aliased
-     *
-     * @param string $name
-     * @return bool
      */
-    public function isAlias(string $name) : bool;
+    public function isAlias(string $name): bool;
 
     /**
      * @return string[]
      */
-    public function getConfiguredTypeNames() : array;
+    public function getConfiguredTypeNames(): array;
 
     /**
      * Returns the actual class name for an alias
-     *
-     * @param string $name
-     * @return string
      */
-    public function getClassForAlias(string $name) : ?string;
+    public function getClassForAlias(string $name): ?string;
 
     /**
      * Returns the instanciation parameters for the given type
@@ -44,22 +36,15 @@ public function getClassForAlias(string $name) : ?string;
      * @param  string $type The alias or class name
      * @return array The configured parameter hash
      */
-    public function getParameters(string $type) : array;
+    public function getParameters(string $type): array;
 
     /**
      * Set the instanciation parameters for the given type
-     *
-     * @param string $type
-     * @param array $params
      */
     public function setParameters(string $type, array $params);
 
     /**
      * Configured type preference
-     *
-     * @param string $type
-     * @param string $contextClass
-     * @return string
      */
-    public function getTypePreference(string $type, ?string $contextClass = null) : ?string;
+    public function getTypePreference(string $type, ?string $contextClass = null): ?string;
 }
diff --git a/src/ConfigProvider.php b/src/ConfigProvider.php
index dcc336b7..e1e9d571 100644
--- a/src/ConfigProvider.php
+++ b/src/ConfigProvider.php
@@ -10,6 +10,10 @@
 
 namespace Laminas\Di;
 
+use Zend\Di\CodeGenerator\InjectorGenerator as LegacyInjectorGenerator;
+use Zend\Di\ConfigInterface as LegacyConfigInterface;
+use Zend\Di\InjectorInterface as LegacyInjectorInterfae;
+
 /**
  * Implements the config provider for mezzio
  */
@@ -20,35 +24,33 @@ class ConfigProvider
      *
      * @return array The configuration for mezzio
      */
-    public function __invoke() : array
+    public function __invoke(): array
     {
         return [
-            'dependencies' => $this->getDependencyConfig()
+            'dependencies' => $this->getDependencyConfig(),
         ];
     }
 
     /**
      * Returns the dependency (service manager) configuration
-     *
-     * @return array
      */
-    public function getDependencyConfig() : array
+    public function getDependencyConfig(): array
     {
         return [
             // Legacy Zend Framework aliases
-            'aliases' => [
-                \Zend\Di\InjectorInterface::class => InjectorInterface::class,
-                \Zend\Di\ConfigInterface::class => ConfigInterface::class,
-                \Zend\Di\CodeGenerator\InjectorGenerator::class => CodeGenerator\InjectorGenerator::class,
+            'aliases'            => [
+                LegacyInjectorInterfae::class  => InjectorInterface::class,
+                LegacyConfigInterface::class   => ConfigInterface::class,
+                LegacyInjectorGenerator::class => CodeGenerator\InjectorGenerator::class,
             ],
-            'factories' => [
-                InjectorInterface::class => Container\InjectorFactory::class,
-                ConfigInterface::class => Container\ConfigFactory::class,
+            'factories'          => [
+                InjectorInterface::class               => Container\InjectorFactory::class,
+                ConfigInterface::class                 => Container\ConfigFactory::class,
                 CodeGenerator\InjectorGenerator::class => Container\GeneratorFactory::class,
             ],
             'abstract_factories' => [
-                Container\ServiceManager\AutowireFactory::class
-            ]
+                Container\ServiceManager\AutowireFactory::class,
+            ],
         ];
     }
 }
diff --git a/src/Container/AutowireFactory.php b/src/Container/AutowireFactory.php
index bca62e38..533fb059 100644
--- a/src/Container/AutowireFactory.php
+++ b/src/Container/AutowireFactory.php
@@ -24,7 +24,7 @@ class AutowireFactory
      *
      * @param ContainerInterface $container The container context for this factory
      * @return InjectorInterface The dependency injector
-     * @throws Exception\RuntimeException When no dependency injector is available
+     * @throws Exception\RuntimeException When no dependency injector is available.
      */
     private function getInjector(ContainerInterface $container)
     {
@@ -41,6 +41,9 @@ private function getInjector(ContainerInterface $container)
 
     /**
      * Check creatability of the requested name
+     *
+     * @param string $requestedName
+     * @return bool
      */
     public function canCreate(ContainerInterface $container, $requestedName)
     {
@@ -48,11 +51,13 @@ public function canCreate(ContainerInterface $container, $requestedName)
             return false;
         }
 
-        return $this->getInjector($container)->canCreate((string)$requestedName);
+        return $this->getInjector($container)->canCreate((string) $requestedName);
     }
 
     /**
      * Create an instance
+     *
+     * @return object
      */
     public function create(ContainerInterface $container, string $requestedName, ?array $options = null)
     {
@@ -61,9 +66,12 @@ public function create(ContainerInterface $container, string $requestedName, ?ar
 
     /**
      * Make invokable and implement the laminas-service factory pattern
+     *
+     * @param string $requestedName
+     * @return object
      */
-    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
+    public function __invoke(ContainerInterface $container, $requestedName, ?array $options = null)
     {
-        return $this->create($container, (string)$requestedName, $options);
+        return $this->create($container, (string) $requestedName, $options);
     }
 }
diff --git a/src/Container/ConfigFactory.php b/src/Container/ConfigFactory.php
index 8b148832..c5ca1398 100644
--- a/src/Container/ConfigFactory.php
+++ b/src/Container/ConfigFactory.php
@@ -15,19 +15,23 @@
 use Laminas\Di\LegacyConfig;
 use Psr\Container\ContainerInterface;
 
+use function array_merge_recursive;
+use function trigger_error;
+
+use const E_USER_DEPRECATED;
+
 /**
  * Factory implementation for creating the definition list
  */
 class ConfigFactory
 {
     /**
-     * @param ContainerInterface $container
      * @return Config
      */
-    public function create(ContainerInterface $container) : ConfigInterface
+    public function create(ContainerInterface $container): ConfigInterface
     {
         $config = $container->has('config') ? $container->get('config') : [];
-        $data = (isset($config['dependencies']['auto'])) ? $config['dependencies']['auto'] : [];
+        $data   = $config['dependencies']['auto'] ?? [];
 
         if (isset($config['di'])) {
             trigger_error(
@@ -37,7 +41,7 @@ public function create(ContainerInterface $container) : ConfigInterface
             );
 
             $legacyConfig = new LegacyConfig($config['di']);
-            $data = array_merge_recursive($legacyConfig->toArray(), $data);
+            $data         = array_merge_recursive($legacyConfig->toArray(), $data);
         }
 
         return new Config($data);
@@ -46,7 +50,7 @@ public function create(ContainerInterface $container) : ConfigInterface
     /**
      * Make the instance invokable
      */
-    public function __invoke(ContainerInterface $container) : ConfigInterface
+    public function __invoke(ContainerInterface $container): ConfigInterface
     {
         return $this->create($container);
     }
diff --git a/src/Container/GeneratorFactory.php b/src/Container/GeneratorFactory.php
index 7fd4ccb3..c161e605 100644
--- a/src/Container/GeneratorFactory.php
+++ b/src/Container/GeneratorFactory.php
@@ -15,32 +15,33 @@
 use Laminas\Di\Definition\RuntimeDefinition;
 use Laminas\Di\Resolver\DependencyResolver;
 use Psr\Container\ContainerInterface;
+use Zend\Di\ConfigInterface as LegacyConfigInterace;
 
 class GeneratorFactory
 {
-    private function getConfig(ContainerInterface $container) : ConfigInterface
+    private function getConfig(ContainerInterface $container): ConfigInterface
     {
         if ($container->has(ConfigInterface::class)) {
             return $container->get(ConfigInterface::class);
         }
 
-        if ($container->has(\Zend\Di\ConfigInterface::class)) {
-            return $container->get(\Zend\Di\ConfigInterface::class);
+        if ($container->has(LegacyConfigInterace::class)) {
+            return $container->get(LegacyConfigInterace::class);
         }
 
         return (new ConfigFactory())->create($container);
     }
 
-    public function create(ContainerInterface $container) : InjectorGenerator
+    public function create(ContainerInterface $container): InjectorGenerator
     {
         $diConfig = $this->getConfig($container);
         $resolver = new DependencyResolver(new RuntimeDefinition(), $diConfig);
         $resolver->setContainer($container);
 
-        $config = $container->has('config') ? $container->get('config') : [];
+        $config    = $container->has('config') ? $container->get('config') : [];
         $aotConfig = $config['dependencies']['auto']['aot'] ?? [];
         $namespace = $aotConfig['namespace'] ?? null;
-        $logger = null;
+        $logger    = null;
 
         if (isset($aotConfig['logger'])) {
             $logger = $container->get($aotConfig['logger']);
@@ -55,7 +56,7 @@ public function create(ContainerInterface $container) : InjectorGenerator
         return $generator;
     }
 
-    public function __invoke(ContainerInterface $container) : InjectorGenerator
+    public function __invoke(ContainerInterface $container): InjectorGenerator
     {
         return $this->create($container);
     }
diff --git a/src/Container/InjectorFactory.php b/src/Container/InjectorFactory.php
index 6e88a72e..7bf811d3 100644
--- a/src/Container/InjectorFactory.php
+++ b/src/Container/InjectorFactory.php
@@ -14,24 +14,21 @@
 use Laminas\Di\Injector;
 use Laminas\Di\InjectorInterface;
 use Psr\Container\ContainerInterface;
+use Zend\Di\ConfigInterface as LegacyConfigInterace;
 
 /**
  * Implements the DependencyInjector service factory for laminas-servicemanager
  */
 class InjectorFactory
 {
-    /**
-     * @param ContainerInterface $container
-     * @return ConfigInterface
-     */
-    private function createConfig(ContainerInterface $container) : ConfigInterface
+    private function createConfig(ContainerInterface $container): ConfigInterface
     {
         if ($container->has(ConfigInterface::class)) {
             return $container->get(ConfigInterface::class);
         }
 
-        if ($container->has(\Zend\Di\ConfigInterface::class)) {
-            return $container->get(\Zend\Di\ConfigInterface::class);
+        if ($container->has(LegacyConfigInterace::class)) {
+            return $container->get(LegacyConfigInterace::class);
         }
 
         return (new ConfigFactory())->create($container);
@@ -40,7 +37,7 @@ private function createConfig(ContainerInterface $container) : ConfigInterface
     /**
      * {@inheritDoc}
      */
-    public function create(ContainerInterface $container) : InjectorInterface
+    public function create(ContainerInterface $container): InjectorInterface
     {
         $config = $this->createConfig($container);
         return new Injector($config, $container);
@@ -49,7 +46,7 @@ public function create(ContainerInterface $container) : InjectorInterface
     /**
      * Make the instance invokable
      */
-    public function __invoke(ContainerInterface $container) : InjectorInterface
+    public function __invoke(ContainerInterface $container): InjectorInterface
     {
         return $this->create($container);
     }
diff --git a/src/Container/ServiceManager/AutowireFactory.php b/src/Container/ServiceManager/AutowireFactory.php
index 775a7768..8873f5c8 100644
--- a/src/Container/ServiceManager/AutowireFactory.php
+++ b/src/Container/ServiceManager/AutowireFactory.php
@@ -21,18 +21,19 @@
  */
 class AutowireFactory implements AbstractFactoryInterface
 {
-    /**
-     * @var GenericAutowireFactory
-     */
+    /** @var GenericAutowireFactory */
     private $factory;
 
-    public function __construct(GenericAutowireFactory $factory = null)
+    public function __construct(?GenericAutowireFactory $factory = null)
     {
         $this->factory = $factory ? : new GenericAutowireFactory();
     }
 
     /**
      * Check creatability of the requested name
+     *
+     * @param string $requestedName
+     * @return bool
      */
     public function canCreate(ContainerInterface $container, $requestedName)
     {
@@ -41,8 +42,11 @@ public function canCreate(ContainerInterface $container, $requestedName)
 
     /**
      * Make invokable and implement the laminas-service factory pattern
+     *
+     * @param string $requestedName
+     * @return bool
      */
-    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
+    public function __invoke(ContainerInterface $container, $requestedName, ?array $options = null)
     {
         return $this->factory->create($container, (string) $requestedName, $options);
     }
diff --git a/src/DefaultContainer.php b/src/DefaultContainer.php
index 6575201b..9b7ad8d1 100644
--- a/src/DefaultContainer.php
+++ b/src/DefaultContainer.php
@@ -12,6 +12,8 @@
 
 use Psr\Container\ContainerInterface;
 
+use function get_class;
+
 /**
  * Default IoC container implementation.
  *
@@ -37,10 +39,10 @@ public function __construct(InjectorInterface $injector)
     {
         $this->injector = $injector;
 
-        $this->services[InjectorInterface::class] = $injector;
+        $this->services[InjectorInterface::class]  = $injector;
         $this->services[ContainerInterface::class] = $this;
-        $this->services[get_class($injector)] = $injector;
-        $this->services[get_class($this)] = $this;
+        $this->services[get_class($injector)]      = $injector;
+        $this->services[static::class]             = $this;
     }
 
     /**
@@ -48,9 +50,8 @@ public function __construct(InjectorInterface $injector)
      *
      * @param string $name The name of the service retrievable by get()
      * @param object $service The service instance
-     * @return self
      */
-    public function setInstance(string $name, $service) : self
+    public function setInstance(string $name, $service): self
     {
         $this->services[$name] = $service;
         return $this;
@@ -60,6 +61,7 @@ public function setInstance(string $name, $service) : self
      * Check if a service is available
      *
      * @see ContainerInterface::has()
+     *
      * @param string $name
      * @return mixed
      */
@@ -82,6 +84,7 @@ public function has($name)
      * the dependency injector and then it is stored for further use.
      *
      * @see ContainerInterface::get()
+     *
      * @param string $name
      * @return mixed
      */
diff --git a/src/Definition/ClassDefinitionInterface.php b/src/Definition/ClassDefinitionInterface.php
index d6c675ca..db01b726 100644
--- a/src/Definition/ClassDefinitionInterface.php
+++ b/src/Definition/ClassDefinitionInterface.php
@@ -14,23 +14,20 @@
 
 interface ClassDefinitionInterface
 {
-    /**
-     * @return ReflectionClass
-     */
-    public function getReflection() : ReflectionClass;
+    public function getReflection(): ReflectionClass;
 
     /**
      * @return string[]
      */
-    public function getSupertypes() : array;
+    public function getSupertypes(): array;
 
     /**
      * @return string[]
      */
-    public function getInterfaces() : array;
+    public function getInterfaces(): array;
 
     /**
      * @return ParameterInterface[]
      */
-    public function getParameters() : array;
+    public function getParameters(): array;
 }
diff --git a/src/Definition/DefinitionInterface.php b/src/Definition/DefinitionInterface.php
index 11343dda..ce62452c 100644
--- a/src/Definition/DefinitionInterface.php
+++ b/src/Definition/DefinitionInterface.php
@@ -10,6 +10,8 @@
 
 namespace Laminas\Di\Definition;
 
+use Laminas\Di\Exception\ClassNotFoundException;
+
 /**
  * Interface for class definitions
  */
@@ -20,20 +22,15 @@ interface DefinitionInterface
      *
      * @return string[]
      */
-    public function getClasses() : array;
+    public function getClasses(): array;
 
     /**
      * Whether a class exists in this definition
-     *
-     * @param  string $class
-     * @return bool
      */
-    public function hasClass(string $class) : bool;
+    public function hasClass(string $class): bool;
 
     /**
-     * @param string $class
-     * @throws \Laminas\Di\Exception\ClassNotFoundException
-     * @return ClassDefinitionInterface
+     * @throws ClassNotFoundException
      */
-    public function getClassDefinition(string $class) : ClassDefinitionInterface;
+    public function getClassDefinition(string $class): ClassDefinitionInterface;
 }
diff --git a/src/Definition/ParameterInterface.php b/src/Definition/ParameterInterface.php
index 2836ed75..e063e2dd 100644
--- a/src/Definition/ParameterInterface.php
+++ b/src/Definition/ParameterInterface.php
@@ -15,33 +15,18 @@
  */
 interface ParameterInterface
 {
-    /**
-     * @return string
-     */
-    public function getName() : string;
+    public function getName(): string;
 
-    /**
-     * @return int
-     */
-    public function getPosition() : int;
+    public function getPosition(): int;
 
-    /**
-     * @return string|null
-     */
-    public function getType() : ?string;
+    public function getType(): ?string;
 
     /**
      * @return mixed
      */
     public function getDefault();
 
-    /**
-     * @return bool
-     */
-    public function isRequired() : bool;
+    public function isRequired(): bool;
 
-    /**
-     * @return bool
-     */
-    public function isBuiltin() : bool;
+    public function isBuiltin(): bool;
 }
diff --git a/src/Definition/Reflection/ClassDefinition.php b/src/Definition/Reflection/ClassDefinition.php
index 223e3251..5fa42b5c 100644
--- a/src/Definition/Reflection/ClassDefinition.php
+++ b/src/Definition/Reflection/ClassDefinition.php
@@ -13,23 +13,20 @@
 use Laminas\Di\Definition\ClassDefinitionInterface;
 use Laminas\Di\Definition\ParameterInterface;
 use ReflectionClass;
+use ReflectionParameter;
+
+use function uasort;
 
 class ClassDefinition implements ClassDefinitionInterface
 {
-    /**
-     * @var ReflectionClass
-     */
+    /** @var ReflectionClass */
     private $reflection;
 
-    /**
-     * @var Parameter[]
-     */
-    private $parameters = null;
+    /** @var Parameter[] */
+    private $parameters;
 
-    /**
-     * @var string[]
-     */
-    private $supertypes = null;
+    /** @var string[] */
+    private $supertypes;
 
     /**
      * @param string|ReflectionClass $class
@@ -43,23 +40,17 @@ public function __construct($class)
         $this->reflection = $class;
     }
 
-    /**
-     * @return void
-     */
     private function reflectSupertypes()
     {
         $this->supertypes = [];
-        $class = $this->reflection;
+        $class            = $this->reflection;
 
         while ($class = $class->getParentClass()) {
             $this->supertypes[] = $class->name;
         }
     }
 
-    /**
-     * @return ReflectionClass
-     */
-    public function getReflection() : ReflectionClass
+    public function getReflection(): ReflectionClass
     {
         return $this->reflection;
     }
@@ -67,7 +58,7 @@ public function getReflection() : ReflectionClass
     /**
      * @return string[]
      */
-    public function getSupertypes() : array
+    public function getSupertypes(): array
     {
         if ($this->supertypes === null) {
             $this->reflectSupertypes();
@@ -79,14 +70,11 @@ public function getSupertypes() : array
     /**
      * @return string[]
      */
-    public function getInterfaces() : array
+    public function getInterfaces(): array
     {
         return $this->reflection->getInterfaceNames();
     }
 
-    /**
-     * @return void
-     */
     private function reflectParameters()
     {
         $this->parameters = [];
@@ -97,9 +85,9 @@ private function reflectParameters()
 
         $method = $this->reflection->getMethod('__construct');
 
-        /** @var \ReflectionParameter $parameterReflection */
+        /** @var ReflectionParameter $parameterReflection */
         foreach ($method->getParameters() as $parameterReflection) {
-            $parameter = new Parameter($parameterReflection);
+            $parameter                               = new Parameter($parameterReflection);
             $this->parameters[$parameter->getName()] = $parameter;
         }
 
@@ -111,7 +99,7 @@ private function reflectParameters()
     /**
      * @return Parameter[]
      */
-    public function getParameters() : array
+    public function getParameters(): array
     {
         if ($this->parameters === null) {
             $this->reflectParameters();
diff --git a/src/Definition/Reflection/Parameter.php b/src/Definition/Reflection/Parameter.php
index fd132704..3938e212 100644
--- a/src/Definition/Reflection/Parameter.php
+++ b/src/Definition/Reflection/Parameter.php
@@ -18,14 +18,9 @@
  */
 class Parameter implements ParameterInterface
 {
-    /**
-     * @var ReflectionParameter
-     */
+    /** @var ReflectionParameter */
     protected $reflection;
 
-    /**
-     * @param ReflectionParameter $reflection
-     */
     public function __construct(ReflectionParameter $reflection)
     {
         $this->reflection = $reflection;
@@ -33,7 +28,10 @@ public function __construct(ReflectionParameter $reflection)
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::getDefault()
+     *
+     * @return mixed
      */
     public function getDefault()
     {
@@ -42,27 +40,30 @@ public function getDefault()
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::getName()
      */
-    public function getName() : string
+    public function getName(): string
     {
         return $this->reflection->getName();
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::getPosition()
      */
-    public function getPosition() : int
+    public function getPosition(): int
     {
         return $this->reflection->getPosition();
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::getType()
      */
-    public function getType() : ?string
+    public function getType(): ?string
     {
         if ($this->reflection->hasType()) {
             return $this->reflection->getType()->getName();
@@ -73,18 +74,20 @@ public function getType() : ?string
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::isRequired()
      */
-    public function isRequired() : bool
+    public function isRequired(): bool
     {
         return ! $this->reflection->isOptional();
     }
 
     /**
      * {@inheritDoc}
+     *
      * @see ParameterInterface::isScalar()
      */
-    public function isBuiltin() : bool
+    public function isBuiltin(): bool
     {
         if ($this->reflection->hasType()) {
             $type = $this->reflection->getType();
diff --git a/src/Definition/RuntimeDefinition.php b/src/Definition/RuntimeDefinition.php
index 05c4b229..4d023ea4 100644
--- a/src/Definition/RuntimeDefinition.php
+++ b/src/Definition/RuntimeDefinition.php
@@ -13,25 +13,25 @@
 use Laminas\Di\Definition\Reflection\ClassDefinition;
 use Laminas\Di\Exception;
 
+use function array_keys;
+use function array_merge;
+use function class_exists;
+
 /**
  * Class definitions based on runtime reflection
  */
 class RuntimeDefinition implements DefinitionInterface
 {
-    /**
-     * @var ClassDefinition[]
-     */
+    /** @var ClassDefinition[] */
     private $definition = [];
 
-    /**
-     * @var bool[]
-     */
-    private $explicitClasses = null;
+    /** @var bool[] */
+    private $explicitClasses;
 
     /**
      * @param null|string[] $explicitClasses
      */
-    public function __construct(array $explicitClasses = null)
+    public function __construct(?array $explicitClasses = null)
     {
         if ($explicitClasses) {
             $this->setExplicitClasses($explicitClasses);
@@ -42,11 +42,11 @@ public function __construct(array $explicitClasses = null)
      * Set explicit class names
      *
      * @see addExplicitClass()
+     *
      * @param string[] $explicitClasses An array of class names
      * @throws Exception\ClassNotFoundException
-     * @return self
      */
-    public function setExplicitClasses(array $explicitClasses) : self
+    public function setExplicitClasses(array $explicitClasses): self
     {
         $this->explicitClasses = [];
 
@@ -63,11 +63,9 @@ public function setExplicitClasses(array $explicitClasses) : self
      * Adding classes this way will cause the defintion to report them when getClasses()
      * is called, even when they're not yet loaded.
      *
-     * @param string $class
      * @throws Exception\ClassNotFoundException
-     * @return self
      */
-    public function addExplicitClass(string $class) : self
+    public function addExplicitClass(string $class): self
     {
         if (! class_exists($class)) {
             throw new Exception\ClassNotFoundException($class);
@@ -91,13 +89,13 @@ private function loadClass(string $class)
             throw new Exception\ClassNotFoundException($class);
         }
 
-        $this->definition[$class] = new Reflection\ClassDefinition($class);
+        $this->definition[$class] = new ClassDefinition($class);
     }
 
     /**
      * @return string[]
      */
-    public function getClasses() : array
+    public function getClasses(): array
     {
         if (! $this->explicitClasses) {
             return array_keys($this->definition);
@@ -106,20 +104,16 @@ public function getClasses() : array
         return array_keys(array_merge($this->definition, $this->explicitClasses));
     }
 
-    /**
-     * @return bool
-     */
-    public function hasClass(string $class) : bool
+    public function hasClass(string $class): bool
     {
         return class_exists($class);
     }
 
     /**
-     * @param string $class
-     * @return Reflection\ClassDefinition
+     * @return ClassDefinition
      * @throws Exception\ClassNotFoundException
      */
-    public function getClassDefinition(string $class) : ClassDefinitionInterface
+    public function getClassDefinition(string $class): ClassDefinitionInterface
     {
         if (! isset($this->definition[$class])) {
             $this->loadClass($class);
diff --git a/src/Exception/ClassNotFoundException.php b/src/Exception/ClassNotFoundException.php
index dd55e585..cb27797a 100644
--- a/src/Exception/ClassNotFoundException.php
+++ b/src/Exception/ClassNotFoundException.php
@@ -13,7 +13,7 @@
 
 class ClassNotFoundException extends DomainException implements ExceptionInterface
 {
-    public function __construct(string $classname, int $code = null, Throwable $previous = null)
+    public function __construct(string $classname, ?int $code = null, ?Throwable $previous = null)
     {
         parent::__construct("The class '$classname' does not exist.", $code ?? 0, $previous);
     }
diff --git a/src/Exception/InvalidArgumentException.php b/src/Exception/InvalidArgumentException.php
index 3440461d..03a0c2dd 100644
--- a/src/Exception/InvalidArgumentException.php
+++ b/src/Exception/InvalidArgumentException.php
@@ -10,6 +10,8 @@
 
 namespace Laminas\Di\Exception;
 
-class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+use InvalidArgumentException as BaseInvalidArgumentException;
+
+class InvalidArgumentException extends BaseInvalidArgumentException implements ExceptionInterface
 {
 }
diff --git a/src/Exception/LogicException.php b/src/Exception/LogicException.php
index 7b2cef81..3d850155 100644
--- a/src/Exception/LogicException.php
+++ b/src/Exception/LogicException.php
@@ -10,6 +10,8 @@
 
 namespace Laminas\Di\Exception;
 
-class LogicException extends \LogicException implements ExceptionInterface
+use LogicException as BaseLogicException;
+
+class LogicException extends BaseLogicException implements ExceptionInterface
 {
 }
diff --git a/src/Exception/RuntimeException.php b/src/Exception/RuntimeException.php
index 06bf174d..6ae24c69 100644
--- a/src/Exception/RuntimeException.php
+++ b/src/Exception/RuntimeException.php
@@ -10,6 +10,8 @@
 
 namespace Laminas\Di\Exception;
 
-class RuntimeException extends \RuntimeException implements ExceptionInterface
+use RuntimeException as BaseRuntimeException;
+
+class RuntimeException extends BaseRuntimeException implements ExceptionInterface
 {
 }
diff --git a/src/Exception/UnexpectedValueException.php b/src/Exception/UnexpectedValueException.php
index f2bb785c..23e61a6f 100644
--- a/src/Exception/UnexpectedValueException.php
+++ b/src/Exception/UnexpectedValueException.php
@@ -10,6 +10,8 @@
 
 namespace Laminas\Di\Exception;
 
-class UnexpectedValueException extends \UnexpectedValueException implements ExceptionInterface
+use UnexpectedValueException as BaseUnexpectedValueException;
+
+class UnexpectedValueException extends BaseUnexpectedValueException implements ExceptionInterface
 {
 }
diff --git a/src/GeneratedInjectorDelegator.php b/src/GeneratedInjectorDelegator.php
index c9e181ce..7319ce21 100644
--- a/src/GeneratedInjectorDelegator.php
+++ b/src/GeneratedInjectorDelegator.php
@@ -12,15 +12,16 @@
 use Psr\Container\ContainerInterface;
 
 use function class_exists;
+use function is_string;
 
 class GeneratedInjectorDelegator
 {
     /**
      * @param string $name
      */
-    public function __invoke(ContainerInterface $container, $name, callable $callback) : InjectorInterface
+    public function __invoke(ContainerInterface $container, $name, callable $callback): InjectorInterface
     {
-        $config = $container->has('config') ? $container->get('config') : [];
+        $config    = $container->has('config') ? $container->get('config') : [];
         $aotConfig = $config['dependencies']['auto']['aot'] ?? [];
         $namespace = ! isset($aotConfig['namespace']) || $aotConfig['namespace'] === ''
             ? 'Laminas\Di\Generated'
diff --git a/src/Injector.php b/src/Injector.php
index e5623c40..02d6e6eb 100644
--- a/src/Injector.php
+++ b/src/Injector.php
@@ -10,68 +10,65 @@
 
 namespace Laminas\Di;
 
+use Interop\Container\ContainerInterface as LegacyContainerInterface;
+use Laminas\Di\Definition\DefinitionInterface;
 use Laminas\Di\Exception\ClassNotFoundException;
 use Laminas\Di\Exception\InvalidCallbackException;
 use Laminas\Di\Exception\RuntimeException;
+use Laminas\Di\Resolver\DependencyResolverInterface;
 use Laminas\Di\Resolver\InjectionInterface;
 use Laminas\Di\Resolver\TypeInjection;
-use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
 use Psr\Container\NotFoundExceptionInterface;
 
+use function array_pop;
+use function class_exists;
+use function implode;
 use function in_array;
+use function interface_exists;
+use function sprintf;
 
 /**
  * Dependency injector that can generate instances using class definitions and configured instance parameters
  */
 class Injector implements InjectorInterface
 {
-    /**
-     * @var Definition\DefinitionInterface
-     */
-    protected $definition = null;
+    /** @var DefinitionInterface */
+    protected $definition;
 
-    /**
-     * @var ContainerInterface
-     */
-    protected $container = null;
+    /** @var ContainerInterface */
+    protected $container;
 
-    /**
-     * @var Resolver\DependencyResolverInterface
-     */
+    /** @var DependencyResolverInterface */
     protected $resolver;
 
-    /**
-     * @var ConfigInterface
-     */
+    /** @var ConfigInterface */
     protected $config;
 
-    /**
-     * @var string[]
-     */
+    /** @var string[] */
     protected $instantiationStack = [];
 
     /**
      * Constructor
      *
-     * @param ConfigInterface|null $config A custom configuration to utilize. An empty configuration is used
-     *      when null is passed or the parameter is omitted.
-     * @param ContainerInterface|null $container The IoC container to retrieve dependency instances.
-     *      `Laminas\Di\DefaultContainer` is used when null is passed or the parameter is omitted.
-     * @param Definition\DefinitionInterface $definition A custom definition instance for creating requested instances.
-     *      The runtime definition is used when null is passed or the parameter is omitted.
-     * @param Resolver\DependencyResolverInterface|null $resolver A custom resolver instance to resolve dependencies.
+     * @param ConfigInterface|null             $config A custom configuration to utilize. An empty configuration is used
+     *                  when null is passed or the parameter is omitted.
+     * @param ContainerInterface|null          $container The IoC container to retrieve dependency instances.
+     *               `Laminas\Di\DefaultContainer` is used when null is passed or the parameter is omitted.
+     * @param null|DefinitionInterface         $definition A custom definition instance for creating requested
+     *               instances. The runtime definition is used when null is passed or the parameter is omitted.
+     * @param DependencyResolverInterface|null $resolver A custom resolver instance to resolve dependencies.
      *      The default resolver is used when null is passed or the parameter is omitted
      */
     public function __construct(
-        ConfigInterface $config = null,
-        ContainerInterface $container = null,
-        Definition\DefinitionInterface $definition = null,
-        Resolver\DependencyResolverInterface $resolver = null
+        ?ConfigInterface $config = null,
+        ?ContainerInterface $container = null,
+        ?DefinitionInterface $definition = null,
+        ?DependencyResolverInterface $resolver = null
     ) {
         $this->definition = $definition ?: new Definition\RuntimeDefinition();
-        $this->config = $config ?: new Config();
-        $this->resolver = $resolver ?: new Resolver\DependencyResolver($this->definition, $this->config);
+        $this->config     = $config ?: new Config();
+        $this->resolver   = $resolver ?: new Resolver\DependencyResolver($this->definition, $this->config);
         $this->setContainer($container ?: new DefaultContainer($this));
     }
 
@@ -80,8 +77,7 @@ public function __construct(
      *
      * Sets the ioc container to utilize for fetching instances of dependencies
      *
-     * @param ContainerInterface $container
-     * @return self
+     * @return $this
      */
     public function setContainer(ContainerInterface $container)
     {
@@ -91,7 +87,7 @@ public function setContainer(ContainerInterface $container)
         return $this;
     }
 
-    public function getContainer() : ContainerInterface
+    public function getContainer(): ContainerInterface
     {
         return $this->container;
     }
@@ -99,7 +95,7 @@ public function getContainer() : ContainerInterface
     /**
      * Returns the class name for the requested type
      */
-    private function getClassName(string $type) : string
+    private function getClassName(string $type): string
     {
         if ($this->config->isAlias($type)) {
             return $this->config->getClassForAlias($type) ?? $type;
@@ -113,17 +109,17 @@ private function getClassName(string $type) : string
      *
      * This will be the case if the name points to a class.
      */
-    public function canCreate(string $name) : bool
+    public function canCreate(string $name): bool
     {
         $class = $this->getClassName($name);
-        return (class_exists($class) && ! interface_exists($class));
+        return class_exists($class) && ! interface_exists($class);
     }
 
     /**
      * Create the instance with auto wiring
      *
      * @param string $name Class name or service alias
-     * @param array $parameters Constructor parameters, keyed by the parameter name.
+     * @param array  $parameters Constructor parameters, keyed by the parameter name.
      * @return object|null
      * @throws ClassNotFoundException
      * @throws RuntimeException
@@ -155,7 +151,7 @@ public function create(string $name, array $parameters = [])
      * Any parameters provided will be used as constructor arguments only.
      *
      * @param string $name The type name to instantiate.
-     * @param array $params Constructor arguments, keyed by the parameter name.
+     * @param array  $params Constructor arguments, keyed by the parameter name.
      * @return object
      * @throws InvalidCallbackException
      * @throws ClassNotFoundException
@@ -165,8 +161,8 @@ protected function createInstance(string $name, array $params)
         $class = $this->getClassName($name);
 
         if (! $this->definition->hasClass($class)) {
-            $aliasMsg = ($name != $class) ? ' (specified by alias ' . $name . ')' : '';
-            throw new Exception\ClassNotFoundException(sprintf(
+            $aliasMsg = $name !== $class ? ' (specified by alias ' . $name . ')' : '';
+            throw new ClassNotFoundException(sprintf(
                 'Class %s%s could not be located in provided definitions.',
                 $class,
                 $aliasMsg
@@ -174,7 +170,7 @@ protected function createInstance(string $name, array $params)
         }
 
         if (! class_exists($class) || interface_exists($class)) {
-            throw new Exception\ClassNotFoundException(sprintf(
+            throw new ClassNotFoundException(sprintf(
                 'Class or interface by name %s does not exist',
                 $class
             ));
@@ -190,13 +186,14 @@ protected function createInstance(string $name, array $params)
      */
     private function getInjectionValue(InjectionInterface $injection)
     {
-        $container = $this->container;
+        $container      = $this->container;
         $containerTypes = [
             ContainerInterface::class,
-            'Interop\Container\ContainerInterface' // Be backwards compatible with interop/container
+            LegacyContainerInterface::class, // Be backwards compatible with interop/container
         ];
 
-        if (($injection instanceof TypeInjection)
+        if (
+            $injection instanceof TypeInjection
             && ! $container->has((string) $injection)
             && in_array((string) $injection, $containerTypes, true)
         ) {
@@ -214,18 +211,17 @@ private function getInjectionValue(InjectionInterface $injection)
      * the ioc container to fetch the instances
      *
      * @param string $type The class or alias name to resolve for
-     * @param array $params Provided call time parameters
+     * @param array  $params Provided call time parameters
      * @return array The resulting arguments in call order
      * @throws Exception\UndefinedReferenceException When a type cannot be
      *     obtained via the ioc container and the method is required for
      *     injection.
-     * @throws Exception\CircularDependencyException When a circular dependency
-     *     is detected
+     * @throws Exception\CircularDependencyException When a circular dependency is detected.
      */
-    private function resolveParameters(string $type, array $params = []) : array
+    private function resolveParameters(string $type, array $params = []): array
     {
         $resolved = $this->resolver->resolveParameters($type, $params);
-        $params = [];
+        $params   = [];
 
         foreach ($resolved as $position => $injection) {
             try {
diff --git a/src/InjectorInterface.php b/src/InjectorInterface.php
index 97b6247c..db29c69c 100644
--- a/src/InjectorInterface.php
+++ b/src/InjectorInterface.php
@@ -18,14 +18,14 @@ interface InjectorInterface
     /**
      * Check if this dependency injector can handle the given class
      */
-    public function canCreate(string $name) : bool;
+    public function canCreate(string $name): bool;
 
     /**
      * Create a new instance of a class or alias
      *
      * @param array $options Parameters used for instanciation
      * @return object The resulting instace
-     * @throws Exception\ExceptionInterface When an error occours during instanciation
+     * @throws Exception\ExceptionInterface When an error occours during instanciation.
      */
     public function create(string $name, array $options = []);
 }
diff --git a/src/LegacyConfig.php b/src/LegacyConfig.php
index 6f0b5a75..3c5b9a1f 100644
--- a/src/LegacyConfig.php
+++ b/src/LegacyConfig.php
@@ -10,15 +10,28 @@
 
 namespace Laminas\Di;
 
+use ArrayAccess;
 use Laminas\Stdlib\ArrayUtils;
 use Laminas\Stdlib\Parameters;
 use Traversable;
 
+use function array_pop;
+use function class_exists;
+use function interface_exists;
+use function is_array;
+use function strpos;
+use function trigger_error;
+
+use const E_USER_DEPRECATED;
+
 /**
  * Provides a migration config from laminas-di 2.x configuration arrays
  */
 class LegacyConfig extends Config
 {
+    /**
+     * @param array|ArrayAccess $config
+     */
     public function __construct($config)
     {
         parent::__construct([]);
@@ -36,6 +49,10 @@ public function __construct($config)
         }
     }
 
+    /**
+     * @param mixed $parameters
+     * @return mixed[]
+     */
     private function prepareParametersArray($parameters, string $class)
     {
         $prepared = [];
@@ -51,6 +68,9 @@ private function prepareParametersArray($parameters, string $class)
         return $prepared;
     }
 
+    /**
+     * @param iterable $config
+     */
     private function configureInstance($config)
     {
         foreach ($config as $target => $data) {
@@ -73,10 +93,10 @@ private function configureInstance($config)
                     break;
 
                 default:
-                    $config = new Parameters($data);
+                    $config     = new Parameters($data);
                     $parameters = $config->get('parameters', $config->get('parameter'));
 
-                    if (is_array($parameters) || ($parameters instanceof Traversable)) {
+                    if (is_array($parameters) || $parameters instanceof Traversable) {
                         $parameters = $this->prepareParametersArray($parameters, $target);
                         $this->setParameters($target, $parameters);
                     }
@@ -88,11 +108,11 @@ private function configureInstance($config)
     /**
      * Export the configuraton to an array
      */
-    public function toArray() : array
+    public function toArray(): array
     {
         return [
             'preferences' => $this->preferences,
-            'types' => $this->types,
+            'types'       => $this->types,
         ];
     }
 }
diff --git a/src/Module.php b/src/Module.php
index f7630848..1d99337b 100644
--- a/src/Module.php
+++ b/src/Module.php
@@ -32,7 +32,7 @@ class Module
     /**
      * Returns the configuration for laminas-mvc
      */
-    public function getConfig() : array
+    public function getConfig(): array
     {
         $provider = new ConfigProvider();
         return [
diff --git a/src/Resolver/AbstractInjection.php b/src/Resolver/AbstractInjection.php
index 61c72cc4..eb5e8125 100644
--- a/src/Resolver/AbstractInjection.php
+++ b/src/Resolver/AbstractInjection.php
@@ -1,5 +1,5 @@
 <?php
-
+// phpcs:ignoreFile
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
@@ -10,6 +10,7 @@
 
 namespace Laminas\Di\Resolver;
 
+use function sprintf;
 use function trigger_error;
 
 use const E_USER_DEPRECATED;
@@ -24,42 +25,29 @@
 );
 
 /**
- * @codeCoverageIgnore Deprecated
  * @deprecated Since 3.1.0
+ *
  * @see InjectionInterface
+ *
+ * @codeCoverageIgnore Deprecated
  */
 abstract class AbstractInjection
 {
-    /**
-     * @var string
-     */
+    /** @var string */
     private $parameterName;
 
-    /**
-     * @param string $name
-     * @return self
-     */
-    public function setParameterName(string $name) : self
+    public function setParameterName(string $name): self
     {
         $this->parameterName = $name;
         return $this;
     }
 
-    /**
-     * @return string
-     */
-    public function getParameterName() : string
+    public function getParameterName(): string
     {
         return $this->parameterName;
     }
 
-    /**
-     * @return string
-     */
-    abstract public function export() : string;
+    abstract public function export(): string;
 
-    /**
-     * @return bool
-     */
-    abstract public function isExportable() : bool;
+    abstract public function isExportable(): bool;
 }
diff --git a/src/Resolver/DependencyResolver.php b/src/Resolver/DependencyResolver.php
index bdbc6f9b..55a15886 100644
--- a/src/Resolver/DependencyResolver.php
+++ b/src/Resolver/DependencyResolver.php
@@ -18,29 +18,33 @@
 use ReflectionClass;
 use Traversable;
 
+use function array_filter;
+use function array_merge;
+use function class_exists;
+use function gettype;
+use function in_array;
+use function interface_exists;
+use function is_array;
+use function is_callable;
+use function is_numeric;
+use function is_string;
+use function sprintf;
+
 /**
  * The default resolver implementation
  */
 class DependencyResolver implements DependencyResolverInterface
 {
-    /**
-     * @var ConfigInterface
-     */
+    /** @var ConfigInterface */
     protected $config;
 
-    /**
-     * @var DefinitionInterface
-     */
+    /** @var DefinitionInterface */
     protected $definition;
 
-    /**
-     * @var ContainerInterface
-     */
-    protected $container = null;
+    /** @var ContainerInterface */
+    protected $container;
 
-    /**
-     * @var string[]
-     */
+    /** @var string[] */
     private $builtinTypes = [
         'string',
         'int',
@@ -56,16 +60,16 @@ class DependencyResolver implements DependencyResolverInterface
     private $gettypeMap = [
         'boolean' => 'bool',
         'integer' => 'int',
-        'double' => 'float',
+        'double'  => 'float',
     ];
 
     public function __construct(DefinitionInterface $definition, ConfigInterface $config)
     {
         $this->definition = $definition;
-        $this->config = $config;
+        $this->config     = $config;
     }
 
-    private function getClassDefinition(string $type) : ClassDefinitionInterface
+    private function getClassDefinition(string $type): ClassDefinitionInterface
     {
         if ($this->config->isAlias($type)) {
             $type = $this->config->getClassForAlias($type) ?? $type;
@@ -83,12 +87,12 @@ private function getClassDefinition(string $type) : ClassDefinitionInterface
      * @param string $requestedType The type name to get injections for
      * @return array Injections for the method indexed by the parameter name
      */
-    private function getConfiguredParameters(string $requestedType) : array
+    private function getConfiguredParameters(string $requestedType): array
     {
-        $config = $this->config;
-        $params = $config->getParameters($requestedType);
+        $config  = $this->config;
+        $params  = $config->getParameters($requestedType);
         $isAlias = $config->isAlias($requestedType);
-        $class = $isAlias
+        $class   = $isAlias
             ? $config->getClassForAlias($requestedType) ?? $requestedType
             : $requestedType;
 
@@ -109,7 +113,7 @@ private function getConfiguredParameters(string $requestedType) : array
         // A type configuration may define a parameter should be auto resolved
         // even it was defined earlier
         $params = array_filter($params, function ($value) {
-            return ($value !== '*');
+            return $value !== '*';
         });
 
         return $params;
@@ -121,13 +125,13 @@ private function getConfiguredParameters(string $requestedType) : array
      * @param string $type The type to check
      * @param string $requiredType The required type to check against
      */
-    private function isTypeOf(string $type, string $requiredType) : bool
+    private function isTypeOf(string $type, string $requiredType): bool
     {
         if ($this->config->isAlias($type)) {
             $type = $this->config->getClassForAlias($type) ?? $type;
         }
 
-        if ($type == $requiredType) {
+        if ($type === $requiredType) {
             return true;
         }
 
@@ -145,7 +149,7 @@ private function isTypeOf(string $type, string $requiredType) : bool
             || in_array($requiredType, $definition->getInterfaces());
     }
 
-    private function isUsableType(string $type, string $requiredType) : bool
+    private function isUsableType(string $type, string $requiredType): bool
     {
         return $this->isTypeOf($type, $requiredType)
             && ($this->container === null || $this->container->has($type));
@@ -153,7 +157,6 @@ private function isUsableType(string $type, string $requiredType) : bool
 
     /**
      * @param mixed $value
-     * @return string
      */
     private function getTypeNameFromValue($value): string
     {
@@ -164,41 +167,43 @@ private function getTypeNameFromValue($value): string
     /**
      * Check if the given value sadisfies the given type
      *
-     * @param mixed $value The value to check
+     * @param mixed  $value The value to check
      * @param string $type The typename to check against
      */
-    private function isValueOf($value, string $type) : bool
+    private function isValueOf($value, string $type): bool
     {
         if (! $this->isBuiltinType($type)) {
-            return ($value instanceof $type);
+            return $value instanceof $type;
         }
 
-        if ($type == 'callable') {
+        if ($type === 'callable') {
             return is_callable($value);
         }
 
-        if ($type == 'iterable') {
-            return (is_array($value) || ($value instanceof Traversable));
+        if ($type === 'iterable') {
+            return is_array($value) || $value instanceof Traversable;
         }
 
         $valueType = $this->getTypeNameFromValue($value);
-        $numerics = ['int', 'float'];
+        $numerics  = ['int', 'float'];
 
         // PHP accepts float for int and vice versa, as well as numeric string values
         if (in_array($type, $numerics)) {
             return in_array($valueType, $numerics) || (is_string($value) && is_numeric($value));
         }
 
-        return ($type == $valueType);
+        return $type === $valueType;
     }
 
-    private function isBuiltinType(string $type) : bool
+    private function isBuiltinType(string $type): bool
     {
         return in_array($type, $this->builtinTypes);
     }
 
     /**
      * @see DependencyResolverInterface::setContainer()
+     *
+     * @return $this
      */
     public function setContainer(ContainerInterface $container)
     {
@@ -206,10 +211,6 @@ public function setContainer(ContainerInterface $container)
         return $this;
     }
 
-    /**
-     * @param string $type
-     * @return bool
-     */
     private function isCallableType(string $type): bool
     {
         if ($this->config->isAlias($type)) {
@@ -232,17 +233,15 @@ private function isCallableType(string $type): bool
      * If the candidate is usable, its injection representation is returned
      *
      * @param mixed $value
-     * @param null|string $requiredType
-     * @return null|InjectionInterface
      */
-    private function prepareInjection($value, ?string $requiredType) : ?InjectionInterface
+    private function prepareInjection($value, ?string $requiredType): ?InjectionInterface
     {
-        if (($value instanceof ValueInjection) || ($value instanceof TypeInjection)) {
+        if ($value instanceof ValueInjection || $value instanceof TypeInjection) {
             return $value;
         }
 
         if (! $requiredType) {
-            $isAvailableInContainer = (is_string($value) && $this->container !== null && $this->container->has($value));
+            $isAvailableInContainer = is_string($value) && $this->container !== null && $this->container->has($value);
             return $isAvailableInContainer ? new TypeInjection($value) : new ValueInjection($value);
         }
 
@@ -267,17 +266,16 @@ private function prepareInjection($value, ?string $requiredType) : ?InjectionInt
      * {@inheritDoc}
      *
      * @see DependencyResolverInterface::resolveParameters()
-     * @param string $requestedType
-     * @param array $callTimeParameters
+     *
      * @throws Exception\UnexpectedValueException
      * @throws Exception\MissingPropertyException
      * @return InjectionInterface[]
      */
-    public function resolveParameters(string $requestedType, array $callTimeParameters = []) : array
+    public function resolveParameters(string $requestedType, array $callTimeParameters = []): array
     {
         $definition = $this->getClassDefinition($requestedType);
-        $params = $definition->getParameters();
-        $result = [];
+        $params     = $definition->getParameters();
+        $result     = [];
 
         if (empty($params)) {
             return $result;
@@ -317,7 +315,8 @@ public function resolveParameters(string $requestedType, array $callTimeParamete
                     continue;
                 }
 
-                if ($type === ContainerInterface::class
+                if (
+                    $type === ContainerInterface::class
                     || $this->container === null
                     || $this->container->has($type)
                 ) {
@@ -329,7 +328,7 @@ public function resolveParameters(string $requestedType, array $callTimeParamete
             // The parameter is required, but we can't find anything that is suitable
             if ($paramInfo->isRequired()) {
                 $isAlias = $this->config->isAlias($requestedType);
-                $class = $isAlias ? $this->config->getClassForAlias($requestedType) : $requestedType;
+                $class   = $isAlias ? $this->config->getClassForAlias($requestedType) : $requestedType;
                 throw new Exception\MissingPropertyException(sprintf(
                     'Could not resolve value for parameter "%s" of type %s in class %s (requested as %s)',
                     $name,
@@ -348,7 +347,7 @@ public function resolveParameters(string $requestedType, array $callTimeParamete
     /**
      * @see DependencyResolverInterface::resolvePreference()
      */
-    public function resolvePreference(string $type, ?string $context = null) : ?string
+    public function resolvePreference(string $type, ?string $context = null): ?string
     {
         if ($context) {
             $preference = $this->config->getTypePreference($type, $context);
diff --git a/src/Resolver/DependencyResolverInterface.php b/src/Resolver/DependencyResolverInterface.php
index f1659950..28c0f66a 100644
--- a/src/Resolver/DependencyResolverInterface.php
+++ b/src/Resolver/DependencyResolverInterface.php
@@ -10,6 +10,7 @@
 
 namespace Laminas\Di\Resolver;
 
+use Laminas\Di\Exception\MissingPropertyException;
 use Psr\Container\ContainerInterface;
 
 /**
@@ -32,24 +33,23 @@ public function setContainer(ContainerInterface $container);
     /**
      * Resolve a type prefernece
      *
-     * @param string $type The type/class name of the dependency to resolve the
-     *     preference for
-     * @param string $context The typename of the instance that is created or
+     * @param string      $type The type/class name of the dependency to resolve the
+     *          preference for
+     * @param null|string $context The typename of the instance that is created or
      *     in which the dependency should be injected
-     * @return string Returns the preferred type name or null if there is no
+     * @return null|string Returns the preferred type name or null if there is no
      *     preference
      */
-    public function resolvePreference(string $type, ?string $context = null) : ?string;
+    public function resolvePreference(string $type, ?string $context = null): ?string;
 
     /**
      * Resolves all parameters for injection
      *
      * @param string $class The class name to resolve the parameters for
-     * @param array $parameters Parameters to use as provided.
+     * @param array  $parameters Parameters to use as provided.
      * @return InjectionInterface[] Returns the injection parameters as indexed array. This
      *     array contains either TypeInjection or ValueInjection instances
-     * @throws \Laminas\Di\Exception\MissingPropertyException  When a parameter
-     *     could not be resolved
+     * @throws MissingPropertyException  When a parameter could not be resolved.
      */
-    public function resolveParameters(string $class, array $parameters = []) : array;
+    public function resolveParameters(string $class, array $parameters = []): array;
 }
diff --git a/src/Resolver/InjectionInterface.php b/src/Resolver/InjectionInterface.php
index fc1822f9..811ae30f 100644
--- a/src/Resolver/InjectionInterface.php
+++ b/src/Resolver/InjectionInterface.php
@@ -28,6 +28,7 @@
  * generators will use it to generate a factory.
  *
  * @internal
+ *
  * @see DependencyResolverInterface::resolveParameters() The resolver method's return type
  * @see \Laminas\Di\Injector::getInjectionValue()           The default injector implementation
  * @see TypeInjection                                    Implementation for injecting an instance of a specific type
@@ -49,9 +50,9 @@ public function toValue(ContainerInterface $container);
      *
      * This will be used by code generators to provide AoT factories
      *
-     * @throws LogicException When the injection is not exportable
+     * @throws LogicException When the injection is not exportable.
      */
-    public function export() : string;
+    public function export(): string;
 
     /**
      * Whether this injection can be exported as code or not
@@ -63,5 +64,5 @@ public function export() : string;
      * When this method returns false, a call to `export()` should throw a
      * `Laminas\Di\Exception\LogicException`
      */
-    public function isExportable() : bool;
+    public function isExportable(): bool;
 }
diff --git a/src/Resolver/TypeInjection.php b/src/Resolver/TypeInjection.php
index dbe167c2..d6aa32cc 100644
--- a/src/Resolver/TypeInjection.php
+++ b/src/Resolver/TypeInjection.php
@@ -13,6 +13,7 @@
 use Psr\Container\ContainerInterface;
 
 use function trigger_error;
+use function var_export;
 
 use const E_USER_DEPRECATED;
 
@@ -30,24 +31,23 @@ final class TypeInjection implements InjectionInterface
 
     /**
      * Constructor
-     *
-     * @param string $type
      */
     public function __construct(string $type)
     {
         $this->type = $type;
     }
 
-    public function export() : string
+    public function export(): string
     {
         return var_export($this->type, true);
     }
 
-    public function isExportable() : bool
+    public function isExportable(): bool
     {
         return true;
     }
 
+    /** @return mixed */
     public function toValue(ContainerInterface $container)
     {
         return $container->get($this->type);
@@ -55,10 +55,8 @@ public function toValue(ContainerInterface $container)
 
     /**
      * Reflects the type name
-     *
-     * @return string
      */
-    public function __toString() : string
+    public function __toString(): string
     {
         return $this->type;
     }
@@ -66,14 +64,15 @@ public function __toString() : string
     /**
      * Get the type name to look up for injection
      *
-     * @codeCoverageIgnore
      * @deprecated Since 3.1.0
+     *
      * @see toValue()
      * @see export()
      * @see __toString()
-     * @return string
+     *
+     * @codeCoverageIgnore
      */
-    public function getType() : string
+    public function getType(): string
     {
         trigger_error(__METHOD__ . ' is deprecated. Please migrate to __toString()', E_USER_DEPRECATED);
         return $this->type;
diff --git a/src/Resolver/ValueInjection.php b/src/Resolver/ValueInjection.php
index 526a05d7..5aa3ab15 100644
--- a/src/Resolver/ValueInjection.php
+++ b/src/Resolver/ValueInjection.php
@@ -43,10 +43,7 @@ public function __construct($value)
         $this->value = $value;
     }
 
-    /**
-     * @param array $state
-     */
-    public static function __set_state(array $state) : self
+    public static function __set_state(array $state): self
     {
         return new self($state['value']);
     }
@@ -54,10 +51,9 @@ public static function __set_state(array $state) : self
     /**
      * Exports the encapsulated value to php code
      *
-     * @return string
      * @throws LogicException
      */
-    public function export() : string
+    public function export(): string
     {
         if (! $this->isExportable()) {
             throw new LogicException('Unable to export value');
@@ -72,10 +68,8 @@ public function export() : string
 
     /**
      * Checks wether the value can be exported for code generation or not
-     *
-     * @return bool
      */
-    public function isExportable() : bool
+    public function isExportable(): bool
     {
         return $this->isExportableRecursive($this->value);
     }
@@ -86,7 +80,7 @@ public function isExportable() : bool
      *
      * @param mixed $value
      */
-    private function isExportableRecursive($value) : bool
+    private function isExportableRecursive($value): bool
     {
         if (is_scalar($value) || $value === null) {
             return true;
@@ -111,6 +105,7 @@ private function isExportableRecursive($value) : bool
         return false;
     }
 
+    /** @return mixed */
     public function toValue(ContainerInterface $container)
     {
         return $this->value;
@@ -120,12 +115,15 @@ public function toValue(ContainerInterface $container)
      * Get the value to inject
      *
      * @deprecated Since 3.1.0
+     *
      * @see toValue()
+     *
+     * @return mixed
      */
     public function getValue()
     {
         trigger_error(
-            __METHOD__ . ' is deprecated, please migrate to ' . __CLASS__ . '::toValue().',
+            __METHOD__ . ' is deprecated, please migrate to ' . self::class . '::toValue().',
             E_USER_DEPRECATED
         );
 
diff --git a/test/CodeGenerator/AbstractInjectorTest.php b/test/CodeGenerator/AbstractInjectorTest.php
index fde9dcee..8bb9584f 100644
--- a/test/CodeGenerator/AbstractInjectorTest.php
+++ b/test/CodeGenerator/AbstractInjectorTest.php
@@ -33,43 +33,39 @@ class AbstractInjectorTest extends TestCase
 {
     use ProphecyTrait;
 
-    /**
-     * @var InjectorInterface|ObjectProphecy
-     */
+    /** @var InjectorInterface|ObjectProphecy */
     private $decoratedInjectorProphecy;
 
-    /**
-     * @var ContainerInterface|ObjectProphecy
-     */
+    /** @var ContainerInterface|ObjectProphecy */
     private $containerProphecy;
 
     protected function setUp(): void
     {
         $this->decoratedInjectorProphecy = $this->prophesize(InjectorInterface::class);
-        $this->containerProphecy = $this->prophesize(ContainerInterface::class);
+        $this->containerProphecy         = $this->prophesize(ContainerInterface::class);
 
         parent::setUp();
     }
 
     public function createTestSubject(callable $factoriesProvider, bool $withContainer = true): AbstractInjector
     {
-        $injector = $this->decoratedInjectorProphecy->reveal();
+        $injector  = $this->decoratedInjectorProphecy->reveal();
         $container = $withContainer ? $this->containerProphecy->reveal() : null;
 
-        return new class($factoriesProvider, $injector, $container) extends AbstractInjector
+        return new class ($factoriesProvider, $injector, $container) extends AbstractInjector
         {
             private $provider;
 
             public function __construct(
                 callable $provider,
                 InjectorInterface $injector,
-                ContainerInterface $container = null
+                ?ContainerInterface $container = null
             ) {
                 $this->provider = $provider;
                 parent::__construct($injector, $container);
             }
 
-            protected function loadFactoryList() : void
+            protected function loadFactoryList(): void
             {
                 $this->factories = ($this->provider)();
             }
@@ -82,7 +78,7 @@ public function testImplementsContract()
         $prophecy->__invoke()
             ->shouldBeCalled()
             ->willReturn([
-                'SomeService' => 'SomeFactory'
+                'SomeService' => 'SomeFactory',
             ]);
 
         $subject = $this->createTestSubject($prophecy->reveal());
@@ -92,7 +88,7 @@ public function testImplementsContract()
     public function testCanCreateReturnsTrueWhenAFactoryIsAvailable()
     {
         $className = uniqid('SomeClass');
-        $provider = function () use ($className) {
+        $provider  = function () use ($className) {
             return [$className => 'SomeClassFactory'];
         };
 
@@ -106,9 +102,9 @@ public function testCanCreateReturnsTrueWhenAFactoryIsAvailable()
 
     public function testCanCreateUsesDecoratedInjectorWithoutFactory()
     {
-        $missingClass = uniqid('SomeClass');
+        $missingClass  = uniqid('SomeClass');
         $existingClass = uniqid('SomeOtherClass');
-        $provider = function () {
+        $provider      = function () {
             return [];
         };
 
@@ -130,11 +126,11 @@ public function testCanCreateUsesDecoratedInjectorWithoutFactory()
 
     public function testCreateUsesFactory()
     {
-        $factory = $this->prophesize(FactoryInterface::class);
+        $factory   = $this->prophesize(FactoryInterface::class);
         $className = uniqid('SomeClass');
-        $params = ['someArg' => uniqid()];
-        $expected = new stdClass();
-        $provider = function () use ($className, $factory) {
+        $params    = ['someArg' => uniqid()];
+        $expected  = new stdClass();
+        $provider  = function () use ($className, $factory) {
             return [$className => $factory->reveal()];
         };
 
@@ -157,9 +153,9 @@ public function testCreateUsesFactory()
     public function testCreateUsesDecoratedInjectorIfNoFactoryIsAvailable()
     {
         $className = uniqid('SomeClass');
-        $expected = new stdClass();
-        $params = [ 'someArg' => uniqid() ];
-        $provider = function () {
+        $expected  = new stdClass();
+        $params    = ['someArg' => uniqid()];
+        $provider  = function () {
             return [];
         };
 
@@ -174,10 +170,10 @@ public function testCreateUsesDecoratedInjectorIfNoFactoryIsAvailable()
 
     public function testConstructionWithoutContainerUsesDefaultContainer()
     {
-        $factory = $this->prophesize(FactoryInterface::class);
+        $factory   = $this->prophesize(FactoryInterface::class);
         $className = uniqid('SomeClass');
-        $expected = new stdClass();
-        $provider = function () use ($className, $factory) {
+        $expected  = new stdClass();
+        $provider  = function () use ($className, $factory) {
             return [$className => $factory->reveal()];
         };
 
@@ -196,7 +192,7 @@ public function testFactoryIsCreatedFromClassNameString()
         });
 
         $factoryInstancesProperty = new ReflectionProperty(AbstractInjector::class, 'factoryInstances');
-        $factoriesProperty = new ReflectionProperty(AbstractInjector::class, 'factories');
+        $factoriesProperty        = new ReflectionProperty(AbstractInjector::class, 'factories');
         $factoryInstancesProperty->setAccessible(true);
         $factoriesProperty->setAccessible(true);
 
diff --git a/test/CodeGenerator/AutoloadGeneratorTest.php b/test/CodeGenerator/AutoloadGeneratorTest.php
index 9a69c3c2..3a6e83a3 100644
--- a/test/CodeGenerator/AutoloadGeneratorTest.php
+++ b/test/CodeGenerator/AutoloadGeneratorTest.php
@@ -18,13 +18,13 @@
  */
 class AutoloadGeneratorTest extends TestCase
 {
-    const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated';
-
     use GeneratorTestTrait;
+    
+    private const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated';
 
     public function testGenerateCreatesFiles()
     {
-        $classmap = [];
+        $classmap  = [];
         $generator = new AutoloadGenerator(self::DEFAULT_NAMESPACE);
         $generator->setOutputDirectory($this->dir);
         $generator->generate($classmap);
@@ -38,8 +38,8 @@ public function testGeneratedAutoloaderClass()
         $generator = new AutoloadGenerator(self::DEFAULT_NAMESPACE);
         $generator->setOutputDirectory($this->dir);
         $classmap = [
-            'FooClass' => 'FooClass.php',
-            'Bar\\Class' => 'Bar/Class.php'
+            'FooClass'   => 'FooClass.php',
+            'Bar\\Class' => 'Bar/Class.php',
         ];
 
         $generator->generate($classmap);
@@ -55,8 +55,8 @@ public function testGeneratedAutoloadFile()
         $generator = new AutoloadGenerator(self::DEFAULT_NAMESPACE);
         $generator->setOutputDirectory($this->dir);
         $classmap = [
-            'FooClass' => 'FooClass.php',
-            'Bar\\Class' => 'Bar/Class.php'
+            'FooClass'   => 'FooClass.php',
+            'Bar\\Class' => 'Bar/Class.php',
         ];
 
         $generator->generate($classmap);
diff --git a/test/CodeGenerator/FactoryGeneratorTest.php b/test/CodeGenerator/FactoryGeneratorTest.php
index 482d1f7c..17f17c76 100644
--- a/test/CodeGenerator/FactoryGeneratorTest.php
+++ b/test/CodeGenerator/FactoryGeneratorTest.php
@@ -17,19 +17,21 @@
 use LaminasTest\Di\TestAsset;
 use PHPUnit\Framework\TestCase;
 
+use function str_replace;
+
 /**
  * FactoryGenerator test case.
  */
 class FactoryGeneratorTest extends TestCase
 {
-    const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated\Factory';
-
     use GeneratorTestTrait;
+    
+    private const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated\Factory';
 
     public function testGenerateCreatesFiles()
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new FactoryGenerator($config, $resolver, self::DEFAULT_NAMESPACE);
 
         $generator->setOutputDirectory($this->dir . '/Factory');
@@ -40,8 +42,8 @@ public function testGenerateCreatesFiles()
 
     public function testGenerateBuildsUpClassMap()
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new FactoryGenerator($config, $resolver, self::DEFAULT_NAMESPACE);
 
         $generator->setOutputDirectory($this->dir . '/FactoryMultiple');
@@ -59,8 +61,8 @@ public function testGenerateBuildsUpClassMap()
 
     public function testGenerateForClassWithoutParams()
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new FactoryGenerator($config, $resolver, self::DEFAULT_NAMESPACE);
 
         $generator->setOutputDirectory($this->dir . '/Factory');
@@ -74,8 +76,8 @@ public function testGenerateForClassWithoutParams()
 
     public function testGenerateForClassWithParams()
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new FactoryGenerator($config, $resolver, self::DEFAULT_NAMESPACE);
 
         $generator->setOutputDirectory($this->dir . '/Factory');
diff --git a/test/CodeGenerator/GeneratorTestTrait.php b/test/CodeGenerator/GeneratorTestTrait.php
index 945bec68..f76cc0c9 100644
--- a/test/CodeGenerator/GeneratorTestTrait.php
+++ b/test/CodeGenerator/GeneratorTestTrait.php
@@ -15,14 +15,10 @@
 
 trait GeneratorTestTrait
 {
-    /**
-     * @var vfsStreamDirectory
-     */
+    /** @var vfsStreamDirectory */
     private $root;
 
-    /**
-     * @var string
-     */
+    /** @var string */
     private $dir;
 
     /**
@@ -33,6 +29,6 @@ protected function setUp(): void
         parent::setUp();
 
         $this->root = vfsStream::setup('laminas-di');
-        $this->dir = $this->root->url();
+        $this->dir  = $this->root->url();
     }
 }
diff --git a/test/CodeGenerator/InjectorGeneratorTest.php b/test/CodeGenerator/InjectorGeneratorTest.php
index 1d6603f7..72c15111 100644
--- a/test/CodeGenerator/InjectorGeneratorTest.php
+++ b/test/CodeGenerator/InjectorGeneratorTest.php
@@ -20,25 +20,27 @@
 use Prophecy\PhpUnit\ProphecyTrait;
 use Psr\Log\LoggerInterface;
 
+use function uniqid;
+
 /**
  * FactoryGenerator test case.
  */
 class InjectorGeneratorTest extends TestCase
 {
-    const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated';
-
     use GeneratorTestTrait;
     use ProphecyTrait;
 
-    public function testGenerateCreatesFiles() : void
+    private const DEFAULT_NAMESPACE = 'LaminasTest\Di\Generated';
+
+    public function testGenerateCreatesFiles(): void
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new InjectorGenerator($config, $resolver, self::DEFAULT_NAMESPACE);
 
         $generator->setOutputDirectory($this->dir);
         $generator->generate([
-            TestAsset\RequiresA::class
+            TestAsset\RequiresA::class,
         ]);
 
         $this->assertFileExists($this->dir . '/Factory/LaminasTest/Di/TestAsset/RequiresAFactory.php');
@@ -47,13 +49,13 @@ public function testGenerateCreatesFiles() : void
         $this->assertFileExists($this->dir . '/autoload.php');
     }
 
-    public function testGeneratedInjectorClassCode() : void
+    public function testGeneratedInjectorClassCode(): void
     {
         // The namespace must be unique, Since we will attempt to load the
         // generated class
         $namespace = self::DEFAULT_NAMESPACE;
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new InjectorGenerator($config, $resolver, $namespace);
 
         $generator->setOutputDirectory($this->dir);
@@ -65,19 +67,19 @@ public function testGeneratedInjectorClassCode() : void
         );
     }
 
-    public function testGeneratedFactoryListCode() : void
+    public function testGeneratedFactoryListCode(): void
     {
         // The namespace must be unique, Since we will attempt to load the
         // generated class
         $namespace = self::DEFAULT_NAMESPACE;
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new InjectorGenerator($config, $resolver, $namespace);
 
         $generator->setOutputDirectory($this->dir);
         $generator->generate([
             TestAsset\A::class,
-            TestAsset\B::class
+            TestAsset\B::class,
         ]);
 
         self::assertFileEquals(
@@ -86,11 +88,11 @@ public function testGeneratedFactoryListCode() : void
         );
     }
 
-    public function testSetCustomNamespace() : void
+    public function testSetCustomNamespace(): void
     {
-        $expected = self::DEFAULT_NAMESPACE . uniqid();
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
+        $expected  = self::DEFAULT_NAMESPACE . uniqid();
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
         $generator = new InjectorGenerator($config, $resolver, $expected);
 
         $this->assertEquals($expected, $generator->getNamespace());
@@ -98,14 +100,14 @@ public function testSetCustomNamespace() : void
 
     public function testGeneratorLogsDebugForEachClass()
     {
-        $config = new Config();
+        $config   = new Config();
         $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
-        $logger = $this->prophesize(LoggerInterface::class);
+        $logger   = $this->prophesize(LoggerInterface::class);
 
         $generator = new InjectorGenerator($config, $resolver, null, $logger->reveal());
         $generator->setOutputDirectory($this->dir);
         $generator->generate([
-            TestAsset\B::class
+            TestAsset\B::class,
         ]);
 
         $logger->debug(Argument::containingString(TestAsset\B::class))->shouldHaveBeenCalled();
@@ -113,14 +115,14 @@ public function testGeneratorLogsDebugForEachClass()
 
     public function testGeneratorLogsErrorWhenFactoryGenerationFailed()
     {
-        $config = new Config();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
-        $logger = $this->prophesize(LoggerInterface::class);
+        $config    = new Config();
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), $config);
+        $logger    = $this->prophesize(LoggerInterface::class);
         $generator = new InjectorGenerator($config, $resolver, null, $logger->reveal());
 
         $generator->setOutputDirectory($this->dir);
         $generator->generate([
-            'Bad.And.Undefined.ClassName'
+            'Bad.And.Undefined.ClassName',
         ]);
 
         $logger->error(Argument::containingString('Bad.And.Undefined.ClassName'))->shouldHaveBeenCalled();
diff --git a/test/ConfigProviderTest.php b/test/ConfigProviderTest.php
index 1ff105b0..d7a1650d 100644
--- a/test/ConfigProviderTest.php
+++ b/test/ConfigProviderTest.php
@@ -14,7 +14,6 @@
 use Laminas\Di\ConfigInterface;
 use Laminas\Di\ConfigProvider;
 use Laminas\Di\InjectorInterface;
-use PHPUnit\Framework\Constraint\IsType;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -22,15 +21,15 @@
  */
 class ConfigProviderTest extends TestCase
 {
-    public function testInstanceIsInvokable() : void
+    public function testInstanceIsInvokable(): void
     {
         $this->assertIsCallable(new ConfigProvider());
     }
 
-    public function testProvidesDependencies() : void
+    public function testProvidesDependencies(): void
     {
         $provider = new ConfigProvider();
-        $result = $provider();
+        $result   = $provider();
 
         $this->assertArrayHasKey('dependencies', $result);
         $this->assertEquals($provider->getDependencyConfig(), $result['dependencies']);
@@ -39,7 +38,7 @@ public function testProvidesDependencies() : void
     /**
      * Provides service names that should be defined with a factory
      */
-    public function provideExpectedServicesWithFactory() : iterable
+    public function provideExpectedServicesWithFactory(): iterable
     {
         return [
             //               service name
@@ -52,7 +51,7 @@ public function provideExpectedServicesWithFactory() : iterable
     /**
      * @dataProvider provideExpectedServicesWithFactory
      */
-    public function testProvidesFactoryDefinition(string $serviceName) : void
+    public function testProvidesFactoryDefinition(string $serviceName): void
     {
         $result = (new ConfigProvider())->getDependencyConfig();
         $this->assertArrayHasKey($serviceName, $result['factories']);
diff --git a/test/ConfigTest.php b/test/ConfigTest.php
index c4b33dfe..2fe5ff45 100644
--- a/test/ConfigTest.php
+++ b/test/ConfigTest.php
@@ -15,14 +15,14 @@
 use PHPUnit\Framework\TestCase;
 use stdClass;
 
+use function uniqid;
+
 /**
  * @coversDefaultClass Laminas\Di\Config
  */
 class ConfigTest extends TestCase
 {
-    /**
-     * @var array
-     */
+    /** @var array */
     private $fixture;
 
     protected function setUp(): void
@@ -92,7 +92,7 @@ public function testSetParameters()
     {
         $instance = new Config();
         $expected = [
-            'bar' => 'Baz'
+            'bar' => 'Baz',
         ];
 
         $this->assertEmpty($instance->getParameters('Foo'));
@@ -116,18 +116,18 @@ public function testSetTypePreferenceForTypeContext()
         $this->assertEquals('Bar', $instance->getTypePreference('Foo', 'Baz'));
     }
 
-    public function provideValidClassNames()
+    public function provideValidClassNames(): array
     {
         return [
-            'class' => [ TestAsset\A::class ],
-            'interface' => [ TestAsset\DummyInterface::class ],
+            'class'     => [TestAsset\A::class],
+            'interface' => [TestAsset\DummyInterface::class],
         ];
     }
 
     /**
      * @dataProvider provideValidClassNames
      */
-    public function testSetAlias($className)
+    public function testSetAlias(string $className)
     {
         $instance = new Config();
 
@@ -139,10 +139,10 @@ public function testSetAlias($className)
         $this->assertEquals($className, $instance->getClassForAlias('Foo.Bar'));
     }
 
-    public function provideInvalidClassNames()
+    public function provideInvalidClassNames(): array
     {
         return [
-            'badname' => [ 'Bad.Class.Name.For.PHP' ],
+            'badname' => ['Bad.Class.Name.For.PHP'],
         ];
     }
 
diff --git a/test/Container/AutowireFactoryTest.php b/test/Container/AutowireFactoryTest.php
index 5a5cd535..922b4035 100644
--- a/test/Container/AutowireFactoryTest.php
+++ b/test/Container/AutowireFactoryTest.php
@@ -25,9 +25,7 @@
  */
 class AutowireFactoryTest extends TestCase
 {
-    /**
-     * @var AutowireFactory
-     */
+    /** @var AutowireFactory */
     private $instance;
 
     /**
@@ -48,7 +46,7 @@ protected function tearDown(): void
         parent::tearDown();
     }
 
-    private function createContainerMock(InjectorInterface $injector)
+    private function createContainerMock(InjectorInterface $injector): ContainerInterface
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
         $container->method('has')->with(InjectorInterface::class)->willReturn(true);
@@ -67,12 +65,12 @@ public function testCanCreateUsesInjector()
             ->willReturn(true);
 
         $container = $this->createContainerMock($injector);
-        $result = $this->instance->canCreate($container, 'AnyClass');
+        $result    = $this->instance->canCreate($container, 'AnyClass');
 
         $this->assertTrue($result);
     }
 
-    private function createContainerForCreateTest($className, $expected)
+    private function createContainerForCreateTest(string $className, object $expected): ContainerInterface
     {
         $injector = $this->getMockBuilder(InjectorInterface::class)->getMockForAbstractClass();
         $injector->method('canCreate')
@@ -88,20 +86,20 @@ private function createContainerForCreateTest($className, $expected)
 
     public function testCreateUsesInjector()
     {
-        $expected = new stdClass();
+        $expected  = new stdClass();
         $className = 'SomeClassName';
         $container = $this->createContainerForCreateTest($className, $expected);
-        $result = $this->instance->create($container, $className);
+        $result    = $this->instance->create($container, $className);
 
         $this->assertSame($expected, $result);
     }
 
     public function testInstanceIsInvokable()
     {
-        $expected = new stdClass();
+        $expected  = new stdClass();
         $className = 'SomeOtherClassName';
         $container = $this->createContainerForCreateTest($className, $expected);
-        $factory = $this->instance;
+        $factory   = $this->instance;
 
         $result = $factory($container, $className);
         $this->assertSame($expected, $result);
diff --git a/test/Container/ConfigFactoryTest.php b/test/Container/ConfigFactoryTest.php
index 114b236f..83823dd1 100644
--- a/test/Container/ConfigFactoryTest.php
+++ b/test/Container/ConfigFactoryTest.php
@@ -13,17 +13,23 @@
 use Laminas\Di\ConfigInterface;
 use Laminas\Di\Container\ConfigFactory;
 use PHPUnit\Framework\Error\Deprecated as DeprecatedError;
+use PHPUnit\Framework\MockObject\MockBuilder;
 use PHPUnit\Framework\TestCase;
 use Psr\Container\ContainerInterface;
 
+use function restore_error_handler;
+use function set_error_handler;
+use function strstr;
+use function uniqid;
+
+use const E_USER_DEPRECATED;
+
 /**
  * @coversDefaultClass Laminas\Di\Container\ConfigFactory
  */
 class ConfigFactoryTest extends TestCase
 {
-    /**
-     * @var \PHPUnit_Framework_MockObject_MockBuilder
-     */
+    /** @var MockBuilder */
     private $containerBuilder;
 
     protected function setUp(): void
@@ -67,7 +73,7 @@ public function testCreateRequestsContainerForConfigServiceGracefully()
         $this->assertInstanceOf(ConfigInterface::class, $result);
     }
 
-    private function createContainerWithConfig($config)
+    private function createContainerWithConfig(array $config): ContainerInterface
     {
         $container = $this->containerBuilder->getMockForAbstractClass();
         $container->expects($this->atLeastOnce())
@@ -86,7 +92,7 @@ private function createContainerWithConfig($config)
     public function testCreateUsesConfigFromContainer()
     {
         $expectedPreference = uniqid('SomePreference');
-        $container = $this->createContainerWithConfig([
+        $container          = $this->createContainerWithConfig([
             'dependencies' => [
                 'auto' => [
                     'preferences' => [
@@ -103,7 +109,7 @@ public function testCreateUsesConfigFromContainer()
     public function testLegacyConfigIsRespected()
     {
         $expectedPreference = uniqid('SomePreference');
-        $container = $this->createContainerWithConfig([
+        $container          = $this->createContainerWithConfig([
             'di' => [
                 'instance' => [
                     'preferences' => [
@@ -114,7 +120,7 @@ public function testLegacyConfigIsRespected()
         ]);
 
         set_error_handler(function ($errno, $errstr) {
-            if ($errno !== \E_USER_DEPRECATED) {
+            if ($errno !== E_USER_DEPRECATED) {
                 return false;
             }
 
@@ -122,7 +128,7 @@ public function testLegacyConfigIsRespected()
                 // Not the error we're looking for...
                 return false;
             }
-        }, \E_USER_DEPRECATED);
+        }, E_USER_DEPRECATED);
         $result = (new ConfigFactory())->create($container);
         restore_error_handler();
 
diff --git a/test/Container/GeneratorFactoryTest.php b/test/Container/GeneratorFactoryTest.php
index 5ca9d099..f400ef65 100644
--- a/test/Container/GeneratorFactoryTest.php
+++ b/test/Container/GeneratorFactoryTest.php
@@ -21,26 +21,29 @@
 use Psr\Container\ContainerInterface;
 use Psr\Log\LoggerInterface;
 use Psr\Log\NullLogger;
+use ReflectionClass;
+
+use function uniqid;
 
 /**
  * @covers Laminas\Di\Container\GeneratorFactory
  */
 class GeneratorFactoryTest extends TestCase
 {
-    public function testInvokeCreatesGenerator() : void
+    public function testInvokeCreatesGenerator(): void
     {
         $injector = new Injector();
-        $factory = new GeneratorFactory();
+        $factory  = new GeneratorFactory();
 
         $result = $factory->create($injector->getContainer());
         $this->assertInstanceOf(InjectorGenerator::class, $result);
     }
 
-    public function testFactoryUsesDiConfigContainer() : void
+    public function testFactoryUsesDiConfigContainer(): void
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
         $container->method('has')->willReturnCallback(function ($type) {
-            return $type == ConfigInterface::class;
+            return $type === ConfigInterface::class;
         });
 
         $container->expects($this->atLeastOnce())
@@ -52,10 +55,10 @@ public function testFactoryUsesDiConfigContainer() : void
         $factory->create($container);
     }
 
-    public function testSetsOutputDirectoryFromConfig() : void
+    public function testSetsOutputDirectoryFromConfig(): void
     {
-        $vfs = vfsStream::setup(uniqid('laminas-di'));
-        $expected = $vfs->url();
+        $vfs       = vfsStream::setup(uniqid('laminas-di'));
+        $expected  = $vfs->url();
         $container = new ServiceManager();
         $container->setService('config', [
             'dependencies' => [
@@ -71,9 +74,9 @@ public function testSetsOutputDirectoryFromConfig() : void
         $this->assertEquals($expected, $generator->getOutputDirectory());
     }
 
-    public function testSetsNamespaceFromConfig() : void
+    public function testSetsNamespaceFromConfig(): void
     {
-        $expected = 'LaminasTest\\Di\\' . uniqid('Generated');
+        $expected  = 'LaminasTest\\Di\\' . uniqid('Generated');
         $container = new ServiceManager();
         $container->setService('config', [
             'dependencies' => [
@@ -89,19 +92,19 @@ public function testSetsNamespaceFromConfig() : void
         $this->assertEquals($expected, $generator->getNamespace());
     }
 
-    public function testDefaultLogger() : void
+    public function testDefaultLogger(): void
     {
-        $generator = (new GeneratorFactory())->create(new ServiceManager());
-        $reflection = new \ReflectionClass($generator);
-        $property = $reflection->getProperty('logger');
+        $generator  = (new GeneratorFactory())->create(new ServiceManager());
+        $reflection = new ReflectionClass($generator);
+        $property   = $reflection->getProperty('logger');
         $property->setAccessible(true);
 
         $this->assertInstanceOf(NullLogger::class, $property->getValue($generator));
     }
 
-    public function testSetsLoggerFromConfig() : void
+    public function testSetsLoggerFromConfig(): void
     {
-        $logger = $this->getMockBuilder(LoggerInterface::class)
+        $logger    = $this->getMockBuilder(LoggerInterface::class)
             ->getMockForAbstractClass();
         $container = new ServiceManager();
         $container->setService('MyCustomLogger', $logger);
@@ -115,15 +118,15 @@ public function testSetsLoggerFromConfig() : void
             ],
         ]);
 
-        $generator = (new GeneratorFactory())->create($container);
-        $reflection = new \ReflectionClass($generator);
-        $property = $reflection->getProperty('logger');
+        $generator  = (new GeneratorFactory())->create($container);
+        $reflection = new ReflectionClass($generator);
+        $property   = $reflection->getProperty('logger');
         $property->setAccessible(true);
 
         $this->assertNotInstanceOf(NullLogger::class, $property->getValue($generator));
     }
 
-    public function testInvokeCallsCreate() : void
+    public function testInvokeCallsCreate(): void
     {
         $mock = $this->getMockBuilder(GeneratorFactory::class)
             ->setMethods(['create'])
diff --git a/test/Container/InjectorFactoryTest.php b/test/Container/InjectorFactoryTest.php
index 5cc7cbfd..5a428334 100644
--- a/test/Container/InjectorFactoryTest.php
+++ b/test/Container/InjectorFactoryTest.php
@@ -13,7 +13,6 @@
 use Laminas\Di\ConfigInterface;
 use Laminas\Di\Container\InjectorFactory;
 use Laminas\Di\InjectorInterface;
-use PHPUnit\Framework\Constraint\IsType;
 use PHPUnit\Framework\TestCase;
 use Psr\Container\ContainerInterface;
 use ReflectionObject;
@@ -31,7 +30,7 @@ public function testFactoryIsInvokable()
     public function testCreateWillReturnAnInjectorInstance()
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
-        $result = (new InjectorFactory())->create($container);
+        $result    = (new InjectorFactory())->create($container);
 
         $this->assertInstanceOf(InjectorInterface::class, $result);
     }
@@ -39,15 +38,15 @@ public function testCreateWillReturnAnInjectorInstance()
     public function testInvokeWillReturnAnInjectorInstance()
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
-        $factory = new InjectorFactory();
-        $result = $factory($container);
+        $factory   = new InjectorFactory();
+        $result    = $factory($container);
 
         $this->assertInstanceOf(InjectorInterface::class, $result);
     }
 
     public function testUsesConfigServiceFromContainer()
     {
-        $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
+        $container  = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
         $configMock = $this->getMockBuilder(ConfigInterface::class)->getMockForAbstractClass();
         $container->expects($this->atLeastOnce())
             ->method('has')
@@ -62,7 +61,7 @@ public function testUsesConfigServiceFromContainer()
         $injector = (new InjectorFactory())->create($container);
 
         $reflection = new ReflectionObject($injector);
-        $property = $reflection->getProperty('config');
+        $property   = $reflection->getProperty('config');
 
         $property->setAccessible(true);
         $this->assertSame($configMock, $property->getValue($injector));
diff --git a/test/Container/ServiceManager/AutowireFactoryTest.php b/test/Container/ServiceManager/AutowireFactoryTest.php
index 024a313c..a476235f 100644
--- a/test/Container/ServiceManager/AutowireFactoryTest.php
+++ b/test/Container/ServiceManager/AutowireFactoryTest.php
@@ -14,6 +14,7 @@
 use Laminas\Di\Container\AutowireFactory as GenericAutowireFactory;
 use Laminas\Di\Container\ServiceManager\AutowireFactory;
 use PHPUnit\Framework\TestCase;
+use PHPUnit_Framework_MockObject_MockObject;
 use stdClass;
 
 /**
@@ -24,7 +25,7 @@
 class AutowireFactoryTest extends TestCase
 {
     /**
-     * @return \PHPUnit_Framework_MockObject_MockObject
+     * @return PHPUnit_Framework_MockObject_MockObject
      */
     private function createGenericFactoryMock()
     {
@@ -36,8 +37,8 @@ private function createGenericFactoryMock()
     public function testInvokeIsPassedToGenericFactory()
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
-        $mock = $this->createGenericFactoryMock();
-        $expected = new stdClass();
+        $mock      = $this->createGenericFactoryMock();
+        $expected  = new stdClass();
         $className = 'AnyClassName';
 
         // Container must not be called directly
@@ -57,7 +58,7 @@ public function testInvokeIsPassedToGenericFactory()
     public function testCanCreateIsPassedToGenericFactory()
     {
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
-        $mock = $this->createGenericFactoryMock();
+        $mock      = $this->createGenericFactoryMock();
         $className = 'AnyClassName';
 
         // Container must not be called directly
diff --git a/test/DefaultContainerTest.php b/test/DefaultContainerTest.php
index d3802cdc..7a6f42f4 100644
--- a/test/DefaultContainerTest.php
+++ b/test/DefaultContainerTest.php
@@ -12,16 +12,19 @@
 
 use Laminas\Di\DefaultContainer;
 use Laminas\Di\InjectorInterface;
+use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use stdClass;
 
+use function uniqid;
+
 /**
  * @coversDefaultClass Laminas\Di\DefaultContainer
  */
 class DefaultContainerTest extends TestCase
 {
     /**
-     * @return \PHPUnit_Framework_MockObject_MockObject|InjectorInterface
+     * @return MockObject|InjectorInterface
      */
     private function mockInjector()
     {
@@ -36,8 +39,8 @@ public function testSetInstance()
         $injector = $this->mockInjector();
         $injector->expects($this->never())->method($this->logicalNot($this->equalTo('')));
         $container = new DefaultContainer($injector);
-        $expected = new stdClass();
-        $key = uniqid('Test');
+        $expected  = new stdClass();
+        $key       = uniqid('Test');
 
         $container->setInstance($key, $expected);
         $this->assertTrue($container->has($key));
@@ -50,7 +53,7 @@ public function testSetInstance()
     public function testHasConsultatesInjector()
     {
         $injector = $this->mockInjector();
-        $key = uniqid('TestClass');
+        $key      = uniqid('TestClass');
 
         $injector->expects($this->atLeastOnce())
             ->method('canCreate')
@@ -63,9 +66,8 @@ public function testHasConsultatesInjector()
             ->with($key)
             ->willReturn(false);
 
-        $container = new DefaultContainer($injector);
-        $container2 = new DefaultContainer($injector2)
-        ;
+        $container  = new DefaultContainer($injector);
+        $container2 = new DefaultContainer($injector2);
         $this->assertTrue($container->has($key));
         $this->assertFalse($container2->has($key));
     }
@@ -76,7 +78,7 @@ public function testHasConsultatesInjector()
     public function testGetUsesInjector()
     {
         $injector = $this->mockInjector();
-        $key = uniqid('TestClass');
+        $key      = uniqid('TestClass');
         $expected = new stdClass();
 
         $injector->expects($this->atLeastOnce())
@@ -93,7 +95,7 @@ public function testGetUsesInjector()
     public function testGetInstanciatesOnlyOnce()
     {
         $injector = $this->mockInjector();
-        $key = uniqid('TestClass');
+        $key      = uniqid('TestClass');
 
         $injector->expects($this->once())
             ->method('create')
@@ -103,7 +105,7 @@ public function testGetInstanciatesOnlyOnce()
             });
 
         $container = new DefaultContainer($injector);
-        $expected = $container->get($key);
+        $expected  = $container->get($key);
         $this->assertSame($expected, $container->get($key));
     }
 }
diff --git a/test/Definition/Reflection/ClassDefinitionTest.php b/test/Definition/Reflection/ClassDefinitionTest.php
index bafa67f9..26d88792 100644
--- a/test/Definition/Reflection/ClassDefinitionTest.php
+++ b/test/Definition/Reflection/ClassDefinitionTest.php
@@ -17,6 +17,8 @@
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 
+use function sort;
+
 /**
  * @coversDefaultClass Laminas\Di\Definition\Reflection\ClassDefinition
  */
@@ -33,7 +35,7 @@ public function testGetReflection()
     public function testGetSupertypesReturnsAllClasses()
     {
         $supertypes = (new ClassDefinition(HierarchyAsset\C::class))->getSupertypes();
-        $expected = [
+        $expected   = [
             HierarchyAsset\A::class,
             HierarchyAsset\B::class,
         ];
@@ -59,7 +61,7 @@ public function testGetSupertypesReturnsEmptyArray()
      */
     public function testGetInterfacesReturnsAllInterfaces()
     {
-        $result = (new ClassDefinition(HierarchyAsset\C::class))->getInterfaces();
+        $result   = (new ClassDefinition(HierarchyAsset\C::class))->getInterfaces();
         $expected = [
             HierarchyAsset\InterfaceA::class,
             HierarchyAsset\InterfaceB::class,
@@ -85,7 +87,7 @@ public function testGetInterfacesReturnsArray()
         $this->assertEmpty($result);
     }
 
-    public function provideClassesWithParameters()
+    public function provideClassesWithParameters(): array
     {
         return [
             'optional' => [ConstructorAsset\OptionalArguments::class, 2],
@@ -96,7 +98,7 @@ public function provideClassesWithParameters()
     /**
      * @dataProvider provideClassesWithParameters
      */
-    public function testGetParametersReturnsAllParameters($class, $expectedItemCount)
+    public function testGetParametersReturnsAllParameters(string $class, int $expectedItemCount)
     {
         $result = (new ClassDefinition($class))->getParameters();
 
@@ -114,7 +116,7 @@ public function testGetParametersWithScalarTypehints()
         $this->assertContainsOnlyInstancesOf(ParameterInterface::class, $result);
     }
 
-    public function provideParameterlessClasses()
+    public function provideParameterlessClasses(): array
     {
         return [
             'noargs'      => [ConstructorAsset\EmptyConstructor::class],
@@ -125,7 +127,7 @@ public function provideParameterlessClasses()
     /**
      * @dataProvider provideParameterlessClasses
      */
-    public function testGetParametersReturnsAnArray($class)
+    public function testGetParametersReturnsAnArray(string $class)
     {
         $result = (new ClassDefinition($class))->getParameters();
         $this->assertIsArray($result);
diff --git a/test/Definition/Reflection/ParameterTest.php b/test/Definition/Reflection/ParameterTest.php
index f8743920..5f32fb08 100644
--- a/test/Definition/Reflection/ParameterTest.php
+++ b/test/Definition/Reflection/ParameterTest.php
@@ -23,7 +23,7 @@ class ParameterTest extends TestCase
 {
     use ParameterTestTrait;
 
-    public function provideGeneralParameters()
+    public function provideGeneralParameters(): array
     {
         $params = (new ReflectionClass(TestAsset\Parameters::class))->getMethod('general')->getParameters();
 
@@ -37,12 +37,13 @@ public function provideGeneralParameters()
 
     /**
      * @dataProvider provideGeneralParameters
+     * @param mixed $expectedDefault
      */
     public function testParamterReflectedCorrectly(
         ReflectionParameter $reflection,
-        $expectedName,
-        $expectedPosition,
-        $expectRequired,
+        string $expectedName,
+        int $expectedPosition,
+        bool $expectRequired,
         $expectedDefault
     ) {
         $instance = new Parameter($reflection);
@@ -61,7 +62,7 @@ public function testParamterReflectedCorrectly(
     /**
      * @dataProvider provideTypehintedParameterReflections
      */
-    public function testTypehintedParameter(ReflectionParameter $reflection, $expectedType)
+    public function testTypehintedParameter(ReflectionParameter $reflection, ?string $expectedType)
     {
         $required = new Parameter($reflection);
         $this->assertSame($expectedType, $required->getType());
@@ -78,7 +79,7 @@ public function testTypelessParamter(ReflectionParameter $reflection)
         $this->assertFalse($param->isBuiltin(), 'Parameter must not be exposed builtin');
     }
 
-    public function provideScalarTypehintedReflections()
+    public function provideScalarTypehintedReflections(): array
     {
         return $this->buildReflectionArgsFromClass(TestAsset\ScalarTypehintParameters::class);
     }
@@ -86,7 +87,7 @@ public function provideScalarTypehintedReflections()
     /**
      * @dataProvider provideBuiltinTypehintedReflections
      */
-    public function testBuiltinTypehintedParameters(ReflectionParameter $reflection, $expectedType)
+    public function testBuiltinTypehintedParameters(ReflectionParameter $reflection, string $expectedType)
     {
         $param = new Parameter($reflection);
         $this->assertTrue($param->isBuiltin());
@@ -96,7 +97,7 @@ public function testBuiltinTypehintedParameters(ReflectionParameter $reflection,
     /**
      * @dataProvider provideScalarTypehintedReflections
      */
-    public function testScalarTypehintedParameters(ReflectionParameter $reflection, $expectedType)
+    public function testScalarTypehintedParameters(ReflectionParameter $reflection, string $expectedType)
     {
         $param = new Parameter($reflection);
         $this->assertTrue($param->isBuiltin());
@@ -106,7 +107,7 @@ public function testScalarTypehintedParameters(ReflectionParameter $reflection,
     public function testIterablePseudoType()
     {
         $reflections = (new ReflectionClass(TestAsset\IterableDependency::class))->getConstructor()->getParameters();
-        $param = new Parameter($reflections[0]);
+        $param       = new Parameter($reflections[0]);
 
         $this->assertTrue($param->isBuiltin());
         $this->assertSame('iterable', $param->getType());
diff --git a/test/Definition/Reflection/ParameterTestTrait.php b/test/Definition/Reflection/ParameterTestTrait.php
index 1620a5b6..36dccbb8 100644
--- a/test/Definition/Reflection/ParameterTestTrait.php
+++ b/test/Definition/Reflection/ParameterTestTrait.php
@@ -12,36 +12,39 @@
 
 use LaminasTest\Di\TestAsset;
 use ReflectionClass;
+use ReflectionMethod;
+
+use function substr;
 
 trait ParameterTestTrait
 {
-    private function reflectAsset($methodName, $parameterIndex = 0)
+    private function reflectAsset(string $methodName, int $parameterIndex = 0): object
     {
         $all = (new ReflectionClass(TestAsset\Parameters::class))->getMethod($methodName)->getParameters();
         return $all[$parameterIndex];
     }
 
-    private function buildReflectionArgsFromClass($classname)
+    private function buildReflectionArgsFromClass(string $classname): array
     {
-        $class = new ReflectionClass($classname);
+        $class          = new ReflectionClass($classname);
         $invocationArgs = [];
 
-        /** @var \ReflectionMethod $method */
+        /** @var ReflectionMethod $method */
         foreach ($class->getMethods() as $method) {
-            $params = $method->getParameters();
-            $typename = substr($method->name, 0, -4);
-            $invocationArgs[$typename] = [ $params[0], $typename ];
+            $params                    = $method->getParameters();
+            $typename                  = substr($method->name, 0, -4);
+            $invocationArgs[$typename] = [$params[0], $typename];
         }
 
         return $invocationArgs;
     }
 
-    public function provideBuiltinTypehintedReflections()
+    public function provideBuiltinTypehintedReflections(): array
     {
         return $this->buildReflectionArgsFromClass(TestAsset\BuiltinTypehintParameters::class);
     }
 
-    public function provideTypehintedParameterReflections()
+    public function provideTypehintedParameterReflections(): array
     {
         return [
             'required' => [$this->reflectAsset('typehintRequired'), TestAsset\A::class],
@@ -49,7 +52,7 @@ public function provideTypehintedParameterReflections()
         ];
     }
 
-    public function provideTypelessParameterReflections()
+    public function provideTypelessParameterReflections(): array
     {
         return [
             'required' => [$this->reflectAsset('typelessRequired')],
diff --git a/test/Definition/RuntimeDefinitionTest.php b/test/Definition/RuntimeDefinitionTest.php
index 4db7fb59..616e9056 100644
--- a/test/Definition/RuntimeDefinitionTest.php
+++ b/test/Definition/RuntimeDefinitionTest.php
@@ -60,7 +60,7 @@ public function testSetExplicitClassesReplacesPrefiousValues()
         $this->assertEquals($expected, $definition->getClasses());
     }
 
-    public function provideExistingClasses()
+    public function provideExistingClasses(): array
     {
         return [
             'A'             => [TestAsset\A::class],
@@ -69,7 +69,7 @@ public function provideExistingClasses()
         ];
     }
 
-    public function provideInvalidClasses()
+    public function provideInvalidClasses(): array
     {
         return [
             'interface' => [TestAsset\DummyInterface::class],
@@ -80,12 +80,12 @@ public function provideInvalidClasses()
     /**
      * @dataProvider provideInvalidClasses
      */
-    public function testSetInvalidExplicitClassThrowsException($class)
+    public function testSetInvalidExplicitClassThrowsException(string $class)
     {
         $definition = new RuntimeDefinition();
 
         $this->expectException(Exception\ClassNotFoundException::class);
-        $definition->setExplicitClasses([ $class ]);
+        $definition->setExplicitClasses([$class]);
     }
 
     /**
@@ -108,7 +108,7 @@ public function testAddExplicitClass()
     /**
      * @dataProvider provideInvalidClasses
      */
-    public function testAddInvalidExplicitClassThrowsException($class)
+    public function testAddInvalidExplicitClassThrowsException(string $class)
     {
         $definition = new RuntimeDefinition();
 
@@ -119,7 +119,7 @@ public function testAddInvalidExplicitClassThrowsException($class)
     /**
      * @dataProvider provideExistingClasses
      */
-    public function testHasClassReturnsTrueDynamically($class)
+    public function testHasClassReturnsTrueDynamically(string $class)
     {
         $this->assertTrue(
             (new RuntimeDefinition())->hasClass($class)
@@ -129,7 +129,7 @@ public function testHasClassReturnsTrueDynamically($class)
     /**
      * @dataProvider provideInvalidClasses
      */
-    public function testHasClassReturnsFalseForInvalidClasses($class)
+    public function testHasClassReturnsFalseForInvalidClasses(string $class)
     {
         $this->assertFalse(
             (new RuntimeDefinition())->hasClass($class)
@@ -139,10 +139,10 @@ public function testHasClassReturnsFalseForInvalidClasses($class)
     /**
      * @dataProvider provideExistingClasses
      */
-    public function testGetClassDefinition($class)
+    public function testGetClassDefinition(string $class)
     {
         $definition = new RuntimeDefinition();
-        $result = $definition->getClassDefinition($class);
+        $result     = $definition->getClassDefinition($class);
 
         $this->assertInstanceOf(ClassDefinitionInterface::class, $result);
         $this->assertInstanceOf(ReflectionClass::class, $result->getReflection());
@@ -152,7 +152,7 @@ public function testGetClassDefinition($class)
     /**
      * @dataProvider provideExistingClasses
      */
-    public function testGetClassDefinitionAutoPopulatesClass($class)
+    public function testGetClassDefinitionAutoPopulatesClass(string $class)
     {
         $definition = new RuntimeDefinition();
 
diff --git a/test/GeneratedInjectorDelegatorTest.php b/test/GeneratedInjectorDelegatorTest.php
index 6d16bedf..b0439703 100644
--- a/test/GeneratedInjectorDelegatorTest.php
+++ b/test/GeneratedInjectorDelegatorTest.php
@@ -16,6 +16,8 @@
 use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
 
+use function get_class;
+
 class GeneratedInjectorDelegatorTest extends TestCase
 {
     use ProphecyTrait;
@@ -50,7 +52,7 @@ public function testGeneratedInjectorDoesNotExist()
         $container->has('config')->willReturn(false)->shouldBeCalledTimes(1);
 
         $delegator = new GeneratedInjectorDelegator();
-        $result = $delegator($container->reveal(), get_class($injector), $callback);
+        $result    = $delegator($container->reveal(), get_class($injector), $callback);
 
         $this->assertSame($result, $injector);
     }
@@ -71,7 +73,7 @@ public function testGeneratedInjectorExists()
             ->shouldBeCalledTimes(1);
 
         $delegator = new GeneratedInjectorDelegator();
-        $result = $delegator($container->reveal(), get_class($injector), $callback);
+        $result    = $delegator($container->reveal(), get_class($injector), $callback);
 
         $this->assertInstanceOf(TestAsset\GeneratedInjector::class, $result);
         $this->assertSame($injector, $result->getInjector());
diff --git a/test/InjectorTest.php b/test/InjectorTest.php
index c94aa382..63e614bd 100644
--- a/test/InjectorTest.php
+++ b/test/InjectorTest.php
@@ -10,6 +10,7 @@
 
 namespace LaminasTest\Di;
 
+use Interop\Container\ContainerInterface as LegacyContainerInterface;
 use Laminas\Di\Config;
 use Laminas\Di\DefaultContainer;
 use Laminas\Di\Definition\DefinitionInterface;
@@ -26,6 +27,9 @@
 use stdClass;
 use TypeError;
 
+use function array_map;
+use function uniqid;
+
 /**
  * @coversDefaultClass Laminas\Di\Injector
  */
@@ -33,7 +37,7 @@ class InjectorTest extends TestCase
 {
     /**
      * @param mixed $value
-     * @return \PHPUnit\Framework\Constraint\IsIdentical
+     * @return Constraint\IsIdentical
      */
     private function isIdentical($value)
     {
@@ -55,7 +59,7 @@ public function testSetContainerReplacesConstructed()
     public function testConstructWithContainerPassesItToResolver()
     {
         $container = $this->getMockForAbstractClass(ContainerInterface::class);
-        $resolver = $this->getMockForAbstractClass(DependencyResolverInterface::class);
+        $resolver  = $this->getMockForAbstractClass(DependencyResolverInterface::class);
         $resolver->expects($this->once())
             ->method('setContainer')
             ->with($this->isIdentical($container))
@@ -68,8 +72,8 @@ public function testConstructWithContainerPassesItToResolver()
     public function testSetContainerPassesItToResolver()
     {
         $container = $this->getMockForAbstractClass(ContainerInterface::class);
-        $resolver = $this->getMockForAbstractClass(DependencyResolverInterface::class);
-        $injector = new Injector(null, null, null, $resolver);
+        $resolver  = $this->getMockForAbstractClass(DependencyResolverInterface::class);
+        $injector  = new Injector(null, null, null, $resolver);
 
         $resolver->expects($this->once())
             ->method('setContainer')
@@ -95,7 +99,7 @@ public function provideClassNames()
     /**
      * @dataProvider provideClassNames
      */
-    public function testCanCreateReturnsTrueForClasses($className)
+    public function testCanCreateReturnsTrueForClasses(string $className)
     {
         $this->assertTrue((new Injector())->canCreate($className));
     }
@@ -112,7 +116,7 @@ public function testCanCreateReturnsFalseForNonExistingClassOrAlias()
         $this->assertFalse($injector->canCreate('Some.Alias.Name'));
     }
 
-    public function provideValidAliases()
+    public function provideValidAliases(): array
     {
         return [
             //               [ alias,               target]
@@ -126,7 +130,7 @@ public function provideValidAliases()
     /**
      * @dataProvider provideValidAliases
      */
-    public function testCanCreateReturnsTrueWithDefinedAndValidAliases($aliasName, $className)
+    public function testCanCreateReturnsTrueWithDefinedAndValidAliases(string $aliasName, string $className)
     {
         $config = new Config([
             'types' => [
@@ -160,14 +164,14 @@ public function testCreateWithoutDependencies()
 
     public function testCreateUsesContainerDependency()
     {
-        $injector = new Injector();
+        $injector  = new Injector();
         $expectedA = new TestAsset\A();
         $container = new DefaultContainer($injector);
 
         $container->setInstance(TestAsset\A::class, $expectedA);
         $injector->setContainer($container);
 
-        /** @var \LaminasTest\Di\TestAsset\B $result */
+        /** @var TestAsset\B $result */
         $result = $injector->create(TestAsset\B::class);
 
         $this->assertInstanceOf(TestAsset\B::class, $result);
@@ -176,14 +180,14 @@ public function testCreateUsesContainerDependency()
 
     public function testCreateSimpleDependency()
     {
-        /** @var \LaminasTest\Di\TestAsset\B $result */
+        /** @var TestAsset\B $result */
         $result = (new Injector())->create(TestAsset\B::class);
 
         $this->assertInstanceOf(TestAsset\B::class, $result);
         $this->assertInstanceOf(TestAsset\A::class, $result->injectedA);
     }
 
-    public function provideCircularClasses()
+    public function provideCircularClasses(): array
     {
         $classes = [
             'flat'         => TestAsset\CircularClasses\A::class,
@@ -200,7 +204,7 @@ public function provideCircularClasses()
     /**
      * @dataProvider provideCircularClasses
      */
-    public function testCircularDependencyThrowsException($class)
+    public function testCircularDependencyThrowsException(string $class)
     {
         $this->expectException(Exception\CircularDependencyException::class);
         (new Injector())->create($class);
@@ -229,7 +233,7 @@ public function testComplexTreeResolving()
 
     public function testDeepDependencyUsesContainer()
     {
-        $injector = new Injector();
+        $injector  = new Injector();
         $container = $this->getMockForAbstractClass(ContainerInterface::class);
 
         // Mocks a container that always creates new instances
@@ -242,13 +246,12 @@ public function testDeepDependencyUsesContainer()
 
         $injector->setContainer($container);
 
+        /** @var TreeTestAsset\Complex $result1 */
         $result1 = $injector->create(TreeTestAsset\Complex::class);
+        /** @var TreeTestAsset\Complex $result2 */
         $result2 = $injector->create(TreeTestAsset\Complex::class);
 
         /** @var TreeTestAsset\Complex $result */
-        /** @var TreeTestAsset\Complex $result1 */
-        /** @var TreeTestAsset\Complex $result2 */
-
         foreach ([$result1, $result2] as $result) {
             $this->assertInstanceOf(TreeTestAsset\Complex::class, $result);
             $this->assertInstanceOf(TreeTestAsset\Level1::class, $result->result);
@@ -302,7 +305,7 @@ public function testDeepDependencyRespectsSpecificTypePreference()
     public function testDeepDependencyUsesConfiguredParameters()
     {
         $expected = uniqid('InjectValue');
-        $config = new Config([
+        $config   = new Config([
             'types' => [
                 TreeTestAsset\Level2::class => [
                     'parameters' => [
@@ -325,13 +328,13 @@ public function testComplexDeepDependencyConfiguration()
 
         $config = new Config([
             'types' => [
-                TreeTestAsset\Level2::class => [
+                TreeTestAsset\Level2::class           => [
                     'parameters' => [
                         'opt' => $expected1,
                     ],
                 ],
-                'Level2.Alias' => [
-                    'typeOf' => TreeTestAsset\Level2::class,
+                'Level2.Alias'                        => [
+                    'typeOf'     => TreeTestAsset\Level2::class,
                     'parameters' => [
                         'opt' => $expected2,
                     ],
@@ -369,7 +372,7 @@ public function testKnownButInexistentClassThrowsException()
         (new Injector(null, null, $definition))->create('LaminasTest\Di\TestAsset\No\Such\Class');
     }
 
-    public function provideUnexpectedResolverValues()
+    public function provideUnexpectedResolverValues(): array
     {
         return [
             'string' => ['string value'],
@@ -381,6 +384,7 @@ public function provideUnexpectedResolverValues()
 
     /**
      * @dataProvider provideUnexpectedResolverValues
+     * @param mixed $unexpectedValue
      */
     public function testUnexpectedResolverResultThrowsTypeError($unexpectedValue)
     {
@@ -395,18 +399,18 @@ public function testUnexpectedResolverResultThrowsTypeError($unexpectedValue)
         $injector->create(TestAsset\TypelessDependency::class);
     }
 
-    public function provideContainerTypeNames()
+    public function provideContainerTypeNames(): array
     {
         return [
             'psr'     => [ContainerInterface::class],
-            'interop' => ['Interop\Container\ContainerInterface']
+            'interop' => [LegacyContainerInterface::class],
         ];
     }
 
     /**
      * @dataProvider provideContainerTypeNames
      */
-    public function testContainerItselfIsInjectedIfHasReturnsFalse($typeName)
+    public function testContainerItselfIsInjectedIfHasReturnsFalse(string $typeName)
     {
         $resolver  = $this->getMockBuilder(DependencyResolverInterface::class)->getMockForAbstractClass();
         $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
@@ -417,7 +421,7 @@ public function testContainerItselfIsInjectedIfHasReturnsFalse($typeName)
         $container->method('has')->willReturn(false);
 
         $injector = new Injector(null, $container, null, $resolver);
-        $result = $injector->create(TestAsset\TypelessDependency::class);
+        $result   = $injector->create(TestAsset\TypelessDependency::class);
 
         $this->assertInstanceOf(TestAsset\TypelessDependency::class, $result);
         $this->assertSame($container, $result->result);
@@ -426,8 +430,8 @@ public function testContainerItselfIsInjectedIfHasReturnsFalse($typeName)
     public function testTypeUnavailableInContainerThrowsException()
     {
         $expectedMessage = 'Exception from container';
-        $resolver  = $this->getMockBuilder(DependencyResolverInterface::class)->getMockForAbstractClass();
-        $container = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
+        $resolver        = $this->getMockBuilder(DependencyResolverInterface::class)->getMockForAbstractClass();
+        $container       = $this->getMockBuilder(ContainerInterface::class)->getMockForAbstractClass();
         $resolver->expects($this->atLeastOnce())
             ->method('resolveParameters')
             ->willReturn([new TypeInjection(TestAsset\A::class)]);
@@ -448,7 +452,7 @@ public function testTypeUnavailableInContainerThrowsException()
         $injector->create(TestAsset\TypelessDependency::class);
     }
 
-    public function provideManyArguments()
+    public function provideManyArguments(): array
     {
         return [
             'three' => [
@@ -459,7 +463,7 @@ public function provideManyArguments()
                     'c' => true,
                 ],
             ],
-            'six' => [
+            'six'   => [
                 TestAsset\Constructor\ManyArguments::class,
                 [
                     'a' => 'a',
diff --git a/test/LegacyConfigTest.php b/test/LegacyConfigTest.php
index b221d075..2590114c 100644
--- a/test/LegacyConfigTest.php
+++ b/test/LegacyConfigTest.php
@@ -16,6 +16,7 @@
 use Laminas\Di\LegacyConfig;
 use PHPUnit\Framework\Error\Deprecated as DeprecatedError;
 use PHPUnit\Framework\TestCase;
+use SplFileInfo;
 use stdClass;
 
 /**
@@ -23,14 +24,14 @@
  */
 class LegacyConfigTest extends TestCase
 {
-    public function provideMigrationConfigFixtures()
+    public function provideMigrationConfigFixtures(): array
     {
         $iterator = new GlobIterator(__DIR__ . '/_files/legacy-configs/*.php');
-        $values = [];
+        $values   = [];
 
-        /** @var \SplFileInfo $file */
+        /** @var SplFileInfo $file */
         foreach ($iterator as $file) {
-            $key = $file->getBasename('.php');
+            $key  = $file->getBasename('.php');
             $data = include $file->getPathname();
 
             $values[$key] = [
@@ -68,8 +69,8 @@ public function testFQParamNamesTriggerDeprecated()
 
     public function testConstructWithTraversable()
     {
-        $spec = include __DIR__ . '/_files/legacy-configs/common.php';
-        $config = new ArrayIterator($spec['config']);
+        $spec     = include __DIR__ . '/_files/legacy-configs/common.php';
+        $config   = new ArrayIterator($spec['config']);
         $instance = new LegacyConfig($config);
 
         $this->assertEquals($spec['expected'], $instance->toArray());
diff --git a/test/ModuleTest.php b/test/ModuleTest.php
index e42c118f..7d3442b4 100644
--- a/test/ModuleTest.php
+++ b/test/ModuleTest.php
@@ -21,7 +21,7 @@ class ModuleTest extends TestCase
 {
     public function testModuleProvidesServiceConfiguration()
     {
-        $module = new Module();
+        $module         = new Module();
         $configProvider = new ConfigProvider();
 
         $config = $module->getConfig();
diff --git a/test/Resolver/AbstractInjectionTest.php b/test/Resolver/AbstractInjectionTest.php
index 12a4be81..df93ee2f 100644
--- a/test/Resolver/AbstractInjectionTest.php
+++ b/test/Resolver/AbstractInjectionTest.php
@@ -15,6 +15,8 @@
 use PHPUnit\Framework\Error\Deprecated;
 use PHPUnit\Framework\TestCase;
 
+use function sprintf;
+
 class AbstractInjectionTest extends TestCase
 {
     public function testUsageIsDeprecated()
@@ -30,10 +32,12 @@ public function testUsageIsDeprecated()
         {
             public function export(): string
             {
+                return '';
             }
 
             public function isExportable(): bool
             {
+                return true;
             }
         };
     }
diff --git a/test/Resolver/DependencyResolverTest.php b/test/Resolver/DependencyResolverTest.php
index d4502181..8df93d41 100644
--- a/test/Resolver/DependencyResolverTest.php
+++ b/test/Resolver/DependencyResolverTest.php
@@ -29,6 +29,13 @@
 use Psr\Container\ContainerInterface;
 use stdClass;
 
+use function array_keys;
+use function array_merge;
+use function array_shift;
+use function basename;
+use function glob;
+use function uniqid;
+
 /**
  * @coversDefaultClass Laminas\Di\Resolver\DependencyResolver
  */
@@ -39,7 +46,7 @@ class DependencyResolverTest extends TestCase
     /**
      * @return PHPUnit_Framework_MockObject_MockObject|ContainerInterface
      */
-    private function getEmptyContainerMock()
+    private function getEmptyContainerMock(): ContainerInterface
     {
         $container = $this->getMockForAbstractClass(ContainerInterface::class);
         $container->expects($this->any())->method('has')->withAnyParameters()->willReturn(false);
@@ -48,11 +55,7 @@ private function getEmptyContainerMock()
         return $container;
     }
 
-    /**
-     * @param array $definition
-     * @return ParameterInterface
-     */
-    private function mockParameter($name, $position, array $options)
+    private function mockParameter(string $name, int $position, array $options): ParameterInterface
     {
         $definition = array_merge([
             'default'  => null,
@@ -66,24 +69,25 @@ private function mockParameter($name, $position, array $options)
         $mock->method('getPosition')->willReturn($position);
         $mock->method('getDefault')->willReturn($definition['default']);
         $mock->method('getType')->willReturn($definition['type']);
-        $mock->method('isBuiltin')->willReturn((bool)$definition['builtin']);
-        $mock->method('isRequired')->willReturn((bool)$definition['required']);
+        $mock->method('isBuiltin')->willReturn((bool) $definition['builtin']);
+        $mock->method('isRequired')->willReturn((bool) $definition['required']);
 
         return $mock;
     }
 
-    /**
-     * @return ClassDefinitionInterface
-     */
-    private function mockClassDefinition($name, array $parameters = [], array $interfaces = [], array $supertypes = [])
-    {
+    private function mockClassDefinition(
+        string $name,
+        array $parameters = [],
+        array $interfaces = [],
+        array $supertypes = []
+    ): ClassDefinitionInterface {
         $mock = $this->getMockForAbstractClass(ClassDefinitionInterface::class);
 
         $mock->method('getInterfaces')->willReturn($interfaces);
         $mock->method('getSupertypes')->willReturn($supertypes);
         $mock->expects($this->never())->method('getReflection');
 
-        $position = 0;
+        $position   = 0;
         $paramMocks = [];
 
         foreach ($parameters as $name => $options) {
@@ -155,7 +159,7 @@ public function testResolveWithoutConfig()
 
         $injection = array_shift($params);
         $this->assertInstanceOf(TypeInjection::class, $injection);
-        $this->assertEquals(TestAsset\A::class, (string)$injection);
+        $this->assertEquals(TestAsset\A::class, (string) $injection);
 
         $params = $resolver->resolveParameters(TestAsset\A::class);
         $this->assertIsArray($params);
@@ -174,14 +178,14 @@ public function testResolveWithContainerFailsWhenMissing()
     public function testResolveSucceedsWithoutContainer()
     {
         $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
-        $result = $resolver->resolveParameters(TestAsset\RequiresA::class);
+        $result   = $resolver->resolveParameters(TestAsset\RequiresA::class);
 
         $this->assertCount(1, $result);
         $this->assertIsArray($result);
-        $this->assertSame(TestAsset\A::class, (string)$result['p']);
+        $this->assertSame(TestAsset\A::class, (string) $result['p']);
     }
 
-    public function testResolveFailsForDependenciesWithoutType()
+    public function testResolveFailsForDependenciesWithoutType(): void
     {
         $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
 
@@ -189,7 +193,7 @@ public function testResolveFailsForDependenciesWithoutType()
         $resolver->resolveParameters(TestAsset\Constructor\RequiredArguments::class);
     }
 
-    public function testResolveFailsForInterfaces()
+    public function testResolveFailsForInterfaces(): void
     {
         $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
 
@@ -197,31 +201,31 @@ public function testResolveFailsForInterfaces()
         $resolver->resolveParameters(TestAsset\DummyInterface::class);
     }
 
-    public function provideClassesWithoutConstructionParams()
+    public function provideClassesWithoutConstructionParams(): array
     {
         return [
-            'noargs' => [TestAsset\Constructor\EmptyConstructor::class],
-            'noconstruct' => [TestAsset\Constructor\NoConstructor::class]
+            'noargs'      => [TestAsset\Constructor\EmptyConstructor::class],
+            'noconstruct' => [TestAsset\Constructor\NoConstructor::class],
         ];
     }
 
     /**
      * @dataProvider provideClassesWithoutConstructionParams
      */
-    public function testResolveClassWithoutParameters($class)
+    public function testResolveClassWithoutParameters(string $class): void
     {
         $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
-        $result = $resolver->resolveParameters($class);
+        $result   = $resolver->resolveParameters($class);
 
         $this->assertIsArray($result);
         $this->assertCount(0, $result);
     }
 
-    public function testResolveWithOptionalArgs()
+    public function testResolveWithOptionalArgs(): void
     {
         $container = $this->prophesize(ContainerInterface::class)->reveal();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
-        $result = $resolver->resolveParameters(TestAsset\Constructor\OptionalArguments::class);
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), new Config());
+        $result    = $resolver->resolveParameters(TestAsset\Constructor\OptionalArguments::class);
 
         $this->assertIsArray($result);
         $this->assertCount(2, $result);
@@ -230,14 +234,14 @@ public function testResolveWithOptionalArgs()
         $this->assertSame('something', $result['bar']->toValue($container));
     }
 
-    public function testResolvePassedDependenciesWithoutType()
+    public function testResolvePassedDependenciesWithoutType(): void
     {
         $container = $this->prophesize(ContainerInterface::class)->reveal();
-        $resolver = new DependencyResolver(new RuntimeDefinition(), new Config());
+        $resolver  = new DependencyResolver(new RuntimeDefinition(), new Config());
 
         $expected = 'Some Value';
-        $result = $resolver->resolveParameters(TestAsset\Constructor\RequiredArguments::class, [
-            'anyDep' => $expected
+        $result   = $resolver->resolveParameters(TestAsset\Constructor\RequiredArguments::class, [
+            'anyDep' => $expected,
         ]);
 
         $this->assertCount(3, $result);
@@ -245,18 +249,18 @@ public function testResolvePassedDependenciesWithoutType()
         $this->assertSame($expected, $result['anyDep']->toValue($container));
     }
 
-    public function providePreferenceConfigs()
+    public function providePreferenceConfigs(): array
     {
         $args = [];
 
         foreach (glob(__DIR__ . '/../_files/preferences/*.php') as $configFile) {
-            $config = include $configFile;
+            $config         = include $configFile;
             $configInstance = new Config($config);
-            $name = basename($configFile, 'php');
+            $name           = basename($configFile, 'php');
 
             foreach ($config['expect'] as $key => $expectation) {
-                list($requested, $expectedResult, $context) = $expectation;
-                $args[$name . $key] = [
+                [$requested, $expectedResult, $context] = $expectation;
+                $args[$name . $key]                     = [
                     $configInstance,
                     $requested,
                     $context,
@@ -271,13 +275,17 @@ public function providePreferenceConfigs()
     /**
      * @dataProvider providePreferenceConfigs
      */
-    public function testResolveConfiguredPreference(ConfigInterface $config, $requestClass, $context, $expectedType)
-    {
+    public function testResolveConfiguredPreference(
+        ConfigInterface $config,
+        string $requestClass,
+        ?string $context,
+        ?string $expectedType
+    ): void {
         $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
         $this->assertSame($expectedType, $resolver->resolvePreference($requestClass, $context));
     }
 
-    public function provideExplicitInjections()
+    public function provideExplicitInjections(): array
     {
         return [
             'type'  => [new TypeInjection(TestAsset\B::class)],
@@ -288,7 +296,7 @@ public function provideExplicitInjections()
     /**
      * @dataProvider provideExplicitInjections
      */
-    public function testExplicitInjectionInConfigIsUsedWithoutAdditionalTypeChecks($expected)
+    public function testExplicitInjectionInConfigIsUsedWithoutAdditionalTypeChecks(object $expected): void
     {
         $config = new Config([
             'types' => [
@@ -301,12 +309,12 @@ public function testExplicitInjectionInConfigIsUsedWithoutAdditionalTypeChecks($
         ]);
 
         $resolver = new DependencyResolver(new RuntimeDefinition(), $config);
-        $result = $resolver->resolveParameters(TestAsset\RequiresA::class);
+        $result   = $resolver->resolveParameters(TestAsset\RequiresA::class);
         $this->assertArrayHasKey('p', $result);
         $this->assertSame($expected, $result['p']);
     }
 
-    public function provideUnusableParametersData()
+    public function provideUnusableParametersData(): array
     {
         return [
             //            [type,               value,                builtIn]
@@ -321,17 +329,18 @@ public function provideUnusableParametersData()
 
     /**
      * @dataProvider provideUnusableParametersData
+     * @param mixed $value
      */
-    public function testUnusableConfigParametersThrowsException(string $type, $value, bool $builtin = false)
+    public function testUnusableConfigParametersThrowsException(string $type, $value, bool $builtin = false): void
     {
-        $class = uniqid('MockedTestClass');
-        $paramName = uniqid('param');
-        $config = $this->getMockBuilder(ConfigInterface::class)->getMockForAbstractClass();
+        $class      = uniqid('MockedTestClass');
+        $paramName  = uniqid('param');
+        $config     = $this->getMockBuilder(ConfigInterface::class)->getMockForAbstractClass();
         $definition = $this->mockDefinition([
             $class => [
                 'parameters' => [
                     $paramName => [
-                        'type' => $type,
+                        'type'    => $type,
                         'builtin' => $builtin,
                     ],
                 ],
@@ -371,7 +380,8 @@ public function provideUsableParametersData()
             'boolFalse'                 => ['bool',             true,                          true],
             'iterableArray'             => ['iterable',         [],                            true],
             'iterableIterator'          => ['iterable',         new ArrayIterator([]),         true],
-            'iterableIteratorAggregate' => ['iterable',         new class implements IteratorAggregate {
+            'iterableIteratorAggregate' => ['iterable',         new class implements IteratorAggregate
+            {
                 public function getIterator()
                 {
                     return new ArrayIterator([]);
@@ -380,29 +390,31 @@ public function getIterator()
             'callableClosure'           => ['callable',         function () {
             }, true],
             'callableString'            => ['callable',         'trim',                        true],
-            'callableObject'            => ['callable',         new class {
+            'callableObject'            => ['callable',         new class
+            {
                 public function __invoke()
                 {
                 }
             }, true],
-            'derivedInstance'           => [TestAsset\B::class, new TestAsset\ExtendedB(new TestAsset\A()), false ],
-            'directInstance'            => [TestAsset\A::class, new TestAsset\A(),             false ],
+            'derivedInstance'           => [TestAsset\B::class, new TestAsset\ExtendedB(new TestAsset\A()), false],
+            'directInstance'            => [TestAsset\A::class, new TestAsset\A(),             false],
         ];
         // @codingStandardsIgnoreEnd
     }
 
     /**
      * @dataProvider provideUsableParametersData
+     * @param mixed $value
      */
     public function testUsableConfigParametersAreAccepted(string $type, $value, bool $builtin = false)
     {
-        $class = uniqid('MockedTestClass');
-        $paramName = uniqid('param');
+        $class      = uniqid('MockedTestClass');
+        $paramName  = uniqid('param');
         $definition = $this->mockDefinition([
             $class => [
                 'parameters' => [
                     $paramName => [
-                        'type' => $type,
+                        'type'    => $type,
                         'builtin' => $builtin,
                     ],
                 ],
@@ -420,8 +432,8 @@ public function testUsableConfigParametersAreAccepted(string $type, $value, bool
         ]);
 
         $container = $this->prophesize(ContainerInterface::class)->reveal();
-        $resolver = new DependencyResolver($definition, $config);
-        $result = $resolver->resolveParameters($class);
+        $resolver  = new DependencyResolver($definition, $config);
+        $result    = $resolver->resolveParameters($class);
 
         $this->assertArrayHasKey($paramName, $result);
         $this->assertInstanceOf(ValueInjection::class, $result[$paramName]);
@@ -438,8 +450,8 @@ public function testUsableConfigParametersAreAccepted(string $type, $value, bool
      */
     public function testConfiguredExtendedInterfaceParameterSatisfiesRequiredInterfaceType()
     {
-        $class = uniqid('MockedTestClass');
-        $paramName = uniqid('param');
+        $class      = uniqid('MockedTestClass');
+        $paramName  = uniqid('param');
         $definition = $this->mockDefinition([
             $class => [
                 'parameters' => [
@@ -461,14 +473,14 @@ public function testConfiguredExtendedInterfaceParameterSatisfiesRequiredInterfa
         ]);
 
         $resolver = new DependencyResolver($definition, $config);
-        $result = $resolver->resolveParameters($class);
+        $result   = $resolver->resolveParameters($class);
 
         $this->assertArrayHasKey($paramName, $result);
         $this->assertInstanceOf(TypeInjection::class, $result[$paramName]);
-        $this->assertEquals(TestAsset\Hierarchy\InterfaceC::class, (string)$result[$paramName]);
+        $this->assertEquals(TestAsset\Hierarchy\InterfaceC::class, (string) $result[$paramName]);
     }
 
-    public function provideIterableClassNames()
+    public function provideIterableClassNames(): array
     {
         return [
             'iterator'          => [TestAsset\Pseudotypes\IteratorImplementation::class],
@@ -488,12 +500,12 @@ public function provideIterableClassNames()
      *
      * @dataProvider provideIterableClassNames
      */
-    public function testConfiguredTraversableTypeParameterSatisfiesIterable($iterableClassName)
+    public function testConfiguredTraversableTypeParameterSatisfiesIterable(string $iterableClassName)
     {
-        $class = TestAsset\IterableDependency::class;
-        $paramName = 'iterator';
+        $class      = TestAsset\IterableDependency::class;
+        $paramName  = 'iterator';
         $definition = new RuntimeDefinition();
-        $config = new Config([
+        $config     = new Config([
             'types' => [
                 $class => [
                     'parameters' => [
@@ -504,11 +516,11 @@ public function testConfiguredTraversableTypeParameterSatisfiesIterable($iterabl
         ]);
 
         $resolver = new DependencyResolver($definition, $config);
-        $result = $resolver->resolveParameters($class);
+        $result   = $resolver->resolveParameters($class);
 
         $this->assertArrayHasKey($paramName, $result);
         $this->assertInstanceOf(TypeInjection::class, $result[$paramName]);
-        $this->assertEquals($iterableClassName, (string)$result[$paramName]);
+        $this->assertEquals($iterableClassName, (string) $result[$paramName]);
     }
 
     /**
@@ -521,8 +533,8 @@ public function testConfiguredTraversableTypeParameterSatisfiesIterable($iterabl
      */
     public function testConfiguredInvokableTypeParameterSatisfiesCallable()
     {
-        $class = uniqid('MockedTestClass');
-        $paramName = uniqid('param');
+        $class      = uniqid('MockedTestClass');
+        $paramName  = uniqid('param');
         $definition = $this->mockDefinition([
             $class => [
                 'parameters' => [
@@ -535,7 +547,7 @@ public function testConfiguredInvokableTypeParameterSatisfiesCallable()
 
         $config = new Config([
             'types' => [
-                $class => [
+                $class           => [
                     'parameters' => [
                         $paramName => TestAsset\Pseudotypes\CallableImplementation::class,
                     ],
@@ -547,11 +559,11 @@ public function testConfiguredInvokableTypeParameterSatisfiesCallable()
         ]);
 
         $resolver = new DependencyResolver($definition, $config);
-        $result = $resolver->resolveParameters($class);
+        $result   = $resolver->resolveParameters($class);
 
         $this->assertArrayHasKey($paramName, $result);
         $this->assertInstanceOf(TypeInjection::class, $result[$paramName]);
-        $this->assertEquals(TestAsset\Pseudotypes\CallableImplementation::class, (string)$result[$paramName]);
+        $this->assertEquals(TestAsset\Pseudotypes\CallableImplementation::class, (string) $result[$paramName]);
     }
 
     /**
@@ -565,8 +577,8 @@ public function testConfiguredInvokableTypeParameterSatisfiesCallable()
      */
     public function testConfiguredInvokableAliasParameterSatisfiesCallable()
     {
-        $class = uniqid('MockedTestClass');
-        $paramName = uniqid('param');
+        $class      = uniqid('MockedTestClass');
+        $paramName  = uniqid('param');
         $definition = $this->mockDefinition([
             $class => [
                 'parameters' => [
@@ -579,7 +591,7 @@ public function testConfiguredInvokableAliasParameterSatisfiesCallable()
 
         $config = new Config([
             'types' => [
-                $class => [
+                $class           => [
                     'parameters' => [
                         $paramName => 'Callable.Alias',
                     ],
@@ -591,17 +603,17 @@ public function testConfiguredInvokableAliasParameterSatisfiesCallable()
         ]);
 
         $resolver = new DependencyResolver($definition, $config);
-        $result = $resolver->resolveParameters($class);
+        $result   = $resolver->resolveParameters($class);
 
         $this->assertArrayHasKey($paramName, $result);
         $this->assertInstanceOf(TypeInjection::class, $result[$paramName]);
-        $this->assertEquals('Callable.Alias', (string)$result[$paramName]);
+        $this->assertEquals('Callable.Alias', (string) $result[$paramName]);
     }
 
     public function testResolvePreferenceUsesSupertypes()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(TestAsset\B::class, TestAsset\ExtendedB::class, TestAsset\Hierarchy\A::class);
         $resolver = new DependencyResolver($definition, $config);
 
@@ -614,7 +626,7 @@ public function testResolvePreferenceUsesSupertypes()
     public function testResolvePreferenceUsesInterfaces()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(
             TestAsset\B::class,
             TestAsset\ExtendedB::class,
@@ -632,7 +644,7 @@ public function testResolvePreferenceUsesInterfaces()
     public function testParametresResolverShouldNotCheckTheTypeForString()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setParameters(
             TestAsset\B::class,
             ['a' => 'my-service']
@@ -655,7 +667,7 @@ public function testParametresResolverShouldNotCheckTheTypeForString()
     public function testResolvePreferenceFallsBackToGlobalPreferenceWhenNotSuitableForClassRequirement()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(TestAsset\A::class, TestAsset\B::class, TestAsset\RequiresA::class);
         $config->setTypePreference(TestAsset\A::class, TestAsset\ExtendedA::class);
         $resolver = new DependencyResolver($definition, $config);
@@ -674,7 +686,7 @@ public function testResolvePreferenceFallsBackToGlobalPreferenceWhenNotSuitableF
     public function testResolvePreferenceReturnsNullWhenNothingIsSuitableForClassRequirement()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(TestAsset\A::class, TestAsset\ExtendedB::class, TestAsset\RequiresA::class);
         $config->setTypePreference(TestAsset\A::class, TestAsset\B::class);
         $resolver = new DependencyResolver($definition, $config);
@@ -690,7 +702,7 @@ public function testResolvePreferenceReturnsNullWhenNothingIsSuitableForClassReq
     public function testResolvePreferenceFallsBackToGlobalPreferenceWhenNotSuitableForInterfaceRequirement()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(
             TestAsset\Hierarchy\InterfaceB::class,
             TestAsset\Hierarchy\InterfaceA::class,
@@ -713,7 +725,7 @@ public function testResolvePreferenceFallsBackToGlobalPreferenceWhenNotSuitableF
     public function testResolvePreferenceReturnsNullWhenNothingIsSuitableForInterfaceRequirement()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(
             TestAsset\Hierarchy\InterfaceB::class,
             TestAsset\B::class,
@@ -733,7 +745,7 @@ public function testResolvePreferenceReturnsNullWhenNothingIsSuitableForInterfac
     public function testResolvePreferenceUsesDefinedClassForInterfaceRequirements()
     {
         $definition = new RuntimeDefinition();
-        $config = new Config();
+        $config     = new Config();
         $config->setTypePreference(
             TestAsset\Hierarchy\InterfaceB::class,
             TestAsset\Hierarchy\B::class
diff --git a/test/Resolver/TypeInjectionTest.php b/test/Resolver/TypeInjectionTest.php
index 5e2373bb..f4ff2f91 100644
--- a/test/Resolver/TypeInjectionTest.php
+++ b/test/Resolver/TypeInjectionTest.php
@@ -13,12 +13,12 @@
 use Laminas\Di\Resolver\InjectionInterface;
 use Laminas\Di\Resolver\TypeInjection;
 use Laminas\Di\Resolver\ValueInjection;
-use PHPUnit\Framework\Error\Deprecated;
 use PHPUnit\Framework\TestCase;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Psr\Container\ContainerInterface;
 use stdClass;
 
+use function sprintf;
 use function uniqid;
 
 /**
@@ -35,10 +35,10 @@ public function testImplementsContract()
 
     public function testToValueUsesContainer()
     {
-        $container = $this->prophesize(ContainerInterface::class);
-        $typename = uniqid('TypeName');
+        $container     = $this->prophesize(ContainerInterface::class);
+        $typename      = uniqid('TypeName');
         $expectedValue = new stdClass();
-        $subject = new TypeInjection($typename);
+        $subject       = new TypeInjection($typename);
 
         $container->get($typename)
             ->shouldBeCalled()
@@ -65,7 +65,7 @@ public function provideTypeNames(): iterable
     /**
      * @dataProvider provideTypeNames
      */
-    public function testIsExportableIsAlwaysTrue($typeName)
+    public function testIsExportableIsAlwaysTrue(string $typeName)
     {
         $this->assertTrue((new TypeInjection($typeName))->isExportable());
     }
diff --git a/test/Resolver/ValueInjectionTest.php b/test/Resolver/ValueInjectionTest.php
index 74727732..2b5b320d 100644
--- a/test/Resolver/ValueInjectionTest.php
+++ b/test/Resolver/ValueInjectionTest.php
@@ -21,6 +21,10 @@
 use Psr\Container\ContainerInterface;
 use stdClass;
 
+use function fclose;
+use function fopen;
+use function microtime;
+use function time;
 use function uniqid;
 
 /**
@@ -30,7 +34,7 @@ class ValueInjectionTest extends TestCase
 {
     use ProphecyTrait;
 
-    private $streamFixture = null;
+    private $streamFixture;
 
     protected function setUp(): void
     {
@@ -56,7 +60,7 @@ public function testImplementsContract()
         $this->assertInstanceOf(InjectionInterface::class, new ValueInjection(null));
     }
 
-    public function provideConstructionValues()
+    public function provideConstructionValues(): array
     {
         return [
             'string' => ['Hello World'],
@@ -69,21 +73,23 @@ public function provideConstructionValues()
 
     /**
      * @dataProvider provideConstructionValues
+     * @param mixed $value
      */
     public function testSetStateConstructsInstance($value)
     {
         $container = $this->prophesize(ContainerInterface::class)->reveal();
-        $result = ValueInjection::__set_state(['value' => $value]);
+        $result    = ValueInjection::__set_state(['value' => $value]);
         $this->assertInstanceOf(ValueInjection::class, $result);
         $this->assertSame($value, $result->toValue($container));
     }
 
     /**
      * @dataProvider provideConstructionValues
+     * @param mixed $value
      */
     public function testToValueBypassesContainer($value)
     {
-        $result = new ValueInjection($value);
+        $result    = new ValueInjection($value);
         $container = $this->prophesize(ContainerInterface::class);
 
         $container->get(Argument::cetera())
@@ -92,7 +98,7 @@ public function testToValueBypassesContainer($value)
         $this->assertSame($value, $result->toValue($container->reveal()));
     }
 
-    public function provideExportableValues()
+    public function provideExportableValues(): array
     {
         return [
             'string'       => ['Testvalue'],
@@ -124,7 +130,7 @@ public function provideExportableValues()
         ];
     }
 
-    public function provideUnexportableItems()
+    public function provideUnexportableItems(): array
     {
         if (! $this->streamFixture) {
             $this->streamFixture = fopen('php://temp', 'w+');
@@ -139,6 +145,7 @@ public function provideUnexportableItems()
 
     /**
      * @dataProvider provideUnexportableItems
+     * @param mixed $value
      */
     public function testExportThrowsExceptionForUnexportable($value)
     {
@@ -150,6 +157,7 @@ public function testExportThrowsExceptionForUnexportable($value)
 
     /**
      * @dataProvider provideUnexportableItems
+     * @param mixed $value
      */
     public function testIsExportableReturnsFalseForUnexportable($value)
     {
@@ -159,6 +167,7 @@ public function testIsExportableReturnsFalseForUnexportable($value)
 
     /**
      * @dataProvider provideExportableValues
+     * @param mixed $value
      */
     public function testIsExportableReturnsTrueForExportableValues($value)
     {
@@ -168,11 +177,12 @@ public function testIsExportableReturnsTrueForExportableValues($value)
 
     /**
      * @dataProvider provideExportableValues
+     * @param mixed $value
      */
     public function testExportWithExportableValues($value)
     {
         $instance = new ValueInjection($value);
-        $result = $instance->export();
+        $result   = $instance->export();
 
         $this->assertIsString($result, 'Export is expected to return a string value');
         $this->assertNotEquals('', $result, 'The exported value must not be empty');
@@ -180,7 +190,7 @@ public function testExportWithExportableValues($value)
 
     public function testGetValueTriggersDeprecatedNotice()
     {
-        $value = uniqid();
+        $value   = uniqid();
         $subject = new ValueInjection($value);
 
         $this->expectDeprecation(Deprecated::class);
diff --git a/test/TestAsset/CircularClasses/X.php b/test/TestAsset/CircularClasses/X.php
index 825c8f94..9c38d02b 100644
--- a/test/TestAsset/CircularClasses/X.php
+++ b/test/TestAsset/CircularClasses/X.php
@@ -1,5 +1,7 @@
 <?php
 
+// phpcs:disable
+
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
@@ -12,6 +14,7 @@
 
 class X
 {
+    // @codingStandardsIgnoreStart
     public function __construct(X $x)
     {
     }
diff --git a/test/TestAsset/CircularClasses/Y.php b/test/TestAsset/CircularClasses/Y.php
index 78a49655..4a8593ab 100644
--- a/test/TestAsset/CircularClasses/Y.php
+++ b/test/TestAsset/CircularClasses/Y.php
@@ -1,5 +1,7 @@
 <?php
 
+// phpcs:disable
+
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
@@ -12,6 +14,7 @@
 
 class Y
 {
+    // @codingStandardsIgnoreStart
     public function __construct(Y $y = null)
     {
     }
diff --git a/test/TestAsset/CodeGenerator/StdClassFactory.php b/test/TestAsset/CodeGenerator/StdClassFactory.php
index a25533b0..91c10bd1 100644
--- a/test/TestAsset/CodeGenerator/StdClassFactory.php
+++ b/test/TestAsset/CodeGenerator/StdClassFactory.php
@@ -16,6 +16,7 @@
 
 class StdClassFactory implements FactoryInterface
 {
+    /** @return stdClass */
     public function create(ContainerInterface $container, array $options)
     {
         return new stdClass();
diff --git a/test/TestAsset/Constructor/ManyArguments.php b/test/TestAsset/Constructor/ManyArguments.php
index 1604381e..7d3c5e26 100644
--- a/test/TestAsset/Constructor/ManyArguments.php
+++ b/test/TestAsset/Constructor/ManyArguments.php
@@ -1,5 +1,7 @@
 <?php
 
+// @phpcs:disable
+
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
@@ -10,6 +12,9 @@
 
 namespace LaminasTest\Di\TestAsset\Constructor;
 
+use function array_filter;
+use function compact;
+
 class ManyArguments
 {
     public $result;
@@ -23,7 +28,7 @@ public function __construct(
         $f = null
     ) {
         $this->result = array_filter(compact('a', 'b', 'c', 'd', 'e', 'f'), function ($value) {
-            return ($value !== null);
+            return $value !== null;
         });
     }
 }
diff --git a/test/TestAsset/Constructor/MixedArguments.php b/test/TestAsset/Constructor/MixedArguments.php
index ade80aaa..cb9202df 100644
--- a/test/TestAsset/Constructor/MixedArguments.php
+++ b/test/TestAsset/Constructor/MixedArguments.php
@@ -12,6 +12,7 @@
 
 class MixedArguments
 {
+    /** @param null|mixed $anyDep */
     public function __construct(NoConstructor $objectDep, $anyDep = null)
     {
     }
diff --git a/test/TestAsset/Constructor/OptionalArguments.php b/test/TestAsset/Constructor/OptionalArguments.php
index 67684dac..376c6755 100644
--- a/test/TestAsset/Constructor/OptionalArguments.php
+++ b/test/TestAsset/Constructor/OptionalArguments.php
@@ -12,6 +12,10 @@
 
 class OptionalArguments
 {
+    /**
+     * @param null|string $foo
+     * @param string      $bar
+     */
     public function __construct($foo = null, $bar = 'something')
     {
     }
diff --git a/test/TestAsset/Constructor/RequiredArguments.php b/test/TestAsset/Constructor/RequiredArguments.php
index 6195640f..26dc43d6 100644
--- a/test/TestAsset/Constructor/RequiredArguments.php
+++ b/test/TestAsset/Constructor/RequiredArguments.php
@@ -14,6 +14,7 @@
 
 class RequiredArguments
 {
+    /** @param mixed $anyDep */
     public function __construct(NoConstructor $objectDep, ArrayAccess $internalClassDep, $anyDep)
     {
     }
diff --git a/test/TestAsset/Constructor/ThreeArguments.php b/test/TestAsset/Constructor/ThreeArguments.php
index 826fbff9..1d175d3e 100644
--- a/test/TestAsset/Constructor/ThreeArguments.php
+++ b/test/TestAsset/Constructor/ThreeArguments.php
@@ -14,11 +14,16 @@ class ThreeArguments
 {
     public $result;
 
+    /**
+     * @param null|mixed $a
+     * @param null|mixed $b
+     * @param null|mixed $c
+     */
     public function __construct(
         $a = null,
         $b = null,
         $c = null
     ) {
-        $this->result = compact('a', 'b', 'c');
+        $this->result = ['a' => $a, 'b' => $b, 'c' => $c];
     }
 }
diff --git a/test/TestAsset/DependencyTree/AdditionalLevel1.php b/test/TestAsset/DependencyTree/AdditionalLevel1.php
index b8aa6a1f..b44ddcfe 100644
--- a/test/TestAsset/DependencyTree/AdditionalLevel1.php
+++ b/test/TestAsset/DependencyTree/AdditionalLevel1.php
@@ -12,9 +12,7 @@
 
 class AdditionalLevel1
 {
-    /**
-     * @var Level2
-     */
+    /** @var Level2 */
     public $result;
 
     public function __construct(Level2 $dep)
diff --git a/test/TestAsset/DependencyTree/Complex.php b/test/TestAsset/DependencyTree/Complex.php
index 9a3512f2..dbe4c153 100644
--- a/test/TestAsset/DependencyTree/Complex.php
+++ b/test/TestAsset/DependencyTree/Complex.php
@@ -12,19 +12,15 @@
 
 class Complex
 {
-    /**
-     * @var Level1
-     */
+    /** @var Level1 */
     public $result;
 
-    /**
-     * @var AdditionalLevel1
-     */
+    /** @var AdditionalLevel1 */
     public $result2;
 
     public function __construct(Level1 $dep, AdditionalLevel1 $dep2)
     {
-        $this->result = $dep;
+        $this->result  = $dep;
         $this->result2 = $dep2;
     }
 }
diff --git a/test/TestAsset/DependencyTree/Level1.php b/test/TestAsset/DependencyTree/Level1.php
index 4c68e7cb..8ac837fa 100644
--- a/test/TestAsset/DependencyTree/Level1.php
+++ b/test/TestAsset/DependencyTree/Level1.php
@@ -12,9 +12,7 @@
 
 class Level1
 {
-    /**
-     * @var Level2
-     */
+    /** @var Level2 */
     public $result;
 
     public function __construct(Level2 $dep)
diff --git a/test/TestAsset/DependencyTree/Level2.php b/test/TestAsset/DependencyTree/Level2.php
index 4ca9d67b..6b8debfc 100644
--- a/test/TestAsset/DependencyTree/Level2.php
+++ b/test/TestAsset/DependencyTree/Level2.php
@@ -14,6 +14,7 @@ class Level2
 {
     public $optionalResult;
 
+    /** @param null|mixed $opt*/
     public function __construct($opt = null)
     {
         $this->optionalResult = $opt;
diff --git a/test/TestAsset/DependencyTree/Simple.php b/test/TestAsset/DependencyTree/Simple.php
index bb97d9f0..a831e22b 100644
--- a/test/TestAsset/DependencyTree/Simple.php
+++ b/test/TestAsset/DependencyTree/Simple.php
@@ -12,9 +12,7 @@
 
 class Simple
 {
-    /**
-     * @var Level1
-     */
+    /** @var Level1 */
     public $result;
 
     public function __construct(Level1 $dep)
diff --git a/test/TestAsset/ExtendedB.php b/test/TestAsset/ExtendedB.php
index 309d4fea..b191c47d 100644
--- a/test/TestAsset/ExtendedB.php
+++ b/test/TestAsset/ExtendedB.php
@@ -12,5 +12,4 @@
 
 class ExtendedB extends B
 {
-
 }
diff --git a/test/TestAsset/GeneratedInjector.php b/test/TestAsset/GeneratedInjector.php
index 87a0704e..f69aaf6b 100644
--- a/test/TestAsset/GeneratedInjector.php
+++ b/test/TestAsset/GeneratedInjector.php
@@ -20,16 +20,17 @@ public function __construct(InjectorInterface $injector)
         $this->injector = $injector;
     }
 
-    public function getInjector() : InjectorInterface
+    public function getInjector(): InjectorInterface
     {
         return $this->injector;
     }
 
-    public function canCreate(string $name) : bool
+    public function canCreate(string $name): bool
     {
         return $this->injector->canCreate($name);
     }
 
+    /** @return object */
     public function create(string $name, array $options = [])
     {
         return $this->injector->create($name, $options);
diff --git a/test/TestAsset/Hierarchy/InterfaceA.php b/test/TestAsset/Hierarchy/InterfaceA.php
index 38ab15f9..dbdd1939 100644
--- a/test/TestAsset/Hierarchy/InterfaceA.php
+++ b/test/TestAsset/Hierarchy/InterfaceA.php
@@ -1,5 +1,6 @@
 <?php
 
+// @phpcs:disable
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
diff --git a/test/TestAsset/Hierarchy/InterfaceB.php b/test/TestAsset/Hierarchy/InterfaceB.php
index 46ee2b2d..e382720f 100644
--- a/test/TestAsset/Hierarchy/InterfaceB.php
+++ b/test/TestAsset/Hierarchy/InterfaceB.php
@@ -1,5 +1,7 @@
 <?php
 
+// @phpcs:disable
+
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
diff --git a/test/TestAsset/Hierarchy/InterfaceC.php b/test/TestAsset/Hierarchy/InterfaceC.php
index bd0bd3f5..7c48a044 100644
--- a/test/TestAsset/Hierarchy/InterfaceC.php
+++ b/test/TestAsset/Hierarchy/InterfaceC.php
@@ -1,5 +1,7 @@
 <?php
 
+// @phpcs:disable
+
 /**
  * @see       https://github.com/laminas/laminas-di for the canonical source repository
  * @copyright https://github.com/laminas/laminas-di/blob/master/COPYRIGHT.md
diff --git a/test/TestAsset/Option1ForA.php b/test/TestAsset/Option1ForA.php
index 13c4130e..157888b0 100644
--- a/test/TestAsset/Option1ForA.php
+++ b/test/TestAsset/Option1ForA.php
@@ -12,5 +12,4 @@
 
 class Option1ForA extends A
 {
-
 }
diff --git a/test/TestAsset/Option2ForA.php b/test/TestAsset/Option2ForA.php
index 96065386..518b1413 100644
--- a/test/TestAsset/Option2ForA.php
+++ b/test/TestAsset/Option2ForA.php
@@ -12,5 +12,4 @@
 
 class Option2ForA extends A
 {
-
 }
diff --git a/test/TestAsset/Parameters.php b/test/TestAsset/Parameters.php
index 2f4fc843..4a83eab4 100644
--- a/test/TestAsset/Parameters.php
+++ b/test/TestAsset/Parameters.php
@@ -12,6 +12,10 @@
 
 class Parameters
 {
+    /**
+     * @param mixed  $a
+     * @param string $c
+     */
     public function general($a, B $b, $c = 'something')
     {
     }
@@ -20,14 +24,16 @@ public function typehintRequired(A $foo)
     {
     }
 
+    /** @param mixed $bar */
     public function typelessRequired($bar)
     {
     }
 
-    public function typehintOptional(A $fooOpt = null)
+    public function typehintOptional(?A $fooOpt = null)
     {
     }
 
+    /** @param bool $flag */
     public function typelessOptional($flag = false)
     {
     }
diff --git a/test/TestAsset/Resolver/ExportableValue.php b/test/TestAsset/Resolver/ExportableValue.php
index 08698659..b716e7f9 100644
--- a/test/TestAsset/Resolver/ExportableValue.php
+++ b/test/TestAsset/Resolver/ExportableValue.php
@@ -12,6 +12,7 @@
 
 class ExportableValue
 {
+    /** @param mixed $data */
     public static function __set_state($data)
     {
     }
diff --git a/test/TestAsset/TypelessDependency.php b/test/TestAsset/TypelessDependency.php
index 9f5a5591..2b1aba3e 100644
--- a/test/TestAsset/TypelessDependency.php
+++ b/test/TestAsset/TypelessDependency.php
@@ -14,6 +14,7 @@ class TypelessDependency
 {
     public $result;
 
+    /** @param mixed $value */
     public function __construct($value)
     {
         $this->result = $value;