{include parent} and {include this} work inside dynamically named blocks

The name of the enclosing block is resolved at runtime from the stack of
blocks being currently rendered, which is shared along the inheritance
chain. Previously this was a compile error, or, when the dynamic block
was nested inside a static one, the include silently bound to the outer
static block.

To be released in 3.1.

Author: dg

docs/internals/blocks.md

@@ -60,6 +60,19 @@ the same conservative walk (`findBlockDeclarations`: any statement that is not
 a proven inline wrapper may compile its content into a separate method, so it
 resets the "top level" status).
 
+## {include parent}/{include this} in dynamically named blocks
+
+Inside a block with a **static** name, `{include parent}`/`{include this}`
+resolve the name at compile time from the closest enclosing block. Inside a
+**dynamically named** block the compiler emits `null` and the runtime takes the
+name from `Template::$renderingBlocks` — a stack of names of blocks currently
+being rendered, pushed/popped by `renderBlock()` and **shared by reference
+along the inheritance chain** (`createTemplate`, like the block registry; a
+block function executes bound to its defining instance while `renderBlock` runs
+on another one). Note the closest-block search no longer skips dynamic blocks:
+`{include parent}` nested in a dynamic block inside a static one now refers to
+the dynamic block's runtime name, not silently to the outer static block.
+
 The linter's `TemplateReferenceCheck` currently verifies only that **statically
 named template paths exist** (`{include}`, `{import}`, `{extends}`/`{layout}`,
 `{embed file}`, `{sandbox}`, and the `from` of `{include block from}`), resolving

src/Latte/Essential/Nodes/IncludeBlockNode.php

@@ -26,7 +26,8 @@
  */
 class IncludeBlockNode extends StatementNode
 {
-	public ExpressionNode $name;
+	/** null in {include parent}/{include this} inside a dynamically named block; the name is taken from the runtime */
+	public ?ExpressionNode $name = null;
 	public ?ExpressionNode $from = null;
 	public ArrayNode $args;
 	public ModifierNode $modifier;
@@ -64,14 +65,17 @@ public static function create(Tag $tag, TemplateParser $parser): static
 			$item = $tag->closestTag(
 				[BlockNode::class, DefineNode::class],
 				fn($item) => ($item->node instanceof BlockNode || $item->node instanceof DefineNode)
-					&& $item->node->block && !$item->node->block->isDynamic(),
+					&& $item->node->block
+					&& (!$item->node->block->isDynamic() || !$node->from),
 			);
 			if (!$item || !($item->node instanceof BlockNode || $item->node instanceof DefineNode)) {
 				throw new CompileException("Cannot include $tokenName->text block outside of any block.", $tag->position);
 			}
 
 			assert($item->node->block !== null);
-			$node->name = $item->node->block->name;
+			$node->name = $item->node->block->isDynamic()
+				? null // the name of the enclosing block is known only at runtime
+				: $item->node->block->name;
 		}
 
 		$node->modifier->escape = !$node->modifier->removeFilter('noescape') && !$node->parent;
