Better align compat mode lookup with Mustache

I also opened handlebars-lang/handlebars.js#2151 to apply the same fix to Handlebars.js.

Author: theodorejb

src/Compiler.php

@@ -823,15 +823,12 @@ private function compileModeAwareLookup(string $base, array $parts, string $orig
             return $base;
         }
         // Compat mode: walk the scope chain for parts[0] instead of looking up in $in directly.
-        // For single-part strict paths, use compatStrictLookup (throws on miss); all other paths
-        // use compatLookup (null falls through to the next depth), matching HBS.js container.lookup.
+        // For single-part strict paths, pass true to throw on miss; otherwise returns null.
         if ($this->options->compat && $base === '$in' && !$scoped) {
             $escapedName = self::quote($parts[0]);
             array_shift($parts);
-            $lookupFn = (!$parts && $this->options->strict && !$this->compilingHelperArgs)
-                ? 'compatStrictLookup'
-                : 'compatLookup';
-            $base = self::getRuntimeFunc($lookupFn, '$cx, $in, ' . $escapedName);
+            $strictArg = (!$parts && $this->options->strict && !$this->compilingHelperArgs) ? ', true' : '';
+            $base = self::getRuntimeFunc('compatLookup', '$cx, $in, ' . $escapedName . $strictArg);
             if (!$parts) {
                 return $base;
             }

src/Runtime.php

@@ -230,9 +230,7 @@ public static function invokeAmbiguous(RuntimeContext $cx, string $name, mixed &
         $value = $cx->helpers[$name] ?? null;
         if ($value === null) {
             if ($compat) {
-                $value = $strict
-                    ? self::compatStrictLookup($cx, $_this, $name)
-                    : self::compatLookup($cx, $_this, $name);
+                $value = self::compatLookup($cx, $_this, $name, $strict);
             } elseif ($strict) {
                 $value = self::strictLookup($_this, $name, $name);
             } else {
@@ -249,40 +247,23 @@ public static function invokeAmbiguous(RuntimeContext $cx, string $name, mixed &
     }
 
     /**
-     * Non-strict compat depths-walk for a single key, equivalent to HBS.js container.lookup(depths, name).
+     * Compat depths-walk for a single key, equivalent to HBS.js container.lookup / container.strictLookup.
      * Checks $in first, then walks $cx->depths from the closest ancestor outward.
-     * Null values are skipped (treated as not found), matching HBS.js container.lookup's `result != null` check.
+     * Uses array_key_exists so explicit null values shadow parent contexts (Mustache semantics).
+     * When $strict is true, throws for a key absent from all frames; otherwise returns null.
      */
-    public static function compatLookup(RuntimeContext $cx, mixed $in, string $name): mixed
-    {
-        if (is_array($in) && ($value = $in[$name] ?? null) !== null) {
-            return $value;
-        }
-        for ($i = count($cx->depths) - 1; $i >= 0; $i--) {
-            $ctx = $cx->depths[$i];
-            if (is_array($ctx) && ($v = $ctx[$name] ?? null) !== null) {
-                return $v;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Strict compat depths-walk for a single key, equivalent to HBS.js container.strictLookup(depths, name, loc).
-     * Checks $in first, then walks $cx->depths from the closest ancestor outward.
-     * Null values are treated as defined (array_key_exists), matching HBS.js container.strictLookup's `name in d` check.
-     */
-    public static function compatStrictLookup(RuntimeContext $cx, mixed $in, string $name): mixed
+    public static function compatLookup(RuntimeContext $cx, mixed $in, string $name, bool $strict = false): mixed
     {
         if (is_array($in) && array_key_exists($name, $in)) {
-            return self::strictLookup($in, $name, $name);
+            return $in[$name];
         }
         for ($i = count($cx->depths) - 1; $i >= 0; $i--) {
-            if (is_array($cx->depths[$i]) && array_key_exists($name, $cx->depths[$i])) {
-                return self::strictLookup($cx->depths[$i], $name, $name);
+            $ctx = $cx->depths[$i];
+            if (is_array($ctx) && array_key_exists($name, $ctx)) {
+                return $ctx[$name];
             }
         }
-        return self::strictLookup(null, $name, $name);
+        return $strict ? self::strictLookup(null, $name, $name) : null;
     }
 
     /**

tests/RegressionTest.php

@@ -2171,10 +2171,10 @@ public static function contextProvider(): array
                 'data' => ['name' => 'root', 'items' => [[]]],
                 'expected' => 'root',
             ],
-            'compat+strict: missing multi-part path uses depths walk for first segment' => [
+            'compat+strict: should still perform recursive lookup with a multi-part path not in context' => [
                 'template' => '{{#with child}}{{name.first}}{{/with}}',
                 'options' => new Options(compat: true, strict: true),
-                'data' => ['name' => ['first' => 'root'], 'child' => ['name' => null]],
+                'data' => ['name' => ['first' => 'root'], 'child' => ['x' => 'y']],
                 'expected' => 'root',
             ],
             'compat+strict: explicitly null property in context returned directly' => [