Fix block param and literal path lookups in strict mode

Author: theodorejb

src/Compiler.php

@@ -172,7 +172,7 @@ private function BlockStatement(BlockStatement $block): string
             }
 
             $escapedKey = self::quote($literalKey);
-            $var = "\$in[$escapedKey] ?? " . $this->missValue($literalKey);
+            $var = $this->compileModeAwareLookup('$in', [$literalKey], $literalKey);
 
             if ($block->program === null) {
                 return $this->compileInvertedSection($block, $var, $escapedKey);
@@ -554,8 +554,7 @@ private function MustacheStatement(MustacheStatement $mustache): string
             return self::getRuntimeFunc($fn, self::getRuntimeFunc('hv', "\$cx, $escapedKey, \$in"));
         }
 
-        $miss = $this->missValue($literalKey);
-        return self::getRuntimeFunc($fn, "\$in[$escapedKey] ?? $miss");
+        return self::getRuntimeFunc($fn, $this->compileModeAwareLookup('$in', [$literalKey], $literalKey));
     }
 
     // ── Expressions ─────────────────────────────────────────────────
@@ -611,38 +610,36 @@ private function PathExpression(PathExpression $expression): string
         }
 
         $isLength = end($stringParts) === 'length';
-        $varParts = $isLength ? array_slice($stringParts, 0, -1) : $stringParts;
-        $miss = $this->missValue($expression->original);
 
         // Check block params (depth-0, non-data, non-scoped paths only, not SubExpression-headed)
         if (!$hasSubExprHead && !$data && $depth === 0 && !self::scopedId($expression)) {
-            $bp = $this->lookupBlockParam($stringParts[0]);
+            $bp = $this->lookupBlockParam($expression->head);
             if ($bp !== null) {
                 [$bpDepth, $bpIndex] = $bp;
                 $bpBase = "\$blockParams[$bpDepth][$bpIndex]";
                 // Mark the current compileProgram() level as having a direct $blockParams reference.
                 if ($this->bpRefStack) {
                     $this->bpRefStack[array_key_last($this->bpRefStack)] = true;
                 }
-                // Skip the block param name ($varParts[0]) since it has been resolved to a $blockParams index.
-                $parent = $bpBase . self::buildKeyAccess(array_slice($varParts, 1));
-                if ($isLength) {
-                    return $this->buildLookupLength($parent);
-                }
-                return "$parent ?? $miss";
+
+                // Skip the block param name since it has been resolved to a $blockParams index.
+                $keys = $isLength ? array_slice($expression->tail, 0, -1) : $expression->tail;
+                $lookup = $this->compileModeAwareLookup($bpBase, $keys, $expression->original);
+                return $isLength ? $this->buildLookupLength($lookup) : $lookup;
             }
         }
 
         // Handle .length: compile parent path through the normal mode-aware logic, then wrap in
         // lookupLength() at runtime. This mirrors HBS.js, where .length is a normal property
         // access with no compile-time special casing.
         if ($isLength) {
+            $partsExceptLength = array_slice($stringParts, 0, -1);
             return $this->buildLookupLength(
-                $this->compileModeAwareLookup($base, $varParts, $expression->original, 'null'),
+                $this->compileModeAwareLookup($base, $partsExceptLength, $expression->original),
             );
         }
 
-        return $this->compileModeAwareLookup($base, $stringParts, $expression->original, $miss);
+        return $this->compileModeAwareLookup($base, $stringParts, $expression->original);
     }
 
     /**
@@ -841,9 +838,9 @@ private function resolvePartialName(PathExpression|StringLiteral|NumberLiteral $
      * An optional $extraArg is appended to every call's argument list.
      * @param string[] $parts
      */
