gulp-phug 1.3.4 → 1.3.5

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/AutoCloseTokenHandler.php

@@ -3,28 +3,16 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\AutoCloseToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class AutoCloseTokenHandler implements TokenHandlerInterface
+class AutoCloseTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof AutoCloseToken)) {
-            throw new \RuntimeException(
-                'You can only pass auto-close tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = AutoCloseToken::class;
 
-        if (!$state->currentNodeIs([ElementNode::class])) {
-            $state->throwException(
-                'Auto-close operators can only be used on elements',
-                0,
-                $token
-            );
-        }
+    public function handleAutoCloseToken(AutoCloseToken $token, State $state)
+    {
+        $this->assertCurrentNodeIs($token, $state, [ElementNode::class]);
 
         $state->getCurrentNode()->autoClose();
     }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/BlockTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\BlockToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\BlockNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class BlockTokenHandler implements TokenHandlerInterface
+class BlockTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof BlockToken)) {
-            throw new \RuntimeException(
-                'You can only pass block tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = BlockToken::class;
 
+    public function handleBlockToken(BlockToken $token, State $state)
+    {
         /** @var BlockNode $node */
         $node = $state->createNode(BlockNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/CaseTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\CaseToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CaseNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class CaseTokenHandler implements TokenHandlerInterface
+class CaseTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof CaseToken)) {
-            throw new \RuntimeException(
-                'You can only pass case tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = CaseToken::class;
 
+    public function handleCaseToken(CaseToken $token, State $state)
+    {
         /** @var CaseNode $node */
         $node = $state->createNode(CaseNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ClassTokenHandler.php

@@ -3,44 +3,17 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ClassToken;
-use Phug\Lexer\TokenInterface;
-use Phug\Parser\Node\AttributeNode;
-use Phug\Parser\Node\ElementNode;
-use Phug\Parser\Node\MixinCallNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
+use Phug\Parser\TokenHandler\Partial\StaticAttributeTrait;
 
-class ClassTokenHandler implements TokenHandlerInterface
+class ClassTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ClassToken)) {
-            throw new \RuntimeException(
-                'You can only pass class tokens to this token handler'
-            );
-        }
-
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
+    use StaticAttributeTrait;
 
-        if (!$state->currentNodeIs([ElementNode::class, MixinCallNode::class])) {
-            $state->throwException(
-                'Classes can only be used on elements and mixin calls',
-                0,
-                $token
-            );
-        }
+    const TOKEN_TYPE = ClassToken::class;
 
-        //We actually create a fake class attribute
-        /** @var AttributeNode $attr */
-        $attr = $state->createNode(AttributeNode::class, $token);
-        $attr->setName('class');
-        $attr->setValue(var_export($token->getName(), true));
-        $attr->unescape()->uncheck();
-
-        /** @var ElementNode|MixinCallNode $current */
-        $current = $state->getCurrentNode();
-        $current->getAttributes()->attach($attr);
+    public function handleClassToken(ClassToken $token, State $state)
+    {
+        $this->attachStaticAttribute('class', $token, $state);
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/CodeTokenHandler.php

@@ -4,21 +4,15 @@ namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\CodeToken;
 use Phug\Lexer\Token\TextToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CodeNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class CodeTokenHandler implements TokenHandlerInterface
+class CodeTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof CodeToken)) {
-            throw new \RuntimeException(
-                'You can only pass code tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = CodeToken::class;
 
+    public function handleCodeToken(CodeToken $token, State $state)
+    {
         /** @var CodeNode $node */
         $node = $state->createNode(CodeNode::class, $token);
 

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/CommentTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\CommentToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CommentNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class CommentTokenHandler implements TokenHandlerInterface
+class CommentTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof CommentToken)) {
-            throw new \RuntimeException(
-                'You can only pass comment tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = CommentToken::class;
 
+    public function handleCommentToken(CommentToken $token, State $state)
+    {
         /** @var CommentNode $node */
         $node = $state->createNode(CommentNode::class, $token);
         $node->setIsVisible($token->isVisible());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ConditionalTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ConditionalToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ConditionalNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ConditionalTokenHandler implements TokenHandlerInterface
+class ConditionalTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ConditionalToken)) {
-            throw new \RuntimeException(
-                'You can only pass conditional tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = ConditionalToken::class;
 
+    public function handleConditionalToken(ConditionalToken $token, State $state)
+    {
         /** @var ConditionalNode $node */
         $node = $state->createNode(ConditionalNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/DoTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\DoToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\DoNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class DoTokenHandler implements TokenHandlerInterface
+class DoTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof DoToken)) {
-            throw new \RuntimeException(
-                'You can only pass do tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = DoToken::class;
 
+    public function handleDoToken(DoToken $token, State $state)
+    {
         $node = $state->createNode(DoNode::class, $token);
         $state->setCurrentNode($node);
     }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/DoctypeTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\DoctypeToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\DoctypeNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class DoctypeTokenHandler implements TokenHandlerInterface
+class DoctypeTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof DoctypeToken)) {
-            throw new \RuntimeException(
-                'You can only pass doctype tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = DoctypeToken::class;
 
+    public function handleDoctypeToken(DoctypeToken $token, State $state)
+    {
         /** @var DoctypeNode $node */
         $node = $state->createNode(DoctypeNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/EachTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\EachToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\EachNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class EachTokenHandler implements TokenHandlerInterface
+class EachTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof EachToken)) {
-            throw new \RuntimeException(
-                'You can only pass each tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = EachToken::class;
 
+    public function handleEachToken(EachToken $token, State $state)
+    {
         /** @var EachNode $node */
         $node = $state->createNode(EachNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ExpansionTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ExpansionToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ExpansionTokenHandler implements TokenHandlerInterface
+class ExpansionTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ExpansionToken)) {
-            throw new \RuntimeException(
-                'You can only pass expansion tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = ExpansionToken::class;
 
+    public function handleExpansionToken(ExpansionToken $token, State $state)
+    {
         if (!$state->getCurrentNode()) {
             $state->throwException(
                 'Expansion needs an element to work on',
@@ -26,7 +20,7 @@ class ExpansionTokenHandler implements TokenHandlerInterface
             );
         }
 
-        if ($node = $state->getInterpolationNode()) {
+        if ($state->getInterpolationNode()) {
             //Make sure to keep the expansion
             $newNode = $state->createNode(ElementNode::class, $token);
             $newNode->setOuterNode($state->getCurrentNode());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ExpressionTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ExpressionToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ExpressionNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ExpressionTokenHandler implements TokenHandlerInterface
+class ExpressionTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ExpressionToken)) {
-            throw new \RuntimeException(
-                'You can only pass expression tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = ExpressionToken::class;
 
+    public function handleExpressionToken(ExpressionToken $token, State $state)
+    {
         /** @var ExpressionNode $node */
         $node = $state->createNode(ExpressionNode::class, $token);
         $node->setIsEscaped($token->isEscaped());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/FilterTokenHandler.php

@@ -3,22 +3,16 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\FilterToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\FilterNode;
 use Phug\Parser\Node\ImportNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class FilterTokenHandler implements TokenHandlerInterface
+class FilterTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof FilterToken)) {
-            throw new \RuntimeException(
-                'You can only pass filter tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = FilterToken::class;
 
+    public function handleFilterToken(FilterToken $token, State $state)
+    {
         /** @var FilterNode $node */
         $node = $state->createNode(FilterNode::class, $token);
         $node->setName($token->getName());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ForTokenHandler.php

@@ -3,21 +3,15 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ForToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\ForNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ForTokenHandler implements TokenHandlerInterface
+class ForTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof ForToken)) {
-            throw new \RuntimeException(
-                'You can only pass for tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = ForToken::class;
 
+    public function handleForToken(ForToken $token, State $state)
+    {
         /** @var ForNode $node */
         $node = $state->createNode(ForNode::class, $token);
         $node->setSubject($token->getSubject());

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/IdTokenHandler.php

@@ -3,43 +3,17 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\IdToken;
-use Phug\Lexer\TokenInterface;
-use Phug\Parser\Node\AttributeNode;
-use Phug\Parser\Node\ElementNode;
-use Phug\Parser\Node\MixinCallNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
+use Phug\Parser\TokenHandler\Partial\StaticAttributeTrait;
 
-class IdTokenHandler implements TokenHandlerInterface
+class IdTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof IdToken)) {
-            throw new \RuntimeException(
-                'You can only pass id tokens to this token handler'
-            );
-        }
-
-        if (!$state->getCurrentNode()) {
-            $state->setCurrentNode($state->createNode(ElementNode::class, $token));
-        }
+    use StaticAttributeTrait;
 
-        if (!$state->currentNodeIs([ElementNode::class, MixinCallNode::class])) {
-            $state->throwException(
-                'IDs can only be used on elements and mixin calls',
-                0,
-                $token
-            );
-        }
+    const TOKEN_TYPE = IdToken::class;
 
-        /** @var AttributeNode $attr */
-        $attr = $state->createNode(AttributeNode::class, $token);
-        $attr->setName('id');
-        $attr->setValue(var_export($token->getName(), true));
-        $attr->unescape()->uncheck();
-
-        /** @var ElementNode|MixinCallNode $current */
-        $current = $state->getCurrentNode();
-        $current->getAttributes()->attach($attr);
+    public function handleIdToken(IdToken $token, State $state)
+    {
+        $this->attachStaticAttribute('id', $token, $state);
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/ImportTokenHandler.php

@@ -3,35 +3,18 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\ImportToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CommentNode;
 use Phug\Parser\Node\ImportNode;
 use Phug\Parser\Node\MixinNode;
 use Phug\Parser\NodeInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class ImportTokenHandler implements TokenHandlerInterface
+class ImportTokenHandler extends AbstractTokenHandler
 {
-    protected function isEmptyDocument(NodeInterface $document)
-    {
-        foreach ($document->getChildren() as $child) {
-            if (!($child instanceof MixinNode || ($child instanceof CommentNode && !$child->isVisible()))) {
-                return false;
-            }
-        }
-
-        return true;
-    }
+    const TOKEN_TYPE = ImportToken::class;
 
-    public function handleToken(TokenInterface $token, State $state)
+    public function handleImportToken(ImportToken $token, State $state)
     {
-        if (!($token instanceof ImportToken)) {
-            throw new \RuntimeException(
-                'You can only pass import tokens to this token handler'
-            );
-        }
-
         if ($token->getName() === 'extend' && !$this->isEmptyDocument($state->getDocumentNode())) {
             $state->throwException(
                 'extends should be the very first statement in a document',
@@ -46,4 +29,15 @@ class ImportTokenHandler implements TokenHandlerInterface
         $node->setPath($token->getPath());
         $state->setCurrentNode($node);
     }
+
+    protected function isEmptyDocument(NodeInterface $document)
+    {
+        foreach ($document->getChildren() as $child) {
+            if (!($child instanceof MixinNode || ($child instanceof CommentNode && !$child->isVisible()))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/IndentTokenHandler.php

@@ -3,20 +3,14 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\IndentToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class IndentTokenHandler implements TokenHandlerInterface
+class IndentTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof IndentToken)) {
-            throw new \RuntimeException(
-                'You can only pass indent tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = IndentToken::class;
 
+    public function handleIndentToken(IndentToken $token, State $state)
+    {
         $state->enter();
     }
 }

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/InterpolationEndTokenHandler.php

@@ -3,20 +3,14 @@
 namespace Phug\Parser\TokenHandler;
 
 use Phug\Lexer\Token\InterpolationEndToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class InterpolationEndTokenHandler implements TokenHandlerInterface
+class InterpolationEndTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof InterpolationEndToken)) {
-            throw new \RuntimeException(
-                'You can only pass interpolation end tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = InterpolationEndToken::class;
 
+    public function handleInterpolationEndToken(InterpolationEndToken $token, State $state)
+    {
         $node = $state->getCurrentNode();
         $nodes = $state->getInterpolationStack()->offsetGet($token);
         $state->setCurrentNode($nodes->currentNode);

package/support/vendor/phug/phug/src/Phug/Parser/Parser/TokenHandler/InterpolationStartTokenHandler.php

@@ -5,47 +5,22 @@ namespace Phug\Parser\TokenHandler;
 use Phug\Lexer\Token\ExpressionToken;
 use Phug\Lexer\Token\InterpolationEndToken;
 use Phug\Lexer\Token\InterpolationStartToken;
-use Phug\Lexer\TokenInterface;
 use Phug\Parser\Node\CodeNode;
 use Phug\Parser\Node\ElementNode;
 use Phug\Parser\Node\ExpressionNode;
 use Phug\Parser\Node\TextNode;
 use Phug\Parser\State;
-use Phug\Parser\TokenHandlerInterface;
 
-class InterpolationStartTokenHandler implements TokenHandlerInterface
+class InterpolationStartTokenHandler extends AbstractTokenHandler
 {
-    public function handleToken(TokenInterface $token, State $state)
-    {
-        if (!($token instanceof InterpolationStartToken)) {
-            throw new \RuntimeException(
-                'You can only pass interpolation start tokens to this token handler'
-            );
-        }
+    const TOKEN_TYPE = InterpolationStartToken::class;
 
+    public function handleInterpolationStartToken(InterpolationStartToken $token, State $state)
+    {
         $node = $state->getCurrentNode();
 
         if (!$node && !($state->getPreviousToken() instanceof InterpolationEndToken)) {
-            /** @var ElementNode $element */
-            $element = $state->createNode(ElementNode::class, $token);
-            $state->setCurrentNode($element);
-
-            foreach ($state->lookUpNext([ExpressionToken::class]) as $expression) {
-                /** @var ExpressionNode $expressionNode */
-                $expressionNode = $state->createNode(ExpressionNode::class, $expression);
-                $expressionNode->check();
-                $expressionNode->unescape();
-                $expressionNode->setValue($expression->getValue());
-                $element->setName($expressionNode);
-            }
-
-            if (!$state->expect([InterpolationEndToken::class])) {
-                $state->throwException(
-                    'Interpolation not properly closed',
-                    0,
-                    $token
-                );
-            }
+            $this->handleExpressionTokens($token, $state);
 
             return;
         }
@@ -65,4 +40,28 @@ class InterpolationStartTokenHandler implements TokenHandlerInterface
 
         $state->store();
     }
+
+    private function handleExpressionTokens(InterpolationStartToken $token, State $state)
+    {
+        /** @var ElementNode $element */
+        $element = $state->createNode(ElementNode::class, $token);
+        $state->setCurrentNode($element);
+
+        foreach ($state->lookUpNext([ExpressionToken::class]) as $expression) {
+            /** @var ExpressionNode $expressionNode */
+            $expressionNode = $state->createNode(ExpressionNode::class, $expression);
+            $expressionNode->check();
+            $expressionNode->unescape();
+            $expressionNode->setValue($expression->getValue());
+            $element->setName($expressionNode);
+        }
+
+        if (!$state->expect([InterpolationEndToken::class])) {
+            $state->throwException(
+                'Interpolation not properly closed',
+                0,
+                $token
+            );
+        }
+    }
 }