Merge remote-tracking branch 'origin/master'

kylekatarnls · kylekatarnls · commit de7888e41249 · 2025-03-07T19:49:29.000Z
split: 5b726dc15ef2bacbe76a8e2f20731238f5a7ecfe
diff --git a/Compiler.php b/Compiler.php
@@ -499,7 +499,7 @@ public function getBlocks()
      *
      * @return ElementInterface
      */
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $nodeEvent = new NodeEvent($node);
         $this->trigger($nodeEvent);
@@ -537,7 +537,7 @@ public function compileNode(NodeInterface $node, ElementInterface $parent = null
      * @param BlockElement $block
      * @param array        $children
      */
-    public function replaceBlock(BlockElement $block, array $children = null)
+    public function replaceBlock(BlockElement $block, ?array $children = null)
     {
         if ($parent = $block->getParent()) {
             foreach (array_reverse($children ?: $block->getChildren()) as $child) {
diff --git a/Compiler/AbstractNodeCompiler.php b/Compiler/AbstractNodeCompiler.php
@@ -41,7 +41,7 @@ public function getCompiler()
      *
      * @return ElementInterface[]
      */
-    public function getCompiledNodeList($nodeList, ElementInterface $element = null)
+    public function getCompiledNodeList($nodeList, ?ElementInterface $element = null)
     {
         return array_values(array_filter(array_map(
             function (NodeInterface $childNode) use ($element) {
@@ -59,7 +59,7 @@ function (NodeInterface $childNode) use ($element) {
      *
      * @return ElementInterface[]
      */
-    public function getCompiledChildren(NodeInterface $node, ElementInterface $element = null)
+    public function getCompiledChildren(NodeInterface $node, ?ElementInterface $element = null)
     {
         return $this->getCompiledNodeList($node->getChildren(), $element);
     }
@@ -71,7 +71,7 @@ public function getCompiledChildren(NodeInterface $node, ElementInterface $eleme
      * @param NodeInterface         $node
      * @param ElementInterface|null $element
      */
-    public function compileNodeChildren(NodeInterface $node, ElementInterface $element = null)
+    public function compileNodeChildren(NodeInterface $node, ?ElementInterface $element = null)
     {
         $children = array_filter($node->getChildren());
         array_walk($children, function (NodeInterface $childNode) use ($element) {
@@ -109,7 +109,7 @@ protected function getTextChildren(ParserNodeInterface $node)
         }, $children));
     }
 
-    private function compileParserNode(NodeInterface $node, ElementInterface $element = null)
+    private function compileParserNode(NodeInterface $node, ?ElementInterface $element = null)
     {
         return $node instanceof ParserNodeInterface
             ? $this->getCompiler()->compileNode($node, $element)
diff --git a/Compiler/Element/BlockElement.php b/Compiler/Element/BlockElement.php
@@ -22,9 +22,9 @@ class BlockElement extends AbstractElement
     public function __construct(
         CompilerInterface $compiler,
         $name = '',
-        ParserNode $originNode = null,
-        NodeInterface $parent = null,
-        array $children = null
+        ?ParserNode $originNode = null,
+        ?NodeInterface $parent = null,
+        ?array $children = null
     ) {
         $blocks = &$compiler->getBlocksByName($name);
         $blocks[] = $this;
diff --git a/Compiler/NodeCompiler/AssignmentListNodeCompiler.php b/Compiler/NodeCompiler/AssignmentListNodeCompiler.php
@@ -9,7 +9,7 @@
 
 class AssignmentListNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof AssignmentListNode,
diff --git a/Compiler/NodeCompiler/AssignmentNodeCompiler.php b/Compiler/NodeCompiler/AssignmentNodeCompiler.php
@@ -13,7 +13,7 @@
 
 class AssignmentNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof AssignmentNode,
diff --git a/Compiler/NodeCompiler/AttributeListNodeCompiler.php b/Compiler/NodeCompiler/AttributeListNodeCompiler.php
@@ -9,7 +9,7 @@
 
 class AttributeListNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof AttributeListNode,
diff --git a/Compiler/NodeCompiler/AttributeNodeCompiler.php b/Compiler/NodeCompiler/AttributeNodeCompiler.php
@@ -57,7 +57,7 @@ protected function compileValue(AttributeNode $node)
         return $value;
     }
 
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof AttributeNode,
diff --git a/Compiler/NodeCompiler/BlockNodeCompiler.php b/Compiler/NodeCompiler/BlockNodeCompiler.php
@@ -12,7 +12,7 @@
 
 class BlockNodeCompiler extends AbstractNodeCompiler
 {
-    protected function compileAnonymousBlock(BlockNode $node, ElementInterface $parent = null)
+    protected function compileAnonymousBlock(BlockNode $node, ?ElementInterface $parent = null)
     {
         $mixin = $node;
         while ($mixin->hasParent() && !($mixin instanceof MixinNode)) {
@@ -38,7 +38,7 @@ protected function hasBlockParent(BlockNode $node)
         return false;
     }
 
-    protected function compileNamedBlock($name, BlockNode $node, ElementInterface $parent = null)
+    protected function compileNamedBlock($name, BlockNode $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $layout = $compiler->getLayout();
@@ -63,7 +63,7 @@ protected function compileNamedBlock($name, BlockNode $node, ElementInterface $p
         );
     }
 
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof BlockNode,
diff --git a/Compiler/NodeCompiler/CaseNodeCompiler.php b/Compiler/NodeCompiler/CaseNodeCompiler.php
@@ -8,7 +8,7 @@
 
 class CaseNodeCompiler extends AbstractStatementNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof CaseNode,
diff --git a/Compiler/NodeCompiler/CodeNodeCompiler.php b/Compiler/NodeCompiler/CodeNodeCompiler.php
@@ -12,7 +12,7 @@
 
 class CodeNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof CodeNode,
@@ -42,7 +42,7 @@ public function compileNode(NodeInterface $node, ElementInterface $parent = null
         return $code;
     }
 
-    private function getCodeElement(CodeNode $node, array $texts, array $children, ElementInterface $parent = null)
+    private function getCodeElement(CodeNode $node, array $texts, array $children, ?ElementInterface $parent = null)
     {
         if (count($texts) === count($children)) {
             return new CodeElement($this->getTextChildren($node), $node);
diff --git a/Compiler/NodeCompiler/CommentNodeCompiler.php b/Compiler/NodeCompiler/CommentNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class CommentNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof CommentNode,
diff --git a/Compiler/NodeCompiler/ConditionalNodeCompiler.php b/Compiler/NodeCompiler/ConditionalNodeCompiler.php
@@ -9,7 +9,7 @@
 
 class ConditionalNodeCompiler extends AbstractStatementNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
 
diff --git a/Compiler/NodeCompiler/DoNodeCompiler.php b/Compiler/NodeCompiler/DoNodeCompiler.php
@@ -8,7 +8,7 @@
 
 class DoNodeCompiler extends AbstractStatementNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof DoNode,
diff --git a/Compiler/NodeCompiler/DoctypeNodeCompiler.php b/Compiler/NodeCompiler/DoctypeNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class DoctypeNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/DocumentNodeCompiler.php b/Compiler/NodeCompiler/DocumentNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class DocumentNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof DocumentNode,
diff --git a/Compiler/NodeCompiler/EachNodeCompiler.php b/Compiler/NodeCompiler/EachNodeCompiler.php
@@ -76,7 +76,7 @@ protected function compileLoop(NodeInterface $node, $items, $key, $item)
         return $loop;
     }
 
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof EachNode,
diff --git a/Compiler/NodeCompiler/ElementNodeCompiler.php b/Compiler/NodeCompiler/ElementNodeCompiler.php
@@ -14,7 +14,7 @@
 
 class ElementNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/ExpressionNodeCompiler.php b/Compiler/NodeCompiler/ExpressionNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class ExpressionNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof ExpressionNode,
diff --git a/Compiler/NodeCompiler/FilterNodeCompiler.php b/Compiler/NodeCompiler/FilterNodeCompiler.php
@@ -40,7 +40,7 @@ protected function compileText($name, $children, $parent, $indentLevel)
         }, $children));
     }
 
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/ForNodeCompiler.php b/Compiler/NodeCompiler/ForNodeCompiler.php
@@ -8,7 +8,7 @@
 
 class ForNodeCompiler extends EachNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof ForNode,
diff --git a/Compiler/NodeCompiler/ImportNodeCompiler.php b/Compiler/NodeCompiler/ImportNodeCompiler.php
@@ -51,7 +51,7 @@ protected function isPugImport($path)
      *
      * @return null|ElementInterface
      */
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/KeywordNodeCompiler.php b/Compiler/NodeCompiler/KeywordNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class KeywordNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof KeywordNode,
diff --git a/Compiler/NodeCompiler/MixinCallNodeCompiler.php b/Compiler/NodeCompiler/MixinCallNodeCompiler.php
@@ -14,7 +14,7 @@
 
 class MixinCallNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(ParserNodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(ParserNodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/MixinNodeCompiler.php b/Compiler/NodeCompiler/MixinNodeCompiler.php
@@ -13,7 +13,7 @@
 
 class MixinNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/TextNodeCompiler.php b/Compiler/NodeCompiler/TextNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class TextNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof TextNode,
diff --git a/Compiler/NodeCompiler/VariableNodeCompiler.php b/Compiler/NodeCompiler/VariableNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class VariableNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/WhenNodeCompiler.php b/Compiler/NodeCompiler/WhenNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class WhenNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $this->getCompiler()->assert(
             $node instanceof WhenNode,
diff --git a/Compiler/NodeCompiler/WhileNodeCompiler.php b/Compiler/NodeCompiler/WhileNodeCompiler.php
@@ -9,7 +9,7 @@
 
 class WhileNodeCompiler extends AbstractStatementNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompiler/YieldNodeCompiler.php b/Compiler/NodeCompiler/YieldNodeCompiler.php
@@ -10,7 +10,7 @@
 
 class YieldNodeCompiler extends AbstractNodeCompiler
 {
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null)
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)
     {
         $compiler = $this->getCompiler();
         $compiler->assert(
diff --git a/Compiler/NodeCompilerInterface.php b/Compiler/NodeCompilerInterface.php
@@ -16,31 +16,31 @@ interface NodeCompilerInterface
      *
      * @return array
      */
-    public function getCompiledNodeList($nodeList, ElementInterface $parent = null);
+    public function getCompiledNodeList($nodeList, ?ElementInterface $parent = null);
 
     /**
      * @param NodeInterface    $node
      * @param ElementInterface $parent
      *
      * @return array
      */
-    public function getCompiledChildren(NodeInterface $node, ElementInterface $parent = null);
+    public function getCompiledChildren(NodeInterface $node, ?ElementInterface $parent = null);
 
     /**
      * @param NodeInterface         $node
      * @param ElementInterface|null $element
      *
      * @return mixed
      */
-    public function compileNodeChildren(NodeInterface $node, ElementInterface $element = null);
+    public function compileNodeChildren(NodeInterface $node, ?ElementInterface $element = null);
 
     /**
      * @param ParserNodeInterface $node
      * @param ElementInterface    $parent
      *
      * @return null|BlockElement|ElementInterface
      */
-    public function compileNode(ParserNodeInterface $node, ElementInterface $parent = null);
+    public function compileNode(ParserNodeInterface $node, ?ElementInterface $parent = null);
 
     /**
      * @return CompilerInterface
diff --git a/CompilerInterface.php b/CompilerInterface.php
@@ -92,7 +92,7 @@ public function getBlocks();
      * @param BlockElement $block
      * @param array        $children
      */
-    public function replaceBlock(BlockElement $block, array $children = null);
+    public function replaceBlock(BlockElement $block, ?array $children = null);
 
     /**
      * @throws CompilerException
@@ -133,7 +133,7 @@ public function getCurrentImportPaths();
      *
      * @return null|ElementInterface
      */
-    public function compileNode(NodeInterface $node, ElementInterface $parent = null);
+    public function compileNode(NodeInterface $node, ?ElementInterface $parent = null);
 
     /**
      * @param string $input

Original file line number	Diff line number	Diff line change
`@@ -499,7 +499,7 @@ public function getBlocks()`
`499`	`499`	`*`
`500`	`500`	`* @return ElementInterface`
`501`	`501`	`*/`
`502`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`502`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`503`	`503`	`{`
`504`	`504`	`$nodeEvent = new NodeEvent($node);`
`505`	`505`	`$this->trigger($nodeEvent);`
`@@ -537,7 +537,7 @@ public function compileNode(NodeInterface $node, ElementInterface $parent = null`
`537`	`537`	`* @param BlockElement $block`
`538`	`538`	`* @param array $children`
`539`	`539`	`*/`
`540`		`- public function replaceBlock(BlockElement $block, array $children = null)`
	`540`	`+ public function replaceBlock(BlockElement $block, ?array $children = null)`
`541`	`541`	`{`
`542`	`542`	`if ($parent = $block->getParent()) {`
`543`	`543`	`foreach (array_reverse($children ?: $block->getChildren()) as $child) {`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public function getCompiler()`
`41`	`41`	`*`
`42`	`42`	`* @return ElementInterface[]`
`43`	`43`	`*/`
`44`		`- public function getCompiledNodeList($nodeList, ElementInterface $element = null)`
	`44`	`+ public function getCompiledNodeList($nodeList, ?ElementInterface $element = null)`
`45`	`45`	`{`
`46`	`46`	`return array_values(array_filter(array_map(`
`47`	`47`	`function (NodeInterface $childNode) use ($element) {`
`@@ -59,7 +59,7 @@ function (NodeInterface $childNode) use ($element) {`
`59`	`59`	`*`
`60`	`60`	`* @return ElementInterface[]`
`61`	`61`	`*/`
`62`		`- public function getCompiledChildren(NodeInterface $node, ElementInterface $element = null)`
	`62`	`+ public function getCompiledChildren(NodeInterface $node, ?ElementInterface $element = null)`
`63`	`63`	`{`
`64`	`64`	`return $this->getCompiledNodeList($node->getChildren(), $element);`
`65`	`65`	`}`
`@@ -71,7 +71,7 @@ public function getCompiledChildren(NodeInterface $node, ElementInterface $eleme`
`71`	`71`	`* @param NodeInterface $node`
`72`	`72`	`* @param ElementInterface\|null $element`
`73`	`73`	`*/`
`74`		`- public function compileNodeChildren(NodeInterface $node, ElementInterface $element = null)`
	`74`	`+ public function compileNodeChildren(NodeInterface $node, ?ElementInterface $element = null)`
`75`	`75`	`{`
`76`	`76`	`$children = array_filter($node->getChildren());`
`77`	`77`	`array_walk($children, function (NodeInterface $childNode) use ($element) {`
`@@ -109,7 +109,7 @@ protected function getTextChildren(ParserNodeInterface $node)`
`109`	`109`	`}, $children));`
`110`	`110`	`}`
`111`	`111`
`112`		`- private function compileParserNode(NodeInterface $node, ElementInterface $element = null)`
	`112`	`+ private function compileParserNode(NodeInterface $node, ?ElementInterface $element = null)`
`113`	`113`	`{`
`114`	`114`	`return $node instanceof ParserNodeInterface`
`115`	`115`	`? $this->getCompiler()->compileNode($node, $element)`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`class AssignmentListNodeCompiler extends AbstractNodeCompiler`
`11`	`11`	`{`
`12`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`12`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`13`	`13`	`{`
`14`	`14`	`$this->getCompiler()->assert(`
`15`	`15`	`$node instanceof AssignmentListNode,`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`
`14`	`14`	`class AssignmentNodeCompiler extends AbstractNodeCompiler`
`15`	`15`	`{`
`16`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`16`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`17`	`17`	`{`
`18`	`18`	`$this->getCompiler()->assert(`
`19`	`19`	`$node instanceof AssignmentNode,`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ protected function compileValue(AttributeNode $node)`
`57`	`57`	`return $value;`
`58`	`58`	`}`
`59`	`59`
`60`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`60`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`61`	`61`	`{`
`62`	`62`	`$this->getCompiler()->assert(`
`63`	`63`	`$node instanceof AttributeNode,`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`
`13`	`13`	`class BlockNodeCompiler extends AbstractNodeCompiler`
`14`	`14`	`{`
`15`		`- protected function compileAnonymousBlock(BlockNode $node, ElementInterface $parent = null)`
	`15`	`+ protected function compileAnonymousBlock(BlockNode $node, ?ElementInterface $parent = null)`
`16`	`16`	`{`
`17`	`17`	`$mixin = $node;`
`18`	`18`	`while ($mixin->hasParent() && !($mixin instanceof MixinNode)) {`
`@@ -38,7 +38,7 @@ protected function hasBlockParent(BlockNode $node)`
`38`	`38`	`return false;`
`39`	`39`	`}`
`40`	`40`
`41`		`- protected function compileNamedBlock($name, BlockNode $node, ElementInterface $parent = null)`
	`41`	`+ protected function compileNamedBlock($name, BlockNode $node, ?ElementInterface $parent = null)`
`42`	`42`	`{`
`43`	`43`	`$compiler = $this->getCompiler();`
`44`	`44`	`$layout = $compiler->getLayout();`
`@@ -63,7 +63,7 @@ protected function compileNamedBlock($name, BlockNode $node, ElementInterface $p`
`63`	`63`	`);`
`64`	`64`	`}`
`65`	`65`
`66`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`66`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`67`	`67`	`{`
`68`	`68`	`$this->getCompiler()->assert(`
`69`	`69`	`$node instanceof BlockNode,`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`
`9`	`9`	`class CaseNodeCompiler extends AbstractStatementNodeCompiler`
`10`	`10`	`{`
`11`		`- public function compileNode(NodeInterface $node, ElementInterface $parent = null)`
	`11`	`+ public function compileNode(NodeInterface $node, ?ElementInterface $parent = null)`
`12`	`12`	`{`
`13`	`13`	`$this->getCompiler()->assert(`
`14`	`14`	`$node instanceof CaseNode,`