Optimize length lookup

Author: theodorejb

src/Compiler.php

@@ -489,7 +489,7 @@ private function MustacheStatement(MustacheStatement $mustache): string
                 $cvArgs = '$in, ' . self::quote($helperName) . ($this->options->strict ? ', true' : '');
                 return self::getRuntimeFunc($fn, self::getRuntimeFunc('lookupValue', $cvArgs));
             }
-            $expression = $this->PathExpression($path);
+            return self::getRuntimeFunc($fn, $this->PathExpression($path, true));
         } else {
             // Literal in simple position: same lambda resolution as PathExpression above.
             $literalKey = $this->getLiteralKeyName($path);
@@ -511,7 +511,7 @@ private function SubExpression(SubExpression $expression): string
         return $this->compileHelperCall($helperName, $path, $expression->params, $expression->hash);
     }
 
-    private function PathExpression(PathExpression $path): string
+    private function PathExpression(PathExpression $path, bool $wrapLambda = false): string
     {
         $data = $path->data;
         $depth = $path->depth;
@@ -528,10 +528,6 @@ private function PathExpression(PathExpression $path): string
             $stringParts = $path->parts;
         }
 
-        if (!$stringParts) {
-            return $base;
-        }
-
         $isLength = end($stringParts) === 'length';
         $isCurrentContextPath = !$hasSubExprHead && !$data && $depth === 0;
         $scoped = $isCurrentContextPath && self::scopedId($path);
@@ -541,25 +537,26 @@ private function PathExpression(PathExpression $path): string
             $bp = $this->lookupBlockParam($path->head);
             if ($bp !== null) {
                 [$bpDepth, $bpIndex] = $bp;
-                $bpBase = "\$blockParams[$bpDepth][$bpIndex]";
+                $base = "\$blockParams[$bpDepth][$bpIndex]";
                 // Skip the block param name since it has been resolved to a $blockParams index.
-                $keys = $isLength ? array_slice($path->tail, 0, -1) : $path->tail;
-                $lookup = $this->compileModeAwareLookup($bpBase, $keys);
-                return $isLength ? $this->buildLookupLength($lookup) : $lookup;
+                $stringParts = $path->tail;
             }
         }
 
-        // 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, $partsExceptLength, $scoped),
-            );
+            array_pop($stringParts);
         }
+        $result = $this->compileModeAwareLookup($base, $stringParts, $scoped);
 
-        return $this->compileModeAwareLookup($base, $stringParts, $scoped);
+        if ($isLength) {
+            // 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.
+            $strict = $this->options->strict || $this->options->assumeObjects;
+            $result = self::getRuntimeFunc('lookupLength', $strict ? "$result, true" : $result);
+        }
+
+        return ($wrapLambda && !$isLength) ? self::getRuntimeFunc('lambda', $result) : $result;
     }
 
     /**
@@ -805,12 +802,6 @@ private function compileProgramOrEmpty(?Program $program): string
         return $this->compileProgram($program);
     }
 
-    private function buildLookupLength(string $parent): string
-    {
-        $strict = $this->options->strict || $this->options->assumeObjects;
-        return self::getRuntimeFunc('lookupLength', $strict ? "$parent, true" : $parent);
-    }
-
     /**
      * Compile a mode-aware path access expression for the given base and parts.
      * @param string[] $parts

src/Runtime.php

@@ -143,18 +143,23 @@ public static function nullCheck(mixed $base, string $key): mixed
     }
 
     /**
-     * Terminal .length lookup: returns an explicit 'length' key if present, and otherwise
-     * count() for arrays and strlen() for strings, since PHP doesn't have native .length properties.
+     * Terminal .length lookup: returns an explicit 'length' key if present
+     * (invoking with no args if it's a Closure), and otherwise count() for arrays
+     * and strlen() for strings, since these don't have native .length properties in PHP.
      */
     public static function lookupLength(mixed $base, bool $strict = false): mixed
     {
         if (is_array($base)) {
-            return array_key_exists('length', $base) ? $base['length'] : count($base);
-        }
-        if (is_string($base)) {
+            if (!array_key_exists('length', $base)) {
+                return count($base);
+            }
+            $v = $base['length'];
+        } elseif (is_string($base)) {
             return strlen($base);
+        } else {
+            $v = $strict ? self::strictLookup($base, 'length') : null;
         }
-        return $strict ? self::strictLookup($base, 'length') : null;
+        return $v instanceof Closure ? $v() : $v;
     }
 
     /**
@@ -209,7 +214,7 @@ public static function lambda(mixed $v): mixed
      * (PHP equivalent of JS fn.call(context), where context binds as `this` with no positional args).
      * When $strict is true, throws for missing keys.
      */
-    public static function lookupValue(mixed &$_this, string $name, bool $strict = false): mixed
+    public static function lookupValue(mixed $_this, string $name, bool $strict = false): mixed
     {
         $v = $strict ? self::strictLookup($_this, $name) : ($_this[$name] ?? null);
         return $v instanceof Closure ? $v($_this) : $v;