Improved caching (#469)

Author: MartinMystikJonas

CHANGELOG.md

@@ -4,9 +4,14 @@
 ### Added
 - Check if value outputted in template (or escaped for output) can be converted to string
 - Support for PHP 8.4
+- Caching of collected Latte context (variables, components, templates, ...) to improve performance
+- Improved caching of compiled templates to improve performance
+- Memoizing of repeatedly called methods to improve performance
 ### Fixed
 - Fixed unwanted narrowing of template variable types
 
+This version should significantly improve performace of repeated runs.
+
 ## [0.18] - 2025-07-22
 ### Updated
 - Compatibility with PHPStan 2.x (**BC break**)

composer.json

@@ -18,7 +18,7 @@
         "phpunit/phpunit": "^9.5",
         "nette/application": "^3.1.11",
         "nette/forms": "^3.1.12",
-        "nikic/php-parser": "^5.5",
+        "nikic/php-parser": "5.6.0",
         "efabrica/coding-standard": "^0.7",
         "phpstan/phpstan-strict-rules": "^2.0",
         "spaze/phpstan-disallowed-calls": "^2.11|^3.0|^4.0"

docs/configuration.md

@@ -278,3 +278,22 @@ parameters:
     latte:
         strictMode: true
 ```
+
+### debugMode
+Type: `bool`
+
+Enables debugMode that disables cache usage
+
+Default:
+```neon
+parameters:
+    latte:
+        debugMode: false
+```
+
+Example:
+```neon
+parameters:
+    latte:
+        debugMode: true
+```

extension.neon

@@ -17,6 +17,7 @@ parameters:
     latte:
         strictMode: false
         tmpDir: null
+        debugMode: false
         globalVariables: []
         filters:
             translate: [Nette\Localization\Translator, translate]
@@ -48,6 +49,7 @@ parametersSchema:
     latte: structure([
         strictMode: bool()
         tmpDir: schema(string(), nullable())
+        debugMode: bool()
         globalVariables: arrayOf(string(), string())
         filters: arrayOf(anyOf(string(), arrayOf(string())), string())
         functions: arrayOf(anyOf(string(), arrayOf(string())), string())
@@ -103,15 +105,15 @@ services:
     - Efabrica\PHPStanLatte\Analyser\AnalysedTemplatesRegistry(@fileExcluderAnalyse, %analysedPaths%, %latte.reportUnanalysedTemplates%)
 
     -
-        factory: Efabrica\PHPStanLatte\Compiler\CompiledTemplateDirResolver
+        factory: Efabrica\PHPStanLatte\Temp\TempDirResolver
         arguments:
             tmpDir: %latte.tmpDir%
 
     -
         class: Efabrica\PHPStanLatte\Compiler\LatteToPhpCompiler
         arguments:
             cacheKey: ::md5(::json_encode(%latte%))
-            debugMode: %debugMode%
+            debugMode: %latte.debugMode%
     -
         factory: Efabrica\PHPStanLatte\Compiler\Postprocessor
         arguments:
@@ -124,6 +126,7 @@ services:
         factory: Efabrica\PHPStanLatte\Analyser\LatteContextAnalyser
         arguments:
             parser: @latteCurrentPhpVersionRichParser
+            debugMode: %latte.debugMode%
 
     # Latte template resolvers
     - Efabrica\PHPStanLatte\LatteTemplateResolver\Nette\NetteApplicationUIPresenter
@@ -231,7 +234,7 @@ services:
     - Efabrica\PHPStanLatte\LatteContext\Collector\TemplateRenderCollector\TemplateRenderCallsCollector
 
     # Error builder
-    - Efabrica\PHPStanLatte\Error\LineMapper\LineMapper(%debugMode%)
+    - Efabrica\PHPStanLatte\Error\LineMapper\LineMapper(%latte.debugMode%)
     - Efabrica\PHPStanLatte\Error\ErrorBuilder(%latte.errorPatternsToIgnore%, %latte.warningPatterns%, %latte.strictMode%)
 
     # Error transformers

phpstan.neon

@@ -162,6 +162,9 @@ parameters:
                 - '#^Call to an undefined method Latte\\Engine\:\:addExtension\(\)\.$#'
                 - '#^Parameter \#1 \$phpContent of method Efabrica\\PHPStanLatte\\Compiler\\Compiler\\Latte3Compiler::fixLines\(\) expects string, mixed given\.#'
                 - '#^PHPDoc tag @var with type array<string, callable> is not subtype of type array<string>\.#'
+                - '#^Parameter \#1 \$object of function get_class expects object, mixed given\.#'
+                - '#^Call to function is_array\(\) with array<Latte\\Extension> will always evaluate to true\.#'
+                - '#^Call to function is_object\(\) with Latte\\Extension will always evaluate to true\.#'
             path: src/Compiler/Compiler/Latte3Compiler.php
             reportUnmatched: false
 
@@ -198,3 +201,7 @@ parameters:
             # present only in nette/utils 4
             message: '#^PHPDoc tag @var with type SplFileInfo is not subtype of native type Nette\\Utils\\FileInfo\.$#'
             reportUnmatched: false
+        -
+            message: '#^Parameter \#1 .* of static method .*::fromJson\(\) expects array{.*}, array.* given\.$#'
+        -
+            message: '#^Parameter \#1 .* of static method .*::.*FromJson\(\) expects array{.*}, array.* given\.$#'

src/Analyser/LatteContextAnalyser.php

@@ -4,8 +4,13 @@
 
 namespace Efabrica\PHPStanLatte\Analyser;
 
-use Efabrica\PHPStanLatte\LatteContext\CollectedData\CollectedRelatedFiles;
+use Composer\InstalledVersions;
 use Efabrica\PHPStanLatte\LatteContext\Collector\AbstractLatteContextCollector;
+use Efabrica\PHPStanLatte\Temp\TempDirResolver;
+use Exception;
+use InvalidArgumentException;
+use Nette\Utils\FileSystem;
+use Nette\Utils\Json;
 use PhpParser\Node;
 use PhpParser\Node\Stmt\TraitUse;
 use PHPStan\Analyser\NodeScopeResolver;
@@ -14,8 +19,10 @@
 use PHPStan\Analyser\ScopeFactory;
 use PHPStan\File\FileHelper;
 use PHPStan\Parser\Parser;
+use PHPStan\PhpDoc\TypeStringResolver;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\RuleErrorBuilder;
+use RuntimeException;
 use Throwable;
 
 final class LatteContextAnalyser
@@ -26,12 +33,16 @@ final class LatteContextAnalyser
 
     private Parser $parser;
 
+    private TypeStringResolver $typeStringResolver;
+
     private ReflectionProvider $reflectionProvider;
 
     private FileHelper $fileHelper;
 
     private LatteContextCollectorRegistry $collectorRegistry;
 
+    private string $tmpDir;
+
     /**
      * @param AbstractLatteContextCollector[] $collectors
      */
@@ -41,15 +52,23 @@ public function __construct(
         ReflectionProvider $reflectionProvider,
         FileHelper $fileHelper,
         Parser $parser,
-        array $collectors
+        TypeStringResolver $typeStringResolver,
+        TempDirResolver $tempDirResolver,
+        array $collectors,
+        bool $debugMode = false
     ) {
         $this->scopeFactory = $scopeFactory;
         $this->nodeScopeResolver = clone $nodeScopeResolver;
         $this->reflectionProvider = $reflectionProvider;
         $this->fileHelper = $fileHelper;
         // $this->nodeScopeResolver->setAnalysedFiles(null); TODO when changes in PHPStan are merged
         $this->parser = $parser;
+        $this->typeStringResolver = $typeStringResolver;
         $this->collectorRegistry = new LatteContextCollectorRegistry($collectors);
+        $this->tmpDir = $tempDirResolver->resolveCollectorDir();
+        if (file_exists($this->tmpDir) && $debugMode) {
+            FileSystem::delete($this->tmpDir);
+        }
     }
 
     /**
@@ -59,29 +78,34 @@ public function analyseFiles(array $files): LatteContextData
     {
         $errors = [];
         $collectedData = [];
+        $processedFiles = [];
+        $counter = 0;
 
         $this->nodeScopeResolver->setAnalysedFiles($files); // TODO when changes in PHPStan are merged
 
-        $collectedRelatedFiles = [];
         do {
+            if ($counter++ > 100) {
+                throw new RuntimeException('Infinite loop detected in LatteContextAnalyser.');
+            }
+            $relatedFiles = [];
             foreach ($files as $file) {
-                $fileResult = $this->analyseFile($file);
-                if ($fileResult->getErrors() !== []) {
-                    $errors = array_merge($errors, $fileResult->getErrors());
+                $fileResult = $this->loadLatteContextDataFromCache($file);
+                if (!$fileResult) {
+                    $fileResult = $this->analyseFile($file);
+                    if ($fileResult->getErrors() === []) {
+                        $this->saveLatteContextDataToCache($file, $fileResult);
+                    } else {
+                        $errors = array_merge($errors, $fileResult->getErrors());
+                    }
+                } else {
                 }
                 if ($fileResult->getAllCollectedData() !== []) {
                     $collectedData = array_merge($collectedData, $fileResult->getAllCollectedData());
+                    $processedFiles = array_unique(array_merge($processedFiles, $fileResult->getProcessedFiles()));
+                    $relatedFiles = array_unique(array_merge($relatedFiles, $fileResult->getRelatedFiles()));
                 }
-                $collectedRelatedFiles = array_merge($collectedRelatedFiles, $fileResult->getCollectedData(CollectedRelatedFiles::class));
             }
-
-            $processedFiles = [];
-            $relatedFiles = [];
-            foreach ($collectedRelatedFiles as $collectedRelatedFile) {
-                $processedFiles[] = $collectedRelatedFile->getProcessedFile();
-                $relatedFiles[] = $collectedRelatedFile->getRelatedFiles();
-            }
-            $files = array_diff(array_unique(array_merge(...$relatedFiles)), array_unique($processedFiles));
+            $files = array_diff($relatedFiles, $processedFiles);
         } while (count($files) > 0);
 
         return new LatteContextData($collectedData, $errors);
@@ -169,4 +193,115 @@ public function withCollectors(array $collectors): self
         $clone->collectorRegistry = new LatteContextCollectorRegistry($collectors);
         return $clone;
     }
+
+    private function cacheFilename(string $file): string
+    {
+        $cacheKey = md5(
+            $file .
+            PHP_VERSION_ID .
+            (class_exists(InstalledVersions::class) ? json_encode(InstalledVersions::getAllRawData()) : '')
+        );
+        return $this->tmpDir . basename($file) . '.' . $cacheKey . '.json';
+    }
+
+    private function saveLatteContextDataToCache(string $file, LatteContextData $fileResult): void
+    {
+        if (!is_dir($this->tmpDir)) {
+            Filesystem::createDir($this->tmpDir, 0777);
+        }
+
+        $cacheFile = $this->cacheFilename($file);
+
+        try {
+            $data = $fileResult->jsonSerialize();
+        } catch (InvalidArgumentException $e) {
+            // Cannot serialize data, skip caching
+            if (is_file($cacheFile)) {
+                FileSystem::delete($cacheFile);
+            }
+            return;
+        }
+
+        $cacheData = [
+            'file' => $file,
+            'fileHash' => sha1(Filesystem::read($file)),
+            'data' => $data,
+        ];
+        foreach ($fileResult->getRelatedFiles() as $relatedFile) {
+            $cacheData['dependencies'][] = [
+                'file' => $relatedFile,
+                'fileHash' => sha1(Filesystem::read($relatedFile)),
+            ];
+        }
+        Filesystem::write(
+            $cacheFile,
+            Json::encode($cacheData, JSON_PRETTY_PRINT)
+        );
+    }
+
+    private function loadLatteContextDataFromCache(string $file): ?LatteContextData
+    {
+        $cacheFile = $this->cacheFilename($file);
+        if (!is_file($cacheFile)) {
+            return null;
+        }
+
+        try {
+            $cacheData = Json::decode(Filesystem::read($cacheFile), JSON_OBJECT_AS_ARRAY);
+        } catch (Exception $e) {
+            FileSystem::delete($cacheFile);
+            return null;
+        }
+
+        if (!is_array($cacheData) || !isset($cacheData['file'], $cacheData['fileHash'], $cacheData['data'])) {
+            FileSystem::delete($cacheFile);
+            return null;
+        }
+
+        $file = $cacheData['file'];
+        $fileHash = $cacheData['fileHash'];
+
+        if (!is_string($file) || !is_string($fileHash)) {
+            FileSystem::delete($cacheFile);
+            return null;
+        }
+
+        // Check if the file has changed since the cache was created
+        if (sha1(Filesystem::read($file)) !== $fileHash) {
+            return null;
+        }
+
+        if (isset($cacheData['dependencies']) && is_array($cacheData['dependencies'])) {
+            foreach ($cacheData['dependencies'] as $dependency) {
+                if (!is_array($dependency) || !isset($dependency['file'], $dependency['fileHash'])) {
+                    return null;
+                }
+                $dependencyFile = $dependency['file'];
+                $dependencyFileHash = $dependency['fileHash'];
+                if (!is_string($dependencyFile) || !is_string($dependencyFileHash)) {
+                    return null;
+                }
+                if (!is_file($dependencyFile)) {
+                    return null;
+                }
+                // Check if the dependency file has changed since the cache was created
+                if (sha1(Filesystem::read($dependencyFile)) !== $dependencyFileHash) {
+                    return null;
+                }
+            }
+        }
+
+        $data = $cacheData['data'];
+        if (!is_array($data)) {
+            FileSystem::delete($cacheFile);
+            return null;
+        }
+
+        try {
+            return LatteContextData::fromJson($data, $this->typeStringResolver);
+        } catch (Exception $e) {
+            FileSystem::delete($cacheFile);
+            return null;
+        }
+    }
 }