Simplify compiler code and tests

Author: theodorejb

src/Compiler.php

@@ -124,8 +124,8 @@ private function accept(Node $node): string
             $node instanceof PartialBlockStatement => $this->PartialBlockStatement($node),
             $node instanceof Decorator => $this->Decorator($node),
             $node instanceof MustacheStatement => $this->MustacheStatement($node),
-            $node instanceof ContentStatement => $this->ContentStatement($node),
-            $node instanceof CommentStatement => $this->CommentStatement($node),
+            $node instanceof ContentStatement => self::quote($node->value),
+            $node instanceof CommentStatement => '',
             $node instanceof SubExpression => $this->SubExpression($node),
             default => throw new \Exception('Unknown type: ' . (new \ReflectionClass($node))->getShortName()),
         };
@@ -136,11 +136,10 @@ private function compileExpression(Expression $expr): string
         return match (true) {
             $expr instanceof SubExpression => $this->SubExpression($expr),
             $expr instanceof PathExpression => $this->PathExpression($expr),
-            $expr instanceof StringLiteral => $this->StringLiteral($expr),
-            $expr instanceof NumberLiteral => $this->NumberLiteral($expr),
-            $expr instanceof BooleanLiteral => $this->BooleanLiteral($expr),
-            $expr instanceof NullLiteral => $this->NullLiteral($expr),
-            $expr instanceof UndefinedLiteral => $this->UndefinedLiteral($expr),
+            $expr instanceof StringLiteral => self::quote($expr->value),
+            $expr instanceof NumberLiteral => (string) $expr->value,
+            $expr instanceof BooleanLiteral => $expr->value ? 'true' : 'false',
+            $expr instanceof NullLiteral, $expr instanceof UndefinedLiteral => 'null',
             default => throw new \Exception('Unknown expression type: ' . (new \ReflectionClass($expr))->getShortName()),
         };
     }