@@ -106,9 +110,9 @@ private function printBlock(PrintContext $context, string $contentFilter): strin
 		return $context->format(
 			'$this->render' . ($this->parent ? 'ParentBlock' : 'Block')
 			. '(%raw, %node? + '
-			. (isset($block) && !$block->parameters ? 'get_defined_vars()' : '[]')
+			. ($this->name === null || (isset($block) && !$block->parameters) ? 'get_defined_vars()' : '[]')
 			. '%raw) %line;',
-			$context->ensureString($this->name, 'Block name'),
+			$this->name === null ? 'null' : $context->ensureString($this->name, 'Block name'),
 			$this->args,
 			$contentFilter ? ", $contentFilter" : '',
 			$this->position,
@@ -118,7 +122,7 @@ private function printBlock(PrintContext $context, string $contentFilter): strin
 
 	private function printBlockFrom(PrintContext $context, string $contentFilter): string
 	{
-		assert($this->from !== null);
+		assert($this->from !== null && $this->name !== null);
 		return $context->format(
 			'$this->createTemplate(%raw, %node? + $this->params, "include")->renderToContentType(%raw, %raw) %line;',
 			$context->ensureString($this->from, 'Template name'),
@@ -132,7 +136,9 @@ private function printBlockFrom(PrintContext $context, string $contentFilter): s
 
 	public function &getIterator(): \Generator
 	{
-		yield $this->name;
+		if ($this->name) {
+			yield $this->name;
+		}
 		if ($this->from) {
 			yield $this->from;
 		}

src/Latte/Runtime/Template.php

@@ -44,6 +44,9 @@ class Template
 
 	/** @var mixed[][] */
 	private array $blockStack = [];
+
+	/** @var string[]  names of blocks being currently rendered */
+	private array $renderingBlocks = [];
 	private bool $collectingBlocks = false;
 	private ?Template $referringTemplate = null;
 	private ?string $referenceType = null;
@@ -111,7 +114,7 @@ public function render(?string $block = null): void
 	 * @internal
 	 */
 	public function renderBlock(
-		string $name,
+		?string $name,
 		array $params,
 		string|\Closure|null $mod = null,
 		int|string|null $layer = null,
@@ -121,6 +124,8 @@ public function renderBlock(
 			return;
 		}
 
+		$name ??= end($this->renderingBlocks)
+			?: throw new Latte\RuntimeException('Cannot include this block outside of any block.');
 		$block = $layer
 			? ($this->blocks[$layer][$name] ?? null)
 			: ($this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null);
@@ -135,12 +140,17 @@ public function renderBlock(
 
 		$fn = reset($block->functions);
 		assert($fn !== false);
-		$this->filter(
-			fn() => $fn($params),
-			$mod,
-			$block->contentType ?? static::ContentType,
-			"block $name",
-		);
+		$this->renderingBlocks[] = $name;
+		try {
+			$this->filter(
+				fn() => $fn($params),
+				$mod,
+				$block->contentType ?? static::ContentType,
+				"block $name",
+			);
+		} finally {
+			array_pop($this->renderingBlocks);
+		}
 	}
 
 
@@ -149,8 +159,10 @@ public function renderBlock(
 	 * @param  mixed[]  $params
 	 * @internal
 	 */
-	public function renderParentBlock(string $name, array $params): void
+	public function renderParentBlock(?string $name, array $params): void
 	{
+		$name ??= end($this->renderingBlocks)
+			?: throw new Latte\RuntimeException('Cannot include parent block outside of any block.');
 		$block = $this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null;
 		if (!$block || ($function = next($block->functions)) === false) {
 			throw new Latte\RuntimeException("Cannot include undefined parent block '$name'.");
@@ -200,6 +212,8 @@ public function createTemplate(string $name, array $params, string $relation): s
 
 			$this->blocks[self::LayerSnippet] += $child->blocks[self::LayerSnippet];
 			$child->blocks[self::LayerSnippet] = &$this->blocks[self::LayerSnippet];
+
+			$child->renderingBlocks = &$this->renderingBlocks;
 		}
 
 		return $child;

tests/tags/block.dynamic.phpt

@@ -53,3 +53,11 @@ Assert::exception(
 	InvalidArgumentException::class,
 	'Block name must be a string, null given.',
 );
+
+
+// {include parent} inside a dynamically named block resolves the name at runtime
+Assert::exception(
+	fn() => createLatte()->renderToString('{var $n = x}{block $n}A {include parent}{/block}'),
+	Latte\RuntimeException::class,
+	"Cannot include undefined parent block 'x'.",
+);

tests/tags/embed.file.phpt

@@ -1111,3 +1111,22 @@ Assert::exception(
 	Latte\CompileException::class,
 	'%a?%Cannot redeclare block %a%',
 );
+
+
+// dynamically named block in a condition combined with {include parent}
+$latte = new Latte\Engine;
+$latte->setLoader(new Latte\Loaders\StringLoader([
+	'embed.latte' => '<b>{block a}orig-a{/block}</b>',
+	'main' => <<<'XX'
+		{embed "embed.latte"}
+		    {var $a = a}
+		    {if true}
+		        {block $a}dynamic-A {include parent}{/block}
+		    {else}
+		        {block $a}never-A {include parent}{/block}
+		    {/if}
+		{/embed}
+		XX,
+]));
+
+Assert::match('<b>dynamic-A orig-a</b>', trim($latte->renderToString('main')));