Fix more issues

Author: theodorejb

src/Compiler.php

@@ -532,24 +532,19 @@ private function MustacheStatement(MustacheStatement $mustache): string
 
         if ($helperName !== null && $type === SexprType::Ambiguous && !$this->context->options->strict) {
             $escapedKey = self::quote($helperName);
+            $isData = $path instanceof PathExpression && $path->data;
             if ($this->context->options->knownHelpersOnly) {
-                return self::getRuntimeFunc($fn, self::getRuntimeFunc('cv', "\$in, $escapedKey"));
+                $lookup = $isData ? "\$cx->data[$escapedKey] ?? null" : self::getRuntimeFunc('cv', "\$in, $escapedKey");
+                return self::getRuntimeFunc($fn, $lookup);
             }
-            $hvArgs = "\$cx, $escapedKey, \$in" . ($this->context->options->assumeObjects ? ', true' : '');
+            $scope = $isData ? '$cx->data' : '$in';
+            $hvArgs = "\$cx, $escapedKey, $scope" . ($this->context->options->assumeObjects ? ', true' : '');
             return self::getRuntimeFunc($fn, self::getRuntimeFunc('hv', $hvArgs));
         }
 
         // Simple: direct path lookup
         if ($path instanceof PathExpression) {
-            // Single-segment @data vars use lambda() so closures receive HelperOptions;
-            // everything else (multi-segment, depth/scoped paths) uses dv().
-            $varPath = $this->PathExpression($path);
-            if ($path->data && $path->depth === 0 && count($path->parts) === 1
-                && is_string($path->parts[0]) && $path->parts[0] !== 'partial-block') {
-                $escapedName = self::quote($path->parts[0]);
-                return self::getRuntimeFunc($fn, self::getRuntimeFunc('lambda', "\$cx, $escapedName, $varPath, \$in"));
-            }
-            return self::getRuntimeFunc($fn, self::getRuntimeFunc('dv', $varPath));
+            return self::getRuntimeFunc($fn, self::getRuntimeFunc('dv', $this->PathExpression($path)));
         }
 
         // Literal in simple/fallthrough position (strict, assumeObjects, or knownHelpersOnly):
@@ -795,8 +790,7 @@ private function getSimpleHelperName(PathExpression|Literal $path): ?string
         if ($path instanceof Literal) {
             return $this->getLiteralKeyName($path);
         }