@@ -209,7 +208,7 @@ private function compileSection(BlockStatement $block, string $var, string $esca
         assert($block->program !== null);
 
         $blockFn = $this->compileProgramWithBlockParams($block->program);
-        $else = $this->compileElseClause($block);
+        $else = $this->compileProgramOrNull($block->inverse);
 
         if ($this->context->options->knownHelpersOnly) {
             return self::getRuntimeFunc('sec', "\$cx, $var, \$in, $blockFn, $else");
@@ -291,26 +290,29 @@ private function compileProgramWithBlockParams(Program $program): string
     private function compileBlockHelper(BlockStatement $block, string $name): string
     {
         $inverted = $block->program === null;
-        if ($inverted) {
-            assert($block->inverse !== null);
-        }
         // For inverted blocks the fn body comes from the inverse program; for normal blocks, the program.
-        $fnProgram = $inverted ? $block->inverse : $block->program;
+        $fnProgram = $block->program ?? $block->inverse;
+        assert($fnProgram !== null);
 
         // Inline if/unless as ternary — eliminates hbbch dispatch and HelperOptions allocation.
         // Safe because if/unless don't change scope, so $cx and $in are already correct.
         // Negate for 'unless' in a normal block, or 'if' in an inverted block (swapped semantics).
         if ($this->canInlineConditional($block, $name, $fnProgram->blockParams)) {
             $cond = $this->compileConditionalExpr($block->params[0], $name === ($inverted ? 'if' : 'unless'));
             $body = $this->compileProgram($fnProgram);
-            $elseBody = $inverted ? "''" : $this->compileProgramOrEmpty($block->inverse);
+            $elseBody = $this->compileProgramOrEmpty($inverted ? null : $block->inverse);
             return "($cond ? $body : $elseBody)";
         }
 
         $blockFn = $this->compileProgramWithBlockParams($fnProgram);
-        [$fn, $else] = $inverted
-            ? ['null', $blockFn]
-            : [$blockFn, $this->compileElseClause($block)];
+        if ($inverted) {
+            // no {{else}} clause, so there is nothing to compile for fn
+            $fn = 'null';
+            $else = $blockFn;
+        } else {
+            $fn = $blockFn;
+            $else = $this->compileProgramOrNull($block->inverse);
+        }
 
         $outerBp = $this->outerBlockParamsExpr();
         $params = $this->compileParams($block->params, $block->hash);
@@ -372,7 +374,7 @@ private function compileDynamicBlockHelper(BlockStatement $block, string $name,
         $blockFn = $block->program !== null
             ? $this->compileProgramWithBlockParams($block->program)
             : 'null';
-        $else = $this->compileElseClause($block);
+        $else = $this->compileProgramOrNull($block->inverse);
         $outerBp = $this->outerBlockParamsExpr();
         $helperName = self::quote($name);
         return self::getRuntimeFunc('dynhbbch', "\$cx, $helperName, $varPath, $params, \$in, $blockFn, $else, " . count($bp) . ", $outerBp");
@@ -385,7 +387,7 @@ private function DecoratorBlock(BlockStatement $block): string
         if ($helperName !== 'inline') {
             throw new \Exception('Unknown decorator: "' . $helperName . '"');
         } elseif (!$block->params) {
-            $partialName = 'undefined';
+            $partialName = 'undefined'; // match JS for {{#*inline}} without a name (params[0] on empty array is undefined)
         } else {
             $firstArg = $block->params[0];
             if (!$firstArg instanceof Literal) {
@@ -556,16 +558,6 @@ private function MustacheStatement(MustacheStatement $mustache): string
         return self::getRuntimeFunc($fn, "\$in[$escapedKey] ?? $miss");
     }
 
-    private function ContentStatement(ContentStatement $statement): string
-    {
-        return self::quote($statement->value);
-    }
-
-    private function CommentStatement(CommentStatement $statement): string
-    {
-        return '';
-    }
-
     // ── Expressions ─────────────────────────────────────────────────
 
     private function SubExpression(SubExpression $expression): string
@@ -604,7 +596,8 @@ private function PathExpression(PathExpression $expression): string
             $stringParts = $expression->tail;
         } else {
             $base = $this->buildBasePath($data, $depth);
-            $stringParts = self::stringPartsOf($parts);
+            /** @var string[] $parts */
+            $stringParts = $parts;
         }
 
         // `this` with no parts or empty parts
@@ -652,31 +645,6 @@ private function PathExpression(PathExpression $expression): string
         return $this->compileModeAwareLookup($base, $stringParts, $expression->original, $miss);
     }
 
-    private function StringLiteral(StringLiteral $literal): string
-    {
-        return self::quote($literal->value);
-    }
-
-    private function NumberLiteral(NumberLiteral $literal): string
-    {
-        return (string) $literal->value;
-    }
-
-    private function BooleanLiteral(BooleanLiteral $literal): string
-    {
-        return $literal->value ? 'true' : 'false';
-    }
-
-    private function UndefinedLiteral(UndefinedLiteral $literal): string
-    {
-        return 'null';
-    }
-
-    private function NullLiteral(NullLiteral $literal): string
-    {
-        return 'null';
-    }
-
     /**
      * Get the string key name for a literal used in path (mustache/block) position.
      * e.g. {{12}} looks up $in['12'], {{"foo bar"}} looks up $in['foo bar'], {{true}} looks up $in['true'].
@@ -848,18 +816,6 @@ private function getSimpleHelperName(PathExpression|Literal $path): ?string
         return $path->parts[0];
     }
 
-    /**
-     * Compile the else/inverse clause of a block as a trailing closure argument, or 'null' if absent.
-     */
-    private function compileElseClause(BlockStatement $block): string
-    {
-        if (!$block->inverse) {
-            $this->lastCompileProgramHadDirectBpRef = false;
-            return 'null';
-        }
-        return $this->compileProgramWithBlockParams($block->inverse);
-    }
-
     /**
      * Build the base path expression for a given data flag and depth.
      */
@@ -929,6 +885,15 @@ private function missValue(string $key): string
             : 'null';
     }
 
+    private function compileProgramOrNull(?Program $program): string
+    {
+        if (!$program) {
+            $this->lastCompileProgramHadDirectBpRef = false;
+            return 'null';
+        }
+        return $this->compileProgramWithBlockParams($program);
+    }
+
     private function compileProgramOrEmpty(?Program $program): string
     {
         if (!$program) {
@@ -986,14 +951,4 @@ private function buildInlineHelperCall(string $name, array $params, ?Hash $hash)
         }
         return self::getRuntimeFunc('dynhbch', "\$cx, $helperName, $compiledParams, \$in");
     }
-
-    /**
-     * Return only the string parts of a mixed parts array, re-indexed.
-     * @param array<string|SubExpression> $parts
-     * @return list<string>
-     */
-    private static function stringPartsOf(array $parts): array
-    {
-        return array_values(array_filter($parts, fn($p) => is_string($p)));
-    }
 }