codeigniter4 · samsonasik · Nov 19, 2025 · Nov 19, 2025 · Nov 19, 2025
diff --git a/admin/framework/composer.json b/admin/framework/composer.json
@@ -20,7 +20,7 @@
         "codeigniter/coding-standard": "^1.7",
         "fakerphp/faker": "^1.24",
         "friendsofphp/php-cs-fixer": "^3.47.1",
-        "kint-php/kint": "^6.0",
+        "kint-php/kint": "^6.1",
         "mikey179/vfsstream": "^1.6.12",
         "nexusphp/cs-config": "^3.6",
         "phpunit/phpunit": "^10.5.16 || ^11.2",

diff --git a/composer.json b/composer.json
@@ -19,7 +19,7 @@
     "require-dev": {
         "codeigniter/phpstan-codeigniter": "1.x-dev",
         "fakerphp/faker": "^1.24",
-        "kint-php/kint": "^6.0",
+        "kint-php/kint": "^6.1",
         "mikey179/vfsstream": "^1.6.12",
         "nexusphp/tachycardia": "^2.0",
         "phpstan/extension-installer": "^1.4",

diff --git a/system/ThirdParty/Kint/CallFinder.php b/system/ThirdParty/Kint/CallFinder.php
@@ -148,11 +148,11 @@ class CallFinder
     ];
 
     /**
-     * @psalm-param callable-array|callable-string $function
-     *
-     * @psalm-return list<array{parameters: list<CallParameter>, modifiers: list<PhpToken>}>
+     * @psalm-param callable-string|(callable-array&list{class-string, non-empty-string}) $function
      *
      * @return array List of matching calls on the relevant line
+     *
+     * @psalm-return list<array{parameters: list<CallParameter>, modifiers: list<PhpToken>}>
      */
     public static function getFunctionCalls(string $source, int $line, $function): array
     {
@@ -198,6 +198,11 @@ public static function getFunctionCalls(string $source, int $line, $function): a
             self::$operator[T_NEW] = true; // @codeCoverageIgnore
         }
 
+        if (KINT_PHP85) {
+            /** @psalm-suppress UndefinedConstant */
+            self::$operator[T_PIPE] = true;
+        }
+
         /** @psalm-var list<PhpToken> */
         $tokens = \token_get_all($source);
         $function_calls = [];
@@ -212,10 +217,6 @@ public static function getFunctionCalls(string $source, int $line, $function): a
             $function = \strtolower($function[1]);
         } else {
             $class = null;
-            /**
-             * @psalm-suppress RedundantFunctionCallGivenDocblockType
-             * Psalm bug #11075
-             */
             $function = \strtolower($function);
         }
 
@@ -294,6 +295,8 @@ public static function getFunctionCalls(string $source, int $line, $function): a
             $params = []; // All our collected parameters
             $shortparam = []; // The short version of the parameter
             $param_start = $offset; // The distance to the start of the parameter
+            $quote = null; // Buffer to store quote type for shortparam
+            $in_ternary = false;
 
             // Loop through the following tokens until the function call ends
             while (isset($tokens[$offset])) {
@@ -341,6 +344,26 @@ public static function getFunctionCalls(string $source, int $line, $function): a
                     $instring = !$instring;
 
                     $shortparam[] = $token;
+                } elseif (T_START_HEREDOC === $token[0]) {
+                    if (1 === $depth) {
+                        $quote = \ltrim($token[1], " \t<")[0];
+                        if ("'" !== $quote) {
+                            $quote = '"';
+                        }
+                        $shortparam[] = [T_START_HEREDOC, $quote];
+                        $instring = true;
+                    }
+
+                    ++$depth;
+                } elseif (T_END_HEREDOC === $token[0]) {
+                    --$depth;
+
+                    if (1 === $depth) {
+                        if ($realtokens) {
+                            $shortparam[] = '...';
+                        }
+                        $shortparam[] = [T_END_HEREDOC, $quote];
+                    }
                 } elseif (1 === $depth) {
                     if (',' === $token[0]) {
                         $params[] = [
@@ -349,6 +372,7 @@ public static function getFunctionCalls(string $source, int $line, $function): a
                         ];
                         $shortparam = [];
                         $paramrealtokens = false;
+                        $in_ternary = false;
                         $param_start = $offset + 1;
                     } elseif (T_CONSTANT_ENCAPSED_STRING === $token[0]) {
                         $quote = $token[1][0];
@@ -364,6 +388,15 @@ public static function getFunctionCalls(string $source, int $line, $function): a
                         }
                         $shortparam[] = $token;
                     } else {
+                        // We can't tell the order of named parameters or if they're splatting
+                        // without parsing the called function and that's too much work for this
+                        // edge case so we'll just skip parameters altogether.
+                        if ('?' === $token) {
+                            $in_ternary = true;
+                        } elseif (!$in_ternary && ':' === $token) {
+                            $params = [];
+                            break;
+                        }
                         $shortparam[] = $token;
                     }
                 }