-        if ($path->data
-            || $path->depth > 0
+        if ($path->depth > 0
             || self::scopedId($path)
             || count($path->parts) !== 1
             || !is_string($path->parts[0])
@@ -866,43 +860,47 @@ private static function buildHbbchCall(string $helperExpr, string $escapedName,
         return self::getRuntimeFunc('hbbch', "\$cx, $helperExpr, $escapedName, $params, \$in, $blockFn, $else$trailingArgs");
     }
 
-    /**
-     * Build a resolveHelper + hbch call for dynamic inline helper dispatch.
-     */
-    private function buildResolvedHbchCall(string $escapedName, string $varPath, string $params): string
-    {
-        $resolved = self::getRuntimeFunc('resolveHelper', "\$cx, $escapedName, $varPath");
-        return self::getRuntimeFunc('hbch', "\$cx, $resolved, $escapedName, $params, \$in");
-    }
-
     /**
      * Compile a helper call for a MustacheStatement (Helper type) or SubExpression.
      * @param Expression[] $params
      */
     private function compileHelperCall(?string $helperName, Expression $path, array $params, ?Hash $hash): string
     {
+        $compiledParams = $this->compileParams($params, $hash);
+
         if ($helperName !== null) {
-            $compiledParams = $this->compileParams($params, $hash);
             $escapedName = self::quote($helperName);
+            $isData = $path instanceof PathExpression && $path->data;
             if ($this->isKnownHelper($helperName)) {
                 return self::getRuntimeFunc('hbch', "\$cx, \$cx->helpers[$escapedName], $escapedName, $compiledParams, \$in");
             }
             if ($this->context->options->knownHelpersOnly) {
                 $this->throwKnownHelpersOnly($helperName);
             }
-            return $this->buildResolvedHbchCall($escapedName, "\$in[$escapedName] ?? null", $compiledParams);
+            $fallback = $isData ? "\$cx->data[$escapedName] ?? null" : "\$in[$escapedName] ?? null";
+            $resolved = self::getRuntimeFunc('resolveHelper', "\$cx, $escapedName, $fallback");
+            return self::getRuntimeFunc('hbch', "\$cx, $resolved, $escapedName, $compiledParams, \$in");
         }
+
         if ($path instanceof PathExpression) {
             $varPath = $this->PathExpression($path);
             $stringParts = array_filter($path->parts, 'is_string');
-            if (!$path->data && $path->depth === 0 && !self::scopedId($path)
-                && count($stringParts) === count($path->parts)) {
-                $logicalName = self::quote(implode('.', $stringParts));
-                return $this->buildResolvedHbchCall($logicalName, $varPath, $this->compileParams($params, $hash));
+            if (count($stringParts) === count($path->parts)) {
+                // All-string parts (foo.bar, ../fn, ./fn, @fn): scoped/depth/data paths resolve
+                // from context only; normal paths check the helpers hash first via resolveHelper.
+                $escapedName = self::quote($path->original);
+                $resolverFn = (!$path->data && $path->depth === 0 && !self::scopedId($path))
+                    ? 'resolveHelper'
+                    : 'resolveContextHelper';
+            } else {
+                // SubExpression-headed path (e.g. ((helper).prop args)): context-only resolution.
+                $escapedName = self::quote(implode('.', $stringParts));
+                $resolverFn = 'resolveContextHelper';
             }
-            $args = array_map(fn($p) => $this->compileExpression($p), $params);
-            return self::getRuntimeFunc('dv', implode(', ', [$varPath, ...$args]));
+            $resolved = self::getRuntimeFunc($resolverFn, "\$cx, $escapedName, $varPath");
+            return self::getRuntimeFunc('hbch', "\$cx, $resolved, $escapedName, $compiledParams, \$in");
         }
+
         throw new \Exception('Sub-expression must be a helper call');
     }
 

src/Runtime.php

@@ -202,24 +202,11 @@ public static function createContext(mixed $context, array $options, array $comp
     }
 
     /**
-     * Invoke $v if it is callable, passing any extra args; otherwise return $v as-is.
-     * Mirrors HBS.js container.lambda for multi-segment paths and scoped/depth expressions with args.
+     * Invoke $v if it is a Closure; otherwise return $v as-is.
      */
-    public static function dv(mixed $v, mixed ...$args): mixed
+    public static function dv(mixed $v): mixed
     {
-        return $v instanceof Closure ? $v(...$args) : $v;
-    }
-
-    /**
-     * Mirrors HBS.js container.lambda for single-segment @data variables: routes closures through
-     * hbch so they receive a HelperOptions argument when their signature expects one.
-     */
-    public static function lambda(RuntimeContext $cx, string $name, mixed $v, mixed &$_this): mixed
-    {
-        if ($v instanceof Closure) {
-            return static::hbch($cx, $v, $name, [], [], $_this);
-        }
-        return $v;
+        return $v instanceof Closure ? $v() : $v;
     }
 
     /**
@@ -452,6 +439,21 @@ public static function resolveHelper(RuntimeContext $cx, string $name, mixed $ca
         return $cx->helpers['helperMissing'];
     }
 
+    /**
+     * Like resolveHelper but skips the helpers hash lookup — for scoped (./), depth (../),
+     * and data (@) paths which resolve from context only, matching HBS.js behaviour.
+     */
+    public static function resolveContextHelper(RuntimeContext $cx, string $name, mixed $callable): Closure
+    {
+        if ($callable instanceof Closure) {
+            return $callable;
+        }
+        if ($callable !== null) {
+            throw new \Exception("Expected $name to be a function, got " . json_encode($callable));
+        }
+        return $cx->helpers['helperMissing'];
+    }
+
     /**
      * Invoke a resolved helper Closure with positional params, hash, and a HelperOptions instance.
      * Used for known helpers and resolved helpers (direct hbch calls from generated code),

tests/ErrorTest.php

@@ -266,6 +266,11 @@ public static function errorProvider(): array
                 'options' => new Options(knownHelpersOnly: true),
                 'expected' => 'You specified knownHelpersOnly, but used the unknown helper ../flag',
             ],
+            'knownHelpersOnly rejects @data path with params' => [
+                'template' => '{{@fn "Hello"}}',
+                'options' => new Options(knownHelpersOnly: true),
+                'expected' => 'You specified knownHelpersOnly, but used the unknown helper fn',
+            ],
             'unknown decorator throws' => [
                 'template' => '{{#*help me}}{{/help}}',
                 'expected' => 'Unknown decorator: "help"',

tests/RegressionTest.php

@@ -2127,6 +2127,12 @@ public static function dataClosuresProvider(): array
                 'vars' => ['foo' => fn(HelperOptions $options) => $options->name . ': OK'],
                 'expected' => 'foo: OK',
             ],
+            'registered helper takes priority over @data value' => [
+                'template' => '{{@var}}',
+                'vars' => ['var' => 'bad'],
+                'helpers' => ['var' => fn(HelperOptions $opts) => 'helper:' . $opts->name],
+                'expected' => 'helper:var',
+            ],
             '@data closure at multi-segment path is invoked without arguments' => [
                 'template' => '{{@foo.bar}}',
                 'vars' => ['foo' => ['bar' => fn(...$args) => count($args) . ' args']],
@@ -2254,10 +2260,30 @@ public static function subexpressionPathProvider(): array
                 'expected' => 'got:val',
             ],
             'sub-expression as path head: callable' => [
-                'template' => '{{((my-helper foo).bar baz)}}',
-                'data' => ['foo' => 'x', 'baz' => 'y'],
-                'helpers' => ['my-helper' => fn($arg) => ['bar' => fn($x) => "called:$x"]],
-                'expected' => 'called:y',
+                'template' => '{{((my-helper foo).x baz key=val)}}',
+                'data' => ['foo' => 'x', 'baz' => 'y', 'val' => 'hashval'],
+                'helpers' => [
+                    'my-helper' => fn($arg) => [
+                        $arg => function ($x, ?HelperOptions $opts = null) {
+                            return 'called:' . $x . ',key=' . ($opts?->hash['key'] ?? 'null');
+                        },
+                    ],
+                ],
+                'expected' => 'called:y,key=hashval',
+            ],
+            'sub-expression: depth-based callee receives hash in HelperOptions' => [
+                'template' => '{{#each items}}{{{identity (../outerFn pos key=val)}}}|{{/each}}',
+                'data' => [
+                    'items' => [
+                        ['pos' => 'p1', 'val' => 'v1'],
+                        ['pos' => 'p2', 'val' => 'v2'],
+                    ],
+                    'outerFn' => function ($pos, ?HelperOptions $opts = null) {
+                        return 'pos=' . $pos . ',key=' . ($opts?->hash['key'] ?? 'null');
+                    },
+                ],
+                'helpers' => ['identity' => fn($x) => $x],
+                'expected' => 'pos=p1,key=v1|pos=p2,key=v2|',
             ],
             'sub-expression as path head: argument' => [
                 'template' => '{{(foo (my-helper bar).baz)}}',
@@ -2279,26 +2305,28 @@ public static function subexpressionPathProvider(): array
             ],
 
             'sub-expression: multi-segment callee invokes helperMissing when not in context' => [
-                'template' => '{{identity (foo.bar baz)}}',
+                'template' => '{{{identity (foo.bar baz prop=2)}}}',
                 'data' => ['baz' => 'val'],
                 'helpers' => [
                     'identity' => fn($x) => $x,
-                    'helperMissing' => fn($x, HelperOptions $opts) => 'missing:' . $opts->name,
+                    'helperMissing' => function ($baz, HelperOptions $options) {
+                        return "missing:{$options->name},baz=$baz,prop={$options->hash['prop']}";
+                    },
                 ],
-                'expected' => 'missing:foo.bar',
+                'expected' => 'missing:foo.bar,baz=val,prop=2',
             ],
             'sub-expression: multi-segment callee receives HelperOptions' => [
-                'template' => '{{{identity (foo.bar baz)}}}',
+                'template' => '{{{identity (foo.bar baz prop=2)}}}',
                 'data' => [
                     'foo' => [
-                        'bar' => function ($x, ?HelperOptions $opts = null) {
-                            return 'name=' . ($opts->name ?? 'null') . ',x=' . $x;
+                        'bar' => function ($baz, HelperOptions $options) {
+                            return "name={$options->name},baz=$baz,prop={$options->hash['prop']}";
                         },
                     ],
                     'baz' => 'val',
                 ],
                 'helpers' => ['identity' => fn($x) => $x],
-                'expected' => 'name=foo.bar,x=val',
+                'expected' => 'name=foo.bar,baz=val,prop=2',
             ],
         ];
     }