vendor/twig/twig/src/Environment.php line 304

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Twig;
  14. use Twig\Cache\CacheInterface;
  15. use Twig\Cache\FilesystemCache;
  16. use Twig\Cache\NullCache;
  17. use Twig\Error\Error;
  18. use Twig\Error\LoaderError;
  19. use Twig\Error\RuntimeError;
  20. use Twig\Error\SyntaxError;
  21. use Twig\Extension\CoreExtension;
  22. use Twig\Extension\EscaperExtension;
  23. use Twig\Extension\ExtensionInterface;
  24. use Twig\Extension\OptimizerExtension;
  25. use Twig\Extension\YieldNotReadyExtension;
  26. use Twig\Loader\ArrayLoader;
  27. use Twig\Loader\ChainLoader;
  28. use Twig\Loader\LoaderInterface;
  29. use Twig\Node\Expression\Binary\AbstractBinary;
  30. use Twig\Node\Expression\Unary\AbstractUnary;
  31. use Twig\Node\ModuleNode;
  32. use Twig\Node\Node;
  33. use Twig\NodeVisitor\NodeVisitorInterface;
  34. use Twig\Runtime\EscaperRuntime;
  35. use Twig\RuntimeLoader\FactoryRuntimeLoader;
  36. use Twig\RuntimeLoader\RuntimeLoaderInterface;
  37. use Twig\TokenParser\TokenParserInterface;
  39. /**
  40.  * Stores the Twig configuration and renders templates.
  41.  *
  42.  * @author Fabien Potencier <fabien@symfony.com>
  43.  */
  44. class Environment
  45. {
  46.     public const VERSION = '3.11.0';
  47.     public const VERSION_ID = 301100;
  48.     public const MAJOR_VERSION = 4;
  49.     public const MINOR_VERSION = 11;
  50.     public const RELEASE_VERSION = 0;
  51.     public const EXTRA_VERSION = '';
  53.     private $charset;
  54.     private $loader;
  55.     private $debug;
  56.     private $autoReload;
  57.     private $cache;
  58.     private $lexer;
  59.     private $parser;
  60.     private $compiler;
  61.     /** @var array<string, mixed> */
  62.     private $globals = [];
  63.     private $resolvedGlobals;
  64.     private $loadedTemplates;
  65.     private $strictVariables;
  66.     private $originalCache;
  67.     private $extensionSet;
  68.     private $runtimeLoaders = [];
  69.     private $runtimes = [];
  70.     private $optionsHash;
  71.     /** @var bool */
  72.     private $useYield;
  73.     private $defaultRuntimeLoader;
  75.     /**
  76.      * Constructor.
  77.      *
  78.      * Available options:
  79.      *
  80.      *  * debug: When set to true, it automatically set "auto_reload" to true as
  81.      *           well (default to false).
  82.      *
  83.      *  * charset: The charset used by the templates (default to UTF-8).
  84.      *
  85.      *  * cache: An absolute path where to store the compiled templates,
  86.      *           a \Twig\Cache\CacheInterface implementation,
  87.      *           or false to disable compilation cache (default).
  88.      *
  89.      *  * auto_reload: Whether to reload the template if the original source changed.
  90.      *                 If you don't provide the auto_reload option, it will be
  91.      *                 determined automatically based on the debug value.
  92.      *
  93.      *  * strict_variables: Whether to ignore invalid variables in templates
  94.      *                      (default to false).
  95.      *
  96.      *  * autoescape: Whether to enable auto-escaping (default to html):
  97.      *                  * false: disable auto-escaping
  98.      *                  * html, js: set the autoescaping to one of the supported strategies
  99.      *                  * name: set the autoescaping strategy based on the template name extension
  100.      *                  * PHP callback: a PHP callback that returns an escaping strategy based on the template "name"
  101.      *
  102.      *  * optimizations: A flag that indicates which optimizations to apply
  103.      *                   (default to -1 which means that all optimizations are enabled;
  104.      *                   set it to 0 to disable).
  105.      *
  106.      *  * use_yield: Enable templates to exclusively use "yield" instead of "echo"
  107.      *               (default to "false", but switch it to "true" when possible
  108.      *               as this will be the only supported mode in Twig 4.0)
  109.      */
  110.     public function __construct(LoaderInterface $loader, $options = [])
  111.     {
  112.         $this->setLoader($loader);
  114.         $options = array_merge([
  115.             'debug' => false,
  116.             'charset' => 'UTF-8',
  117.             'strict_variables' => false,
  118.             'autoescape' => 'html',
  119.             'cache' => false,
  120.             'auto_reload' => null,
  121.             'optimizations' => -1,
  122.             'use_yield' => false,
  123.         ], $options);
  125.         $this->useYield = (bool) $options['use_yield'];
  126.         $this->debug = (bool) $options['debug'];
  127.         $this->setCharset($options['charset'] ?? 'UTF-8');
  128.         $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
  129.         $this->strictVariables = (bool) $options['strict_variables'];
  130.         $this->setCache($options['cache']);
  131.         $this->extensionSet = new ExtensionSet();
  132.         $this->defaultRuntimeLoader = new FactoryRuntimeLoader([
  133.             EscaperRuntime::class => function () { return new EscaperRuntime($this->charset); },
  134.         ]);
  136.         $this->addExtension(new CoreExtension());
  137.         $escaperExt = new EscaperExtension($options['autoescape']);
  138.         $escaperExt->setEnvironment($this, false);
  139.         $this->addExtension($escaperExt);
  140.         if (\PHP_VERSION_ID >= 80000) {
  141.             $this->addExtension(new YieldNotReadyExtension($this->useYield));
  142.         }
  143.         $this->addExtension(new OptimizerExtension($options['optimizations']));
  144.     }
  146.     /**
  147.      * @internal
  148.      */
  149.     public function useYield(): bool
  150.     {
  151.         return $this->useYield;
  152.     }
  154.     /**
  155.      * Enables debugging mode.
  156.      */
  157.     public function enableDebug()
  158.     {
  159.         $this->debug = true;
  160.         $this->updateOptionsHash();
  161.     }
  163.     /**
  164.      * Disables debugging mode.
  165.      */
  166.     public function disableDebug()
  167.     {
  168.         $this->debug = false;
  169.         $this->updateOptionsHash();
  170.     }
  172.     /**
  173.      * Checks if debug mode is enabled.
  174.      *
  175.      * @return bool true if debug mode is enabled, false otherwise
  176.      */
  177.     public function isDebug()
  178.     {
  179.         return $this->debug;
  180.     }
  182.     /**
  183.      * Enables the auto_reload option.
  184.      */
  185.     public function enableAutoReload()
  186.     {
  187.         $this->autoReload = true;
  188.     }
  190.     /**
  191.      * Disables the auto_reload option.
  192.      */
  193.     public function disableAutoReload()
  194.     {
  195.         $this->autoReload = false;
  196.     }
  198.     /**
  199.      * Checks if the auto_reload option is enabled.
  200.      *
  201.      * @return bool true if auto_reload is enabled, false otherwise
  202.      */
  203.     public function isAutoReload()
  204.     {
  205.         return $this->autoReload;
  206.     }
  208.     /**
  209.      * Enables the strict_variables option.
  210.      */
  211.     public function enableStrictVariables()
  212.     {
  213.         $this->strictVariables = true;
  214.         $this->updateOptionsHash();
  215.     }
  217.     /**
  218.      * Disables the strict_variables option.
  219.      */
  220.     public function disableStrictVariables()
  221.     {
  222.         $this->strictVariables = false;
  223.         $this->updateOptionsHash();
  224.     }
  226.     /**
  227.      * Checks if the strict_variables option is enabled.
  228.      *
  229.      * @return bool true if strict_variables is enabled, false otherwise
  230.      */
  231.     public function isStrictVariables()
  232.     {
  233.         return $this->strictVariables;
  234.     }
  236.     /**
  237.      * Gets the current cache implementation.
  238.      *
  239.      * @param bool $original Whether to return the original cache option or the real cache instance
  240.      *
  241.      * @return CacheInterface|string|false A Twig\Cache\CacheInterface implementation,
  242.      *                                     an absolute path to the compiled templates,
  243.      *                                     or false to disable cache
  244.      */
  245.     public function getCache($original = true)
  246.     {
  247.         return $original ? $this->originalCache : $this->cache;
  248.     }
  250.     /**
  251.      * Sets the current cache implementation.
  252.      *
  253.      * @param CacheInterface|string|false $cache A Twig\Cache\CacheInterface implementation,
  254.      *                                           an absolute path to the compiled templates,
  255.      *                                           or false to disable cache
  256.      */
  257.     public function setCache($cache)
  258.     {
  259.         if (\is_string($cache)) {
  260.             $this->originalCache = $cache;
  261.             $this->cache = new FilesystemCache($cache, $this->autoReload ? FilesystemCache::FORCE_BYTECODE_INVALIDATION : 0);
  262.         } elseif (false === $cache) {
  263.             $this->originalCache = $cache;
  264.             $this->cache = new NullCache();
  265.         } elseif ($cache instanceof CacheInterface) {
  266.             $this->originalCache = $this->cache = $cache;
  267.         } else {
  268.             throw new \LogicException('Cache can only be a string, false, or a \Twig\Cache\CacheInterface implementation.');
  269.         }
  270.     }
  272.     /**
  273.      * Gets the template class associated with the given string.
  274.      *
  275.      * The generated template class is based on the following parameters:
  276.      *
  277.      *  * The cache key for the given template;
  278.      *  * The currently enabled extensions;
  279.      *  * PHP version;
  280.      *  * Twig version;
  281.      *  * Options with what environment was created.
  282.      *
  283.      * @param string   $name  The name for which to calculate the template class name
  284.      * @param int|null $index The index if it is an embedded template
  285.      *
  286.      * @internal
  287.      */
  288.     public function getTemplateClass(string $name, ?int $index = null): string
  289.     {
  290.         $key = $this->getLoader()->getCacheKey($name).$this->optionsHash;
  292.         return '__TwigTemplate_'.hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $key).(null === $index ? '' : '___'.$index);
  293.     }
  295.     /**
  296.      * Renders a template.
  297.      *
  298.      * @param string|TemplateWrapper $name The template name
  299.      *
  300.      * @throws LoaderError  When the template cannot be found
  301.      * @throws SyntaxError  When an error occurred during compilation
  302.      * @throws RuntimeError When an error occurred during rendering
  303.      */
  304.     public function render($name, array $context = []): string
  305.     {
  306.         return $this->load($name)->render($context);
  307.     }
  309.     /**
  310.      * Displays a template.
  311.      *
  312.      * @param string|TemplateWrapper $name The template name
  313.      *
  314.      * @throws LoaderError  When the template cannot be found
  315.      * @throws SyntaxError  When an error occurred during compilation
  316.      * @throws RuntimeError When an error occurred during rendering
  317.      */
  318.     public function display($name, array $context = []): void
  319.     {
  320.         $this->load($name)->display($context);
  321.     }
  323.     /**
  324.      * Loads a template.
  325.      *
  326.      * @param string|TemplateWrapper $name The template name
  327.      *
  328.      * @throws LoaderError  When the template cannot be found
  329.      * @throws RuntimeError When a previously generated cache is corrupted
  330.      * @throws SyntaxError  When an error occurred during compilation
  331.      */
  332.     public function load($name): TemplateWrapper
  333.     {
  334.         if ($name instanceof TemplateWrapper) {
  335.             return $name;
  336.         }
  337.         if ($name instanceof Template) {
  338.             trigger_deprecation('twig/twig', '3.9', 'Passing a "%s" instance to "%s" is deprecated.', self::class, __METHOD__);
  340.             return $name;
  341.         }
  343.         return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
  344.     }
  346.     /**
  347.      * Loads a template internal representation.
  348.      *
  349.      * This method is for internal use only and should never be called
  350.      * directly.
  351.      *
  352.      * @param string   $name  The template name
  353.      * @param int|null $index The index if it is an embedded template
  354.      *
  355.      * @throws LoaderError  When the template cannot be found
  356.      * @throws RuntimeError When a previously generated cache is corrupted
  357.      * @throws SyntaxError  When an error occurred during compilation
  358.      *
  359.      * @internal
  360.      */
  361.     public function loadTemplate(string $cls, string $name, ?int $index = null): Template
  362.     {
  363.         $mainCls = $cls;
  364.         if (null !== $index) {
  365.             $cls .= '___'.$index;
  366.         }
  368.         if (isset($this->loadedTemplates[$cls])) {
  369.             return $this->loadedTemplates[$cls];
  370.         }
  372.         if (!class_exists($cls, false)) {
  373.             $key = $this->cache->generateKey($name, $mainCls);
  375.             if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
  376.                 $this->cache->load($key);
  377.             }
  379.             if (!class_exists($cls, false)) {
  380.                 $source = $this->getLoader()->getSourceContext($name);
  381.                 $content = $this->compileSource($source);
  382.                 $this->cache->write($key, $content);
  383.                 $this->cache->load($key);
  385.                 if (!class_exists($mainCls, false)) {
  386.                     /* Last line of defense if either $this->bcWriteCacheFile was used,
  387.                      * $this->cache is implemented as a no-op or we have a race condition
  388.                      * where the cache was cleared between the above calls to write to and load from
  389.                      * the cache.
  390.                      */
  391.                     eval('?>'.$content);
  392.                 }
  394.                 if (!class_exists($cls, false)) {
  395.                     throw new RuntimeError(\sprintf('Failed to load Twig template "%s", index "%s": cache might be corrupted.', $name, $index), -1, $source);
  396.                 }
  397.             }
  398.         }
  400.         $this->extensionSet->initRuntime();
  402.         return $this->loadedTemplates[$cls] = new $cls($this);
  403.     }
  405.     /**
  406.      * Creates a template from source.
  407.      *
  408.      * This method should not be used as a generic way to load templates.
  409.      *
  410.      * @param string      $template The template source
  411.      * @param string|null $name     An optional name of the template to be used in error messages
  412.      *
  413.      * @throws LoaderError When the template cannot be found
  414.      * @throws SyntaxError When an error occurred during compilation
  415.      */
  416.     public function createTemplate(string $template, ?string $name = null): TemplateWrapper
  417.     {
  418.         $hash = hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $template, false);
  419.         if (null !== $name) {
  420.             $name = \sprintf('%s (string template %s)', $name, $hash);
  421.         } else {
  422.             $name = \sprintf('__string_template__%s', $hash);
  423.         }
  425.         $loader = new ChainLoader([
  426.             new ArrayLoader([$name => $template]),
  427.             $current = $this->getLoader(),
  428.         ]);
  430.         $this->setLoader($loader);
  431.         try {
  432.             return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
  433.         } finally {
  434.             $this->setLoader($current);
  435.         }
  436.     }
  438.     /**
  439.      * Returns true if the template is still fresh.
  440.      *
  441.      * Besides checking the loader for freshness information,
  442.      * this method also checks if the enabled extensions have
  443.      * not changed.
  444.      *
  445.      * @param int $time The last modification time of the cached template
  446.      */
  447.     public function isTemplateFresh(string $name, int $time): bool
  448.     {
  449.         return $this->extensionSet->getLastModified() <= $time && $this->getLoader()->isFresh($name, $time);
  450.     }
  452.     /**
  453.      * Tries to load a template consecutively from an array.
  454.      *
  455.      * Similar to load() but it also accepts instances of \Twig\TemplateWrapper
  456.      * and an array of templates where each is tried to be loaded.
  457.      *
  458.      * @param string|TemplateWrapper|array<string|TemplateWrapper> $names A template or an array of templates to try consecutively
  459.      *
  460.      * @throws LoaderError When none of the templates can be found
  461.      * @throws SyntaxError When an error occurred during compilation
  462.      */
  463.     public function resolveTemplate($names): TemplateWrapper
  464.     {
  465.         if (!\is_array($names)) {
  466.             return $this->load($names);
  467.         }
  469.         $count = \count($names);
  470.         foreach ($names as $name) {
  471.             if ($name instanceof Template) {
  472.                 trigger_deprecation('twig/twig', '3.9', 'Passing a "%s" instance to "%s" is deprecated.', Template::class, __METHOD__);
  474.                 return new TemplateWrapper($this, $name);
  475.             }
  476.             if ($name instanceof TemplateWrapper) {
  477.                 return $name;
  478.             }
  480.             if (1 !== $count && !$this->getLoader()->exists($name)) {
  481.                 continue;
  482.             }
  484.             return $this->load($name);
  485.         }
  487.         throw new LoaderError(\sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
  488.     }
  490.     public function setLexer(Lexer $lexer)
  491.     {
  492.         $this->lexer = $lexer;
  493.     }
  495.     /**
  496.      * @throws SyntaxError When the code is syntactically wrong
  497.      */
  498.     public function tokenize(Source $source): TokenStream
  499.     {
  500.         if (null === $this->lexer) {
  501.             $this->lexer = new Lexer($this);
  502.         }
  504.         return $this->lexer->tokenize($source);
  505.     }
  507.     public function setParser(Parser $parser)
  508.     {
  509.         $this->parser = $parser;
  510.     }
  512.     /**
  513.      * Converts a token stream to a node tree.
  514.      *
  515.      * @throws SyntaxError When the token stream is syntactically or semantically wrong
  516.      */
  517.     public function parse(TokenStream $stream): ModuleNode
  518.     {
  519.         if (null === $this->parser) {
  520.             $this->parser = new Parser($this);
  521.         }
  523.         return $this->parser->parse($stream);
  524.     }
  526.     public function setCompiler(Compiler $compiler)
  527.     {
  528.         $this->compiler = $compiler;
  529.     }
  531.     /**
  532.      * Compiles a node and returns the PHP code.
  533.      */
  534.     public function compile(Node $node): string
  535.     {
  536.         if (null === $this->compiler) {
  537.             $this->compiler = new Compiler($this);
  538.         }
  540.         return $this->compiler->compile($node)->getSource();
  541.     }
  543.     /**
  544.      * Compiles a template source code.
  545.      *
  546.      * @throws SyntaxError When there was an error during tokenizing, parsing or compiling
  547.      */
  548.     public function compileSource(Source $source): string
  549.     {
  550.         try {
  551.             return $this->compile($this->parse($this->tokenize($source)));
  552.         } catch (Error $e) {
  553.             $e->setSourceContext($source);
  554.             throw $e;
  555.         } catch (\Exception $e) {
  556.             throw new SyntaxError(\sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $source, $e);
  557.         }
  558.     }
  560.     public function setLoader(LoaderInterface $loader)
  561.     {
  562.         $this->loader = $loader;
  563.     }
  565.     public function getLoader(): LoaderInterface
  566.     {
  567.         return $this->loader;
  568.     }
  570.     public function setCharset(string $charset)
  571.     {
  572.         if ('UTF8' === $charset = strtoupper($charset ?: '')) {
  573.             // iconv on Windows requires "UTF-8" instead of "UTF8"
  574.             $charset = 'UTF-8';
  575.         }
  577.         $this->charset = $charset;
  578.     }
  580.     public function getCharset(): string
  581.     {
  582.         return $this->charset;
  583.     }
  585.     public function hasExtension(string $class): bool
  586.     {
  587.         return $this->extensionSet->hasExtension($class);
  588.     }
  590.     public function addRuntimeLoader(RuntimeLoaderInterface $loader)
  591.     {
  592.         $this->runtimeLoaders[] = $loader;
  593.     }
  595.     /**
  596.      * @template TExtension of ExtensionInterface
  597.      *
  598.      * @param class-string<TExtension> $class
  599.      *
  600.      * @return TExtension
  601.      */
  602.     public function getExtension(string $class): ExtensionInterface
  603.     {
  604.         return $this->extensionSet->getExtension($class);
  605.     }
  607.     /**
  608.      * Returns the runtime implementation of a Twig element (filter/function/tag/test).
  609.      *
  610.      * @template TRuntime of object
  611.      *
  612.      * @param class-string<TRuntime> $class A runtime class name
  613.      *
  614.      * @return TRuntime The runtime implementation
  615.      *
  616.      * @throws RuntimeError When the template cannot be found
  617.      */
  618.     public function getRuntime(string $class)
  619.     {
  620.         if (isset($this->runtimes[$class])) {
  621.             return $this->runtimes[$class];
  622.         }
  624.         foreach ($this->runtimeLoaders as $loader) {
  625.             if (null !== $runtime = $loader->load($class)) {
  626.                 return $this->runtimes[$class] = $runtime;
  627.             }
  628.         }
  630.         if (null !== $runtime = $this->defaultRuntimeLoader->load($class)) {
  631.             return $this->runtimes[$class] = $runtime;
  632.         }
  634.         throw new RuntimeError(\sprintf('Unable to load the "%s" runtime.', $class));
  635.     }
  637.     public function addExtension(ExtensionInterface $extension)
  638.     {
  639.         $this->extensionSet->addExtension($extension);
  640.         $this->updateOptionsHash();
  641.     }
  643.     /**
  644.      * @param ExtensionInterface[] $extensions An array of extensions
  645.      */
  646.     public function setExtensions(array $extensions)
  647.     {
  648.         $this->extensionSet->setExtensions($extensions);
  649.         $this->updateOptionsHash();
  650.     }
  652.     /**
  653.      * @return ExtensionInterface[] An array of extensions (keys are for internal usage only and should not be relied on)
  654.      */
  655.     public function getExtensions(): array
  656.     {
  657.         return $this->extensionSet->getExtensions();
  658.     }
  660.     public function addTokenParser(TokenParserInterface $parser)
  661.     {
  662.         $this->extensionSet->addTokenParser($parser);
  663.     }
  665.     /**
  666.      * @return TokenParserInterface[]
  667.      *
  668.      * @internal
  669.      */
  670.     public function getTokenParsers(): array
  671.     {
  672.         return $this->extensionSet->getTokenParsers();
  673.     }
  675.     /**
  676.      * @internal
  677.      */
  678.     public function getTokenParser(string $name): ?TokenParserInterface
  679.     {
  680.         return $this->extensionSet->getTokenParser($name);
  681.     }
  683.     public function registerUndefinedTokenParserCallback(callable $callable): void
  684.     {
  685.         $this->extensionSet->registerUndefinedTokenParserCallback($callable);
  686.     }
  688.     public function addNodeVisitor(NodeVisitorInterface $visitor)
  689.     {
  690.         $this->extensionSet->addNodeVisitor($visitor);
  691.     }
  693.     /**
  694.      * @return NodeVisitorInterface[]
  695.      *
  696.      * @internal
  697.      */
  698.     public function getNodeVisitors(): array
  699.     {
  700.         return $this->extensionSet->getNodeVisitors();
  701.     }
  703.     public function addFilter(TwigFilter $filter)
  704.     {
  705.         $this->extensionSet->addFilter($filter);
  706.     }
  708.     /**
  709.      * @internal
  710.      */
  711.     public function getFilter(string $name): ?TwigFilter
  712.     {
  713.         return $this->extensionSet->getFilter($name);
  714.     }
  716.     public function registerUndefinedFilterCallback(callable $callable): void
  717.     {
  718.         $this->extensionSet->registerUndefinedFilterCallback($callable);
  719.     }
  721.     /**
  722.      * Gets the registered Filters.
  723.      *
  724.      * Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.
  725.      *
  726.      * @return TwigFilter[]
  727.      *
  728.      * @see registerUndefinedFilterCallback
  729.      *
  730.      * @internal
  731.      */
  732.     public function getFilters(): array
  733.     {
  734.         return $this->extensionSet->getFilters();
  735.     }
  737.     public function addTest(TwigTest $test)
  738.     {
  739.         $this->extensionSet->addTest($test);
  740.     }
  742.     /**
  743.      * @return TwigTest[]
  744.      *
  745.      * @internal
  746.      */
  747.     public function getTests(): array
  748.     {
  749.         return $this->extensionSet->getTests();
  750.     }
  752.     /**
  753.      * @internal
  754.      */
  755.     public function getTest(string $name): ?TwigTest
  756.     {
  757.         return $this->extensionSet->getTest($name);
  758.     }
  760.     public function addFunction(TwigFunction $function)
  761.     {
  762.         $this->extensionSet->addFunction($function);
  763.     }
  765.     /**
  766.      * @internal
  767.      */
  768.     public function getFunction(string $name): ?TwigFunction
  769.     {
  770.         return $this->extensionSet->getFunction($name);
  771.     }
  773.     public function registerUndefinedFunctionCallback(callable $callable): void
  774.     {
  775.         $this->extensionSet->registerUndefinedFunctionCallback($callable);
  776.     }
  778.     /**
  779.      * Gets registered functions.
  780.      *
  781.      * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
  782.      *
  783.      * @return TwigFunction[]
  784.      *
  785.      * @see registerUndefinedFunctionCallback
  786.      *
  787.      * @internal
  788.      */
  789.     public function getFunctions(): array
  790.     {
  791.         return $this->extensionSet->getFunctions();
  792.     }
  794.     /**
  795.      * Registers a Global.
  796.      *
  797.      * New globals can be added before compiling or rendering a template;
  798.      * but after, you can only update existing globals.
  799.      *
  800.      * @param mixed $value The global value
  801.      */
  802.     public function addGlobal(string $name, $value)
  803.     {
  804.         if ($this->extensionSet->isInitialized() && !\array_key_exists($name, $this->getGlobals())) {
  805.             throw new \LogicException(\sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
  806.         }
  808.         if (null !== $this->resolvedGlobals) {
  809.             $this->resolvedGlobals[$name] = $value;
  810.         } else {
  811.             $this->globals[$name] = $value;
  812.         }
  813.     }
  815.     /**
  816.      * @internal
  817.      *
  818.      * @return array<string, mixed>
  819.      */
  820.     public function getGlobals(): array
  821.     {
  822.         if ($this->extensionSet->isInitialized()) {
  823.             if (null === $this->resolvedGlobals) {
  824.                 $this->resolvedGlobals = array_merge($this->extensionSet->getGlobals(), $this->globals);
  825.             }
  827.             return $this->resolvedGlobals;
  828.         }
  830.         return array_merge($this->extensionSet->getGlobals(), $this->globals);
  831.     }
  833.     public function mergeGlobals(array $context): array
  834.     {
  835.         // we don't use array_merge as the context being generally
  836.         // bigger than globals, this code is faster.
  837.         foreach ($this->getGlobals() as $key => $value) {
  838.             if (!\array_key_exists($key, $context)) {
  839.                 $context[$key] = $value;
  840.             }
  841.         }
  843.         return $context;
  844.     }
  846.     /**
  847.      * @internal
  848.      *
  849.      * @return array<string, array{precedence: int, class: class-string<AbstractUnary>}>
  850.      */
  851.     public function getUnaryOperators(): array
  852.     {
  853.         return $this->extensionSet->getUnaryOperators();
  854.     }
  856.     /**
  857.      * @internal
  858.      *
  859.      * @return array<string, array{precedence: int, class: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}>
  860.      */
  861.     public function getBinaryOperators(): array
  862.     {
  863.         return $this->extensionSet->getBinaryOperators();
  864.     }
  866.     private function updateOptionsHash(): void
  867.     {
  868.         $this->optionsHash = implode(':', [
  869.             $this->extensionSet->getSignature(),
  870.             \PHP_MAJOR_VERSION,
  871.             \PHP_MINOR_VERSION,
  872.             self::VERSION,
  873.             (int) $this->debug,
  874.             (int) $this->strictVariables,
  875.             $this->useYield ? '1' : '0',
  876.         ]);
  877.     }
  878. }