-    private static function buildCallChain(string $fn, string $base, array $parts, string $extraArg = ''): string
+    private static function buildCallChain(string $fn, string $base, array $parts, ?string $extraArg = null): string
     {
-        $extra = $extraArg !== '' ? ", $extraArg" : '';
+        $extra = $extraArg !== null ? ", $extraArg" : '';
         $expr = $base;
         foreach ($parts as $part) {
             $expr = self::getRuntimeFunc($fn, "$expr, " . self::quote($part) . $extra);
@@ -878,13 +875,6 @@ private static function quote(string $string): string
         return "'" . addcslashes($string, "'\\") . "'";
     }
 
-    private function missValue(string $key): string
-    {
-        return ($this->context->options->strict && !$this->compilingHelperArgs)
-            ? self::getRuntimeFunc('miss', self::quote($key))
-            : 'null';
-    }
-
     private function compileProgramOrNull(?Program $program): string
     {
         if (!$program) {
@@ -913,7 +903,7 @@ private function buildLookupLength(string $parent): string
      * Compile a mode-aware path access expression for the given base and parts.
      * @param string[] $parts
      */
-    private function compileModeAwareLookup(string $base, array $parts, string $original, string $miss): string
+    private function compileModeAwareLookup(string $base, array $parts, string $original): string
     {
         if (!$parts) {
             return $base;
@@ -927,7 +917,7 @@ private function compileModeAwareLookup(string $base, array $parts, string $orig
         if ($this->context->options->strict) {
             return self::buildCallChain('strictLookup', $base, $parts, self::quote($original));
         }
-        return $base . self::buildKeyAccess($parts) . " ?? $miss";
+        return $base . self::buildKeyAccess($parts) . ' ?? null';
     }
 
     private function throwKnownHelpersOnly(string $helperName): never

src/Runtime.php

@@ -111,22 +111,14 @@ public static function defaultHelpers(): array
         ];
     }
 
-    /**
-     * Throw exception for missing expression. Only used in strict mode.
-     */
-    public static function miss(string $v): void
-    {
-        throw new \Exception('"' . $v . '" not defined');
-    }
-
     /**
      * Strict-mode key lookup: throw if $base is not an array or $key is absent.
      * Unlike the null-coalescing pattern, this allows null values when the key exists.
      */
     public static function strictLookup(mixed $base, string $key, string $original): mixed
     {
         if (!is_array($base) || !array_key_exists($key, $base)) {
-            self::miss($original);
+            throw new \Exception('"' . $original . '" not defined');
         }
         return $base[$key];
     }

tests/ErrorTest.php

@@ -192,6 +192,13 @@ public static function renderErrorProvider(): array
                 'template' => '{{#each}}OK!{{/each}}',
                 'expected' => 'Must pass iterator to #each',
             ],
+            [
+                'desc' => 'assumeObjects mode should throw on null block param intermediate',
+                'template' => '{{#each items as |item|}}{{item.nested.val}}{{/each}}',
+                'options' => new Options(assumeObjects: true),
+                'data' => ['items' => [['nested' => null]]],
+                'expected' => 'Cannot access property "val" on null',
+            ],
             [
                 'desc' => 'strict mode should throw for missing block param property',
                 'template' => '{{#each items as |item|}}{{item.missing}}{{/each}}',

tests/RegressionTest.php

@@ -2228,6 +2228,27 @@ public static function missingDataProvider(): array
                 'data' => ['foo' => []],
                 'expected' => '',
             ],
+            [
+                'desc' => 'strict mode should not throw for null block param property value',
+                'template' => '{{#each items as |item|}}{{item.val}}{{/each}}',
+                'options' => new Options(strict: true),
+                'data' => ['items' => [['val' => null]]],
+                'expected' => '',
+            ],
+            [
+                'desc' => 'strict mode should not throw for explicit null value at literal mustache path',
+                'template' => '{{"foo"}}',
+                'options' => new Options(strict: true),
+                'data' => ['foo' => null],
+                'expected' => '',
+            ],
+            [
+                'desc' => 'strict mode should not throw for explicit null value at literal block section path',
+                'template' => '{{#"foo"}}YES{{/"foo"}}',
+                'options' => new Options(strict: true),
+                'data' => ['foo' => null],
+                'expected' => '',
+            ],
         ];
     }