Always convert overflowed int keys to string, add psalm

Author: rybakit

.gitattributes

@@ -6,3 +6,4 @@ tests export-ignore
 .php_cs.dist export-ignore
 dockerfile.sh export-ignore
 phpunit.xml.dist export-ignore
+psalm.xml export-ignore

.github/workflows/qa.yml

@@ -38,7 +38,9 @@ jobs:
       - name: Check code quality
         env: ${{ matrix.env }}
         if: ${{ env.QA }}
-        run: docker run --rm -v $PWD:/msgpack -w /msgpack msgpack php vendor/bin/php-cs-fixer fix --dry-run --diff --verbose .
+        run: |
+          docker run --rm -v $PWD:/msgpack -w /msgpack msgpack php vendor/bin/php-cs-fixer fix --dry-run --diff --verbose .
+          docker run --rm -v $PWD:/msgpack -w /msgpack msgpack php vendor/bin/psalm
 
       - name: Upload code coverage to Scrutinizer
         env: ${{ matrix.env }}

composer.json

@@ -16,7 +16,8 @@
     "require-dev": {
         "ext-gmp": "*",
         "friendsofphp/php-cs-fixer": "^2.14",
-        "phpunit/phpunit": "^7.1|^8|^9"
+        "phpunit/phpunit": "^7.1|^8|^9",
+        "vimeo/psalm": "^3.9|^4"
     },
     "suggest": {
         "ext-decimal": "For converting overflowed integers to Decimal objects",

psalm.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<psalm
+    errorLevel="2"
+    resolveFromConfigFile="true"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>

src/BufferUnpacker.php

@@ -20,14 +20,19 @@
 
 class BufferUnpacker
 {
+    /** @var string */
     private $buffer;
+
+    /** @var int */
     private $offset = 0;
+
+    /** @var bool */
     private $isBigIntAsDec;
+
+    /** @var bool */
     private $isBigIntAsGmp;
 
-    /**
-     * @var Extension[]
-     */
+    /** @var Extension[] */
     private $extensions = [];
 
     /**
@@ -109,6 +114,9 @@ public function seek(int $offset) : self
         return $this;
     }
 
+    /**
+     * @param positive-int $length
+     */
     public function skip(int $length) : self
     {
         $offset = $this->offset + $length;
@@ -179,6 +187,9 @@ public function tryUnpack() : array
         return $data;
     }
 
+    /**
+     * @return mixed
+     */
     public function unpack()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -280,6 +291,9 @@ public function unpack()
         throw UnpackingFailedException::unknownCode($c);
     }
 
+    /**
+     * @return null
+     */
     public function unpackNil()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -295,6 +309,9 @@ public function unpackNil()
         throw UnpackingFailedException::unexpectedCode(\ord($this->buffer[$this->offset++]), 'nil');
     }
 
+    /**
+     * @return bool
+     */
     public function unpackBool()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -314,6 +331,9 @@ public function unpackBool()
         throw UnpackingFailedException::unexpectedCode($c, 'bool');
     }
 
+    /**
+     * @return Decimal|\GMP|int|string
+     */
     public function unpackInt()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -348,6 +368,9 @@ public function unpackInt()
         throw UnpackingFailedException::unexpectedCode($c, 'int');
     }
 
+    /**
+     * @return float
+     */
     public function unpackFloat()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -367,6 +390,9 @@ public function unpackFloat()
         throw UnpackingFailedException::unexpectedCode($c, 'float');
     }
 
+    /**
+     * @return string
+     */
     public function unpackStr()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -392,6 +418,9 @@ public function unpackStr()
         throw UnpackingFailedException::unexpectedCode($c, 'str');
     }
 
+    /**
+     * @return string
+     */
     public function unpackBin()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -414,6 +443,9 @@ public function unpackBin()
         throw UnpackingFailedException::unexpectedCode($c, 'bin');
     }
 
+    /**
+     * @return array
+     */
     public function unpackArray()
     {
         $size = $this->unpackArrayHeader();
@@ -426,6 +458,9 @@ public function unpackArray()
         return $array;
     }
 
+    /**
+     * @return int
+     */
     public function unpackArrayHeader()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -448,6 +483,9 @@ public function unpackArrayHeader()
         throw UnpackingFailedException::unexpectedCode($c, 'array');
     }
 
+    /**
+     * @return array
+     */
     public function unpackMap()
     {
         $size = $this->unpackMapHeader();
@@ -460,6 +498,9 @@ public function unpackMap()
         return $map;
     }
 
+    /**
+     * @return int
+     */
     public function unpackMapHeader()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -482,6 +523,9 @@ public function unpackMapHeader()
         throw UnpackingFailedException::unexpectedCode($c, 'map');
     }
 
