compiled interceptors module

lib/internal/Magento/Framework/CompiledInterception/Generator/CompiledPluginList.php

@@ -0,0 +1,72 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Framework\CompiledInterception\Generator;
+
+use Magento\Framework\App\ObjectManager;
+use Magento\Framework\Interception\PluginList\PluginList;
+use Magento\Framework\Interception\ObjectManager\ConfigInterface;
+use Magento\Framework\ObjectManager\Config\Reader\Dom;
+
+class CompiledPluginList extends PluginList
+{
+    /**
+     * CompiledPluginList constructor.
+     * @param $objectManager ObjectManager
+     * @param $scope
+     * @param null $reader
+     * @param null $omConfig
+     * @param null $cachePath
+     */
+    public function __construct(
+        $objectManager,
+        $scope,
+        $reader = null,
+        $omConfig = null,
+        $cachePath = null
+    ) {
+        if (!$reader || !$omConfig) {
+            $reader = $objectManager->get(Dom::class);
+            $omConfig = $objectManager->get(ConfigInterface::class);
+        }
+        parent::__construct(
+            $reader,
+            new StaticScope($scope),
+            new FileCache($cachePath),
+            new \Magento\Framework\ObjectManager\Relations\Runtime(),
+            $omConfig,
+            new \Magento\Framework\Interception\Definition\Runtime(),
+            $objectManager,
+            new \Magento\Framework\ObjectManager\Definition\Runtime(),
+            ['first' => 'global'],
+            'compiled_plugins_' . $scope,
+            new NoSerialize()
+        );
+    }
+
+    /**
+     * Retrieve plugin Instance
+     *
+     * @param string $type
+     * @param string $code
+     * @return mixed
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function getPlugin($type, $code)
+    {
+        return null;
+    }
+
+    /**
+     * @param $type
+     * @param $code
+     * @return mixed
+     */
+    public function getPluginType($type, $code)
+    {
+        return $this->_inherited[$type][$code]['instance'];
+    }
+
+}

lib/internal/Magento/Framework/CompiledInterception/Generator/FileCache.php

@@ -0,0 +1,128 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Framework\CompiledInterception\Generator;
+
+
+use Magento\Framework\Config\CacheInterface;
+
+class FileCache implements CacheInterface
+{
+
+    private $cachePath;
+
+    /**
+     * FileCache constructor.
+     * @param null $cachePath
+     */
+    public function __construct($cachePath = null)
+    {
+        $this->cachePath = ($cachePath === null ? BP . DIRECTORY_SEPARATOR . 'var' . DIRECTORY_SEPARATOR . 'cache' : $cachePath);
+    }
+
+
+    /**
+     * @param $identifier
+     * @return string
+     */
+    private function getCachePath($identifier)
+    {
+        return $this->cachePath . DIRECTORY_SEPARATOR . str_replace('|', '_', $identifier . '.php');
+    }
+
+    /**
+     * Test if a cache is available for the given id
+     *
+     * @param string $identifier Cache id
+     * @return int|bool Last modified time of cache entry if it is available, false otherwise
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function test($identifier)
+    {
+        // TODO: Implement test() method.
+    }
+
+    /**
+     * Load cache record by its unique identifier
+     *
+     * @param string $identifier
+     * @return string|bool
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function load($identifier)
+    {
+        return $this->cachePath ? @include($this->getCachePath($identifier)) : false;
+    }
+
+    /**
+     * Save cache record
+     *
+     * @param string $data
+     * @param string $identifier
+     * @param array $tags
+     * @param int|bool|null $lifeTime
+     * @return bool
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function save($data, $identifier, array $tags = [], $lifeTime = null)
+    {
+        if ($this->cachePath) {
+            $path = $this->getCachePath($identifier);
+            if (!is_dir(dirname($path))) {
+                mkdir(dirname($path));
+            }
+            file_put_contents(
+                $path,
+                '<?php return ' . var_export($data, true) . '?>'
+            );
+        }
+    }
+
+    /**
+     * Remove cache record by its unique identifier
+     *
+     * @param string $identifier
+     * @return bool
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function remove($identifier)
+    {
+        // TODO: Implement remove() method.
+    }
+
+    /**
+     * Clean cache records matching specified tags
+     *
+     * @param string $mode
+     * @param array $tags
+     * @return bool
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function clean($mode = \Zend_Cache::CLEANING_MODE_ALL, array $tags = [])
+    {
+        // TODO: Implement clean() method.
+    }
+
+    /**
+     * Retrieve backend instance
+     *
+     * @return \Zend_Cache_Backend_Interface
+     */
+    public function getBackend()
+    {
+        // TODO: Implement getBackend() method.
+    }
+
+    /**
+     * Retrieve frontend instance compatible with Zend Locale Data setCache() to be used as a workaround
+     *
+     * @return \Zend_Cache_Core
+     */
+    public function getLowLevelFrontend()
+    {
+        // TODO: Implement getLowLevelFrontend() method.
+    }
+
+}

lib/internal/Magento/Framework/CompiledInterception/Generator/NoSerialize.php

