Fix helper argument handling in strict mode

Also updated assumeObjects errors to align with Handlebars.js.

Author: theodorejb

src/Compiler.php

@@ -408,7 +408,7 @@ private function PartialStatement(PartialStatement $statement): string
             $p = $this->SubExpression($name);
             $this->context->usedDynPartial++;
         } elseif ($name instanceof PathExpression || $name instanceof StringLiteral || $name instanceof NumberLiteral) {
-            $partialName = $name instanceof PathExpression ? $name->original : $this->getLiteralKeyName($name);
+            $partialName = $this->resolvePartialName($name);
             $p = self::quote($partialName);
             $this->resolveAndCompilePartial($partialName);
         } else {
@@ -447,22 +447,23 @@ private function PartialBlockStatement(PartialBlockStatement $statement): string
         $body = $this->compileProgram($statement->program);
 
         if ($name instanceof PathExpression || $name instanceof StringLiteral || $name instanceof NumberLiteral) {
-            $partialName = $name instanceof PathExpression ? $name->original : $this->getLiteralKeyName($name);
+            $partialName = $this->resolvePartialName($name);
             $p = self::quote($partialName);
         } else {
             $p = $this->compileExpression($name);
             $partialName = null;
         }
 
+        $found = false;
+
         if ($partialName !== null) {
             $found = isset($this->context->usedPartial[$partialName]);
 
             if (!$found && !str_starts_with($partialName, '@partial-block')) {
-                $resolveName = $partialName;
-                $cnt = $this->resolvePartial($resolveName);
+                $cnt = $this->resolvePartial($partialName);
                 if ($cnt !== null) {
-                    $this->context->usedPartial[$resolveName] = $cnt;
-                    $this->compilePartialTemplate($resolveName, $cnt);
+                    $this->context->usedPartial[$partialName] = $cnt;
+                    $this->compilePartialTemplate($partialName, $cnt);
                     $found = true;
                 }
             }
@@ -479,11 +480,12 @@ private function PartialBlockStatement(PartialBlockStatement $statement): string
 
         // Capture $blockParams if we're inside a block-param scope so the partial block body can access them.
         $useVars = $this->blockParamsUseVars();
+        $bodyClosure = self::templateClosure($body, useVars: $useVars);
         $fallbackParts = ($partialName !== null && !$found)
-            ? [self::getRuntimeFunc('inFallback', "\$cx, " . self::quote($partialName) . ', ' . self::templateClosure($body, useVars: $useVars))]
+            ? [self::getRuntimeFunc('inFallback', "\$cx, " . self::quote($partialName) . ', ' . $bodyClosure)]
             : [];
         $parts = [...$hoistedParts, ...$fallbackParts,
-            self::getRuntimeFunc('in', "\$cx, '@partial-block$pid', " . self::templateClosure($body, useVars: $useVars)),
+            self::getRuntimeFunc('in', "\$cx, '@partial-block$pid', " . $bodyClosure),
             self::getRuntimeFunc('p', "\$cx, $p, $vars, $pid, ''"),
         ];
         return implode('.', $parts);
@@ -639,32 +641,22 @@ private function PathExpression(PathExpression $expression): string
             if (count($checks) > 1) {
                 $cond = "($cond)";
             }
-            $lenStart = "($cond ? count($base$p) : ";
-            $lenEnd = ')';
+            $lenStart = "$cond ? count($base$p) : ";
 
-            return "$base$n ?? $lenStart$miss$lenEnd";
+            return "$base$n ?? ($lenStart$miss)";
         }
 
-        if ($this->context->options->assumeObjects) {
-            $missCode = self::getRuntimeFunc('miss', self::quote($expression->original));
-            $conditions = ["isset($base)"];
-            $intermediateAccess = '';
-            foreach (array_slice($stringParts, 0, -1) as $part) {
-                $intermediateAccess .= '[' . self::quote($part) . ']';
-                $conditions[] = "isset($base$intermediateAccess)";
-            }
-            $allConds = implode(' && ', $conditions);
-            return "($allConds ? ($base$n ?? null) : $missCode)";
+        // assumeObjects and strict mode for helper arguments both use nullCheck chains.
+        // This mirrors HBS.js: both paths use bare nameLookup (no container.strict wrapping), so
+        // only a null intermediate throws (JS TypeError), while a missing key on a valid array
+        // returns null silently (JS undefined). nullCheck encodes those semantics and includes
+        // the key name in the exception message.
+        if ($this->context->options->assumeObjects || ($this->context->options->strict && $this->compilingHelperArgs)) {
+            return self::buildCallChain('nullCheck', $base, $stringParts);
         }
 
-        if ($this->context->options->strict && !$this->compilingHelperArgs) {
-            $escapedOriginal = self::quote($expression->original);
-            $expr = $base;
-            foreach ($stringParts as $part) {
-                $escapedKey = self::quote($part);
-                $expr = self::getRuntimeFunc('strictLookup', "$expr, $escapedKey, $escapedOriginal");
-            }
-            return $expr;
+        if ($this->context->options->strict) {
+            return self::buildCallChain('strictLookup', $base, $stringParts, self::quote($expression->original));
         }
 
         return "$base$n ?? $miss";
@@ -762,11 +754,8 @@ private function resolveAndCompilePartial(string $name): void
     /**
      * Returns the resolved partial content, or null if it doesn't exist.
      */
-    private function resolvePartial(string &$name): ?string
+    private function resolvePartial(string $name): ?string
     {
-        if ($name === '@partial-block') {
-            $name = "@partial-block{$this->context->usedPBlock}";
-        }
         if (isset($this->context->partials[$name])) {
             return $this->context->partials[$name];
         }
@@ -900,6 +889,30 @@ private function buildBasePath(bool $data, int $depth): string
         return $base;
     }
 
+    /**
+     * Resolve the name of a non-SubExpression partial reference.
+     */
+    private function resolvePartialName(PathExpression|StringLiteral|NumberLiteral $name): string
+    {
+        return $name instanceof PathExpression ? $name->original : $this->getLiteralKeyName($name);
+    }
+
+    /**
+     * Build a left-associative chain of runtime function calls over the given parts.
+     * e.g. buildCallChain('f', '$in', ['a','b']) → "LR::f(LR::f($in, 'a'), 'b')"
+     * 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
+    {
+        $extra = $extraArg !== '' ? ", $extraArg" : '';
+        $expr = $base;
+        foreach ($parts as $part) {
+            $expr = self::getRuntimeFunc($fn, "$expr, " . self::quote($part) . $extra);
+        }
+        return $expr;
+    }
+
     /**
      * Build a chained array-access string for the given path parts.
      * e.g. ['foo', 'bar'] → "['foo']['bar']"

src/Runtime.php

@@ -131,6 +131,20 @@ public static function strictLookup(mixed $base, string $key, string $original):
         return $base[$key];
     }
 
+    /**
+     * assumeObjects / strict-helper-arg key lookup: throw if $base is null (mirroring JS
+     * TypeError for null/undefined property access); return null silently for a missing key on a
+     * valid array (mirroring JS returning undefined for a missing object property); return null for
+     * non-array non-null bases (mirroring JS returning undefined for property access on primitives).
+     */
+    public static function nullCheck(mixed $base, string $key): mixed
+    {
+        if ($base === null) {
+            throw new \ErrorException("Cannot access property \"$key\" on null");
+        }
+        return is_array($base) ? ($base[$key] ?? null) : null;
+    }
+
     /**
      * Build a RuntimeContext from raw render options and compile-time partial closures.
      *
@@ -176,9 +190,10 @@ public static function dv(mixed $v, mixed ...$args): mixed
     }
 
     /**
-     * Context variable lookup for knownHelpersOnly mode.
+     * Context variable lookup without helper dispatch.
      * Looks up $name in $_this; if the value is a Closure, invokes it with $_this as context.
-     * Skips helper dispatch (the compiler has already ruled out known helpers).
+     * Used when helper dispatch is unnecessary: knownHelpersOnly mode (the compiler has already
+     * ruled out known helpers), and inlined if/unless conditions on single-segment paths.
      *
      * @param mixed $_this current rendering context
      */

tests/ErrorTest.php

@@ -69,6 +69,11 @@ public static function renderErrorProvider(): array
                 'data' => ['foo' => []],
                 'expected' => '"foo.bar" not defined',
             ],
+            [
+                'template' => '{{#if foo.bar}}bad{{else}}OK{{/if}}',
+                'options' => new Options(strict: true),
+                'expected' => 'Cannot access property "bar" on null',
+            ],
             [
                 'template' => '{{foo}}',
                 'options' => new Options(strict: true),