+    /**
+     * @return mixed
+     */
     public function unpackExt()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -505,6 +549,9 @@ public function unpackExt()
         throw UnpackingFailedException::unexpectedCode($c, 'ext');
     }
 
+    /**
+     * @return int
+     */
     private function unpackUint8()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -514,6 +561,9 @@ private function unpackUint8()
         return \ord($this->buffer[$this->offset++]);
     }
 
+    /**
+     * @return int
+     */
     private function unpackUint16()
     {
         if (!isset($this->buffer[$this->offset + 1])) {
@@ -524,6 +574,9 @@ private function unpackUint16()
             | \ord($this->buffer[$this->offset++]);
     }
 
+    /**
+     * @return int
+     */
     private function unpackUint32()
     {
         if (!isset($this->buffer[$this->offset + 3])) {
@@ -536,6 +589,9 @@ private function unpackUint32()
             | \ord($this->buffer[$this->offset++]);
     }
 
+    /**
+     * @return Decimal|\GMP|int|string
+     */
     private function unpackUint64()
     {
         if (!isset($this->buffer[$this->offset + 7])) {
@@ -558,6 +614,24 @@ private function unpackUint64()
         return \sprintf('%u', $num);
     }
 
+    /**
+     * @return int|string
+     */
+    private function unpackUint64MapKey()
+    {
+        if (!isset($this->buffer[$this->offset + 7])) {
+            throw new InsufficientDataException();
+        }
+
+        $num = \unpack('J', $this->buffer, $this->offset)[1];
+        $this->offset += 8;
+
+        return $num >= 0 ? $num : \sprintf('%u', $num);
+    }
+
+    /**
+     * @return int
+     */
     private function unpackInt8()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -570,6 +644,9 @@ private function unpackInt8()
         return $num > 0x7f ? $num - 0x100 : $num;
     }
 
+    /**
+     * @return int
+     */
     private function unpackInt16()
     {
         if (!isset($this->buffer[$this->offset + 1])) {
@@ -583,6 +660,9 @@ private function unpackInt16()
         return $num > 0x7fff ? $num - 0x10000 : $num;
     }
 
+    /**
+     * @return int
+     */
     private function unpackInt32()
     {
         if (!isset($this->buffer[$this->offset + 3])) {
@@ -598,6 +678,9 @@ private function unpackInt32()
         return $num > 0x7fffffff ? $num - 0x100000000 : $num;
     }
 
+    /**
+     * @return int
+     */
     private function unpackInt64()
     {
         if (!isset($this->buffer[$this->offset + 7])) {
@@ -610,6 +693,9 @@ private function unpackInt64()
         return $num;
     }
 
+    /**
+     * @return float
+     */
     private function unpackFloat32()
     {
         if (!isset($this->buffer[$this->offset + 3])) {
@@ -622,6 +708,9 @@ private function unpackFloat32()
         return $num;
     }
 
+    /**
+     * @return float
+     */
     private function unpackFloat64()
     {
         if (!isset($this->buffer[$this->offset + 7])) {
@@ -634,6 +723,11 @@ private function unpackFloat64()
         return $num;
     }
 
+    /**
+     * @param int $size
+     *
+     * @return array
+     */
     private function unpackArrayData($size)
     {
         $array = [];
@@ -644,6 +738,11 @@ private function unpackArrayData($size)
         return $array;
     }
 
+    /**
+     * @param int $size
+     *
+     * @return array
+     */
     private function unpackMapData($size)
     {
         $map = [];
@@ -654,6 +753,9 @@ private function unpackMapData($size)
         return $map;
     }
 
+    /**
+     * @return int|string
+     */
     private function unpackMapKey()
     {
         if (!isset($this->buffer[$this->offset])) {
@@ -681,7 +783,7 @@ private function unpackMapKey()
             case 0xcc: return $this->unpackUint8();
             case 0xcd: return $this->unpackUint16();
             case 0xce: return $this->unpackUint32();
-            case 0xcf: return $this->unpackUint64();
+            case 0xcf: return $this->unpackUint64MapKey();
             // int
             case 0xd0: return $this->unpackInt8();
             case 0xd1: return $this->unpackInt16();
@@ -700,6 +802,11 @@ private function unpackMapKey()
         throw UnpackingFailedException::invalidMapKeyType($c);
     }
 
+    /**
+     * @param int $length
+     *
+     * @return mixed
+     */
     private function unpackExtData($length)
     {
         if (!isset($this->buffer[$this->offset + $length])) { // 1 (type) + length - 1

src/Exception/PackingFailedException.php

@@ -13,6 +13,9 @@
 
 class PackingFailedException extends \RuntimeException
 {
+    /**
+     * @param mixed $value
+     */
     public static function unsupportedType($value) : self
     {
         return new self(\sprintf('Unsupported type "%s", maybe you forgot to register the type transformer?',