@@ -0,0 +1,37 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Framework\CompiledInterception\Generator;
+
+use Magento\Framework\Serialize\SerializerInterface;
+
+class NoSerialize implements SerializerInterface
+{
+    /**
+     * Serialize data into string
+     *
+     * @param string|int|float|bool|array|null $data
+     * @return string|bool
+     * @throws \InvalidArgumentException
+     * @since 101.0.0
+     */
+    public function serialize($data)
+    {
+        return $data;
+    }
+
+    /**
+     * Unserialize the given string
+     *
+     * @param string $string
+     * @return string|int|float|bool|array|null
+     * @throws \InvalidArgumentException
+     * @since 101.0.0
+     */
+    public function unserialize($string)
+    {
+        return $string;
+    }
+}

lib/internal/Magento/Framework/CompiledInterception/Generator/StaticScope.php

@@ -0,0 +1,40 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Framework\CompiledInterception\Generator;
+
+use Magento\Framework\Config\ScopeInterface;
+
+class StaticScope implements ScopeInterface
+{
+    /**
+     * @var string
+     */
+    protected $scope;
+
+    public function __construct($scope)
+    {
+        $this->scope = $scope;
+    }
+
+    /**
+     * Get current configuration scope identifier
+     *
+     * @return string
+     */
+    public function getCurrentScope() {
+        return $this->scope;
+    }
+
+    /**
+     * @param string $scope
+     * @throws \Exception
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function setCurrentScope($scope){
+        throw new \Exception('readonly');
+    }
+
+}

lib/internal/Magento/Framework/CompiledInterception/README.md

@@ -0,0 +1,88 @@
+### ABOUT
+
+This component changes the way Magento 2 generates Interceptor classes (a mechanism that allows plugins to work together).
+
+Instead of generating boilerplate code it compiles the Interceptor using information from source code. 
+This makes plugins slightly faster and as Magento uses a lot of plugins, even at its core, it lowers request time by ~10%.
+This is important in places where there is a lot of non-cached PHP logic going on (for example admin panel is noticeably faster).
+
+The default method uses code that is called on nearly each method to see if there are any plugins connected, in generated code this is not required and call-stack is reduced.
+
+Having plugins called directly also makes code easier to debug and bugs easier to find.
+
+The Interceptors generated by this plugin are 100% compatible with the ones generated by Magento by default, so there is no need to change anything in your plugins.
+
+### ENABLING
+
+To use compiled interceptors in developer mode please add following preference to your di.xml
+```
+<preference for="Magento\Framework\Interception\Code\Generator\Interceptor" type="Magento\Framework\CompiledInterception\Generator\CompiledInterceptor" />
+```
+
+To use compiled interceptors in production mode please add following preference to your di.xml
+```
+<preference for="Magento\Setup\Module\Di\Code\Generator\Interceptor" type="Magento\Framework\CompiledInterception\Generator\CompiledInterceptor" />
+```
+
+Clear generated files and cache:
+
+`rm -rf generated/* && rm -rf var/cache/* && bin/magento cache:clean`
+
+### DISABLING
+
+Remove preferences from `app/etc/di.xml`, remove module and clear cache and generated files.
+
+### TECHNICAL DETAILS 
+
+Instead of interceptors that read plugins config at runtime like this:
+
+```
+public function methodX($arg) {
+    $pluginInfo = $this->pluginList->getNext($this->subjectType, 'methodX');
+    if (!$pluginInfo) {
+        return parent::methodX($arg);
+    } else {
+        return $this->___callPlugins('methodX', func_get_args(), $pluginInfo);
+    }
+}
+```
+
+This generator generates static interceptors like this:
+
+
+```
+public function methodX($arg) {
+    switch(getCurrentScope()){
+        case 'frontend':
+            $this->_get_example_plugin()->beforeMethodX($this, $arg);
+            $this->_get_another_plugin()->beforeMethodX($this, $arg);
+            $result = $this->_get_around_plugin()->aroundMethodX($this, function($arg){
+                return parent::methodX($arg);
+            });
+            return $this->_get_after_plugin()->afterMethodX($this, $result);
+        case 'adminhtml':
+            // ...
+        default:
+            return parent::methodX($arg);
+    }
+}
+```
+
+
+#### PROS
+
+* Easier debugging. 
+  * If you ever stumbled upon `___callPlugins` when debugging you should know how painful it is to debug issues inside plugins.
+  * Generated code is decorated with PHPDoc for easier debugging in IDE
+
+* Fastest response time (5%-15% faster in developer and production mode)
+  * No redundant calls to `___callPlugins` in call stack.
+  * Methods with no plugins are not overridden in parent at all.
+
+* Implemented as a module and can be easily reverted to the default `Generator\Interceptor`
+
+#### CONS
+
+* Each time after making change in etc plugins config, `generated/code/*` needs to be purged
+* Tiny longer code generation step when run with no cache
+* As this does not load plugins at runtime, might not work in an edge case of plugging into core Magento classes like `PluginsList` etc.