@@ -400,13 +433,26 @@ public static function getFunctionCalls(string $source, int $line, $function): a
                 $literal = false;
                 $new_without_parens = false;
 
-                foreach ($name as $token) {
+                foreach ($name as $name_index => $token) {
+                    if (KINT_PHP85 && T_CLONE === $token[0]) {
+                        $nextReal = self::realTokenIndex($name, $name_index + 1);
+
+                        if (null !== $nextReal && '(' === $name[$nextReal]) {
+                            continue;
+                        }
+                    }
+
                     if (self::tokenIsOperator($token)) {
                         $expression = true;
                         break;
                     }
                 }
 
+                if (!$expression && T_START_HEREDOC === $name[0][0]) {
+                    $expression = true;
+                    $literal = true;
+                }
+
                 // As of 8.4 new is only an expression when parentheses are
                 // omitted. In that case we can cheat and add them ourselves.
                 //
@@ -593,6 +639,7 @@ private static function tokensTrim(array $tokens): array
         return \array_reverse($tokens);
     }
 
+    /** @psalm-return list<PhpToken> */
     private static function tokensFormatted(array $tokens): array
     {
         $tokens = self::tokensTrim($tokens);

diff --git a/system/ThirdParty/Kint/Kint.php b/system/ThirdParty/Kint/Kint.php
@@ -36,15 +36,24 @@
 use Kint\Renderer\TextRenderer;
 use Kint\Value\Context\BaseContext;
 use Kint\Value\Context\ContextInterface;
+use Kint\Value\TraceFrameValue;
 use Kint\Value\UninitializedValue;
 
 /**
  * @psalm-consistent-constructor
  * Psalm bug #8523
  *
  * @psalm-import-type CallParameter from CallFinder
+ * @psalm-import-type TraceFrame from TraceFrameValue
  *
- * @psalm-type KintMode = Kint::MODE_*|bool
+ * @psalm-type KintMode = array-key|bool
+ * @psalm-type KintCallInfo = array{
+ *   params: ?list<CallParameter>,
+ *   modifiers: array,
+ *   callee: ?callable,
+ *   caller: ?callable,
+ *   trace: TraceFrame[],
+ * }
  *
  * @psalm-api
  */
@@ -396,9 +405,9 @@ public static function getBasesFromParamInfo(array $params, int $argc): array
      * @param array[] $trace   Backtrace
      * @param array   $args    Arguments
      *
-     * @return array Call info
-     *
      * @psalm-param list<non-empty-array> $trace
+     *
+     * @return KintCallInfo Call info
      */
     public static function getCallInfo(array $aliases, array $trace, array $args): array
     {
@@ -622,8 +631,8 @@ protected static function getSingleCall(array $frame, array $args): ?array
 
                             foreach ($keys as $key) {
                                 $call['parameters'][] = [
-                                    'name' => \substr($param['name'], 3).'['.\var_export($key, true).']',
-                                    'path' => \substr($param['path'], 3).'['.\var_export($key, true).']',
+                                    'name' => ((string) \substr($param['name'], 3)).'['.\var_export($key, true).']',
+                                    'path' => ((string) \substr($param['path'], 3)).'['.\var_export($key, true).']',
                                     'expression' => false,
                                     'literal' => false,
                                     'new_without_parens' => false,
@@ -634,8 +643,8 @@ protected static function getSingleCall(array $frame, array $args): ?array
                             // through array_values so we can't access them directly at all
                             for ($j = 0; $j + $i < $argc; ++$j) {
                                 $call['parameters'][] = [
-                                    'name' => 'array_values('.\substr($param['name'], 3).')['.$j.']',
-                                    'path' => 'array_values('.\substr($param['path'], 3).')['.$j.']',
+                                    'name' => 'array_values('.((string) \substr($param['name'], 3)).')['.$j.']',
+                                    'path' => 'array_values('.((string) \substr($param['path'], 3)).')['.$j.']',
                                     'expression' => false,
                                     'literal' => false,
                                     'new_without_parens' => false,

diff --git a/system/ThirdParty/Kint/Parser/ClassStaticsPlugin.php b/system/ThirdParty/Kint/Parser/ClassStaticsPlugin.php
@@ -136,7 +136,9 @@ private function buildStaticValue(ReflectionProperty $pr, int $depth): AbstractV
             $context->access_path = '\\'.$context->owner_class.'::$'.$context->name;
         }
 
-        $pr->setAccessible(true);
+        if (KINT_PHP81 === false) {
+            $pr->setAccessible(true);
+        }
 
         /**
          * @psalm-suppress TooFewArguments

diff --git a/system/ThirdParty/Kint/Parser/ColorPlugin.php b/system/ThirdParty/Kint/Parser/ColorPlugin.php
@@ -57,7 +57,7 @@ public function parseComplete(&$var, AbstractValue $v, int $trigger): AbstractVa
 
         $trimmed = \strtolower(\trim($var));
 
-        if (!isset(ColorRepresentation::$color_map[$trimmed]) && !\preg_match('/^(?:(?:rgb|hsl)[^\\)]{6,}\\)|#[0-9a-fA-F]{3,8})$/', $trimmed)) {
+        if (!isset(ColorRepresentation::$color_map[$trimmed]) && !\preg_match('/^(?:(?:rgb|hsl)a?[^\\)]{6,}\\)|#[0-9a-f]{3,8})$/', $trimmed)) {
             return $v;
         }
 

diff --git a/system/ThirdParty/Kint/Parser/DomPlugin.php b/system/ThirdParty/Kint/Parser/DomPlugin.php
@@ -55,11 +55,12 @@
 use Kint\Value\Representation\ContainerRepresentation;
 use Kint\Value\StringValue;
 use LogicException;
+use ReflectionClass;
 
 class DomPlugin extends AbstractPlugin implements PluginBeginInterface
 {
     /**
-     * Reflection doesn't work below 8.1, also it won't show readonly status.
+     * Reflection doesn't show readonly status.
      *
      * In order to ensure this is stable enough we're only going to provide
      * properties for element and node. If subclasses like attr or document
@@ -102,12 +103,9 @@ class DomPlugin extends AbstractPlugin implements PluginBeginInterface
         'previousElementSibling' => true,
         'nextElementSibling' => true,
         'innerHTML' => false,
-        'outerHTML' => false,
+        'outerHTML' => true,
         'substitutedNodeValue' => false,
-    ];
-
-    public const DOM_NS_VERSIONS = [
-        'outerHTML' => KINT_PHP85,
+        'children' => true,
     ];
 
     /**
@@ -208,6 +206,9 @@ class DomPlugin extends AbstractPlugin implements PluginBeginInterface
      */
     public static bool $verbose = false;
 
+    /** @psalm-var array<class-string, array<string, bool>> cache of properties for getKnownProperties */
+    protected static array $property_cache = [];
+
     protected ClassMethodsPlugin $methods_plugin;
     protected ClassStaticsPlugin $statics_plugin;
 
@@ -259,12 +260,14 @@ public function parseBegin(&$var, ContextInterface $c): ?AbstractValue
     /** @psalm-param Node|DOMNode $var */
     private function parseProperty(object $var, string $prop, ContextInterface $c): AbstractValue
     {
-        if (!isset($var->{$prop})) {
+        // Suppress deprecation message
+        if (@!isset($var->{$prop})) {
             return new FixedWidthValue($c, null);
         }
 
         $parser = $this->getParser();
-        $value = $var->{$prop};
+        // Suppress deprecation message
+        @$value = $var->{$prop};
 
         if (\is_scalar($value)) {
             return $parser->parse($value, $c);
@@ -450,40 +453,49 @@ private function parseNode(object $var, ContextInterface $c): DomNodeValue
      */
     public static function getKnownProperties(object $var): array
     {
-        if ($var instanceof Node) {
-            $known_properties = self::NODE_PROPS;
-            if ($var instanceof Element) {
-                $known_properties += self::ELEMENT_PROPS;
-            }
-
-            if ($var instanceof Document) {
-                $known_properties['textContent'] = true;
-            }
+        if (KINT_PHP81) {
+            $r = new ReflectionClass($var);
+            $classname = $r->getName();
+
+            if (!isset(self::$property_cache[$classname])) {
+                self::$property_cache[$classname] = [];
+
+                foreach ($r->getProperties() as $prop) {
+                    if ($prop->isStatic()) {
+                        continue;
+                    }
+
+                    $declaring = $prop->getDeclaringClass()->getName();
+                    $name = $prop->name;
+
+                    if (\in_array($declaring, [Node::class, Element::class], true)) {
+                        $readonly = self::NODE_PROPS[$name] ?? self::ELEMENT_PROPS[$name];
+                    } elseif (\in_array($declaring, [DOMNode::class, DOMElement::class], true)) {
+                        $readonly = self::DOMNODE_PROPS[$name] ?? self::DOMELEMENT_PROPS[$name];
+                    } else {
+                        continue;
+                    }
+
+                    self::$property_cache[$classname][$prop->name] = $readonly;
+                }
 
-            if ($var instanceof Attr || $var instanceof CharacterData) {
-                $known_properties['nodeValue'] = false;
-            }
+                if ($var instanceof Document) {
+                    self::$property_cache[$classname]['textContent'] = true;
+                }
 
-            foreach (self::DOM_NS_VERSIONS as $key => $val) {
-                /**
-                 * @psalm-var bool $val
-                 * Psalm bug #4509
-                 */
-                if (false === $val) {
-                    unset($known_properties[$key]); // @codeCoverageIgnore
+                if ($var instanceof Attr || $var instanceof CharacterData) {
+                    self::$property_cache[$classname]['nodeValue'] = false;
                 }
             }
+
+            $known_properties = self::$property_cache[$classname];
         } else {
             $known_properties = self::DOMNODE_PROPS;
             if ($var instanceof DOMElement) {
                 $known_properties += self::DOMELEMENT_PROPS;
             }
 
             foreach (self::DOM_VERSIONS as $key => $val) {
-                /**
-                 * @psalm-var bool $val
-                 * Psalm bug #4509
-                 */
                 if (false === $val) {
                     unset($known_properties[$key]); // @codeCoverageIgnore
                 }

diff --git a/system/ThirdParty/Kint/Parser/HtmlPlugin.php b/system/ThirdParty/Kint/Parser/HtmlPlugin.php
@@ -52,7 +52,7 @@ public function getTriggers(): int
 
     public function parseComplete(&$var, AbstractValue $v, int $trigger): AbstractValue
     {
-        if ('<!doctype html>' !== \strtolower(\substr($var, 0, 15))) {
+        if ('<!doctype html>' !== \strtolower((string) \substr($var, 0, 15))) {
             return $v;
         }
 

diff --git a/system/ThirdParty/Kint/Parser/IteratorPlugin.php b/system/ThirdParty/Kint/Parser/IteratorPlugin.php
@@ -86,10 +86,6 @@ public function parseComplete(&$var, AbstractValue $v, int $trigger): AbstractVa
         $c = $v->getContext();
 
         foreach (self::$blacklist as $class) {
-            /**
-             * @psalm-suppress RedundantCondition
-             * Psalm bug #11076
-             */
             if ($var instanceof $class) {
                 $base = new BaseContext($class.' Iterator Contents');
                 $base->depth = $c->getDepth() + 1;