.github/workflows/coding_style_checks.yml

@@ -11,4 +11,4 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Run Coding Style Checks
-        run: docker run -q --rm -v "$(pwd):/project" -w /project -i jakzal/phpqa:php8.1-alpine php-cs-fixer fix --dry-run
+        run: docker run -q --rm -v "$(pwd):/project" -w /project -i jakzal/phpqa:php8.3-alpine php-cs-fixer fix --dry-run

.github/workflows/syntax_checks.yml

@@ -8,7 +8,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        php: ["8.1", "8.2", "8.3"]
+        php: ["8.1", "8.2", "8.3", "8.4"]
 
     name: Syntax Checks Under PHP ${{ matrix.php }}
 
@@ -18,4 +18,4 @@ jobs:
 
       - name: Run Syntax Checks
         run: |
-          docker run -q --rm -v "$(pwd):/project" -w /project -i jakzal/phpqa:php${{ matrix.php }} phplint src
+          docker run -q --rm -v "$(pwd):/project" -w /project -i jakzal/phpqa:php${{ matrix.php }}-alpine phplint src

src/swoole/Swoole/Async/Client.php

@@ -5,24 +5,10 @@
 namespace Swoole\Async;
 
 /**
- * @since 6.0.0-rc1
+ * @since 6.0.0
  */
 class Client extends \Swoole\Client
 {
-    public const MSG_OOB = 1;
-
-    public const MSG_PEEK = 2;
-
-    public const MSG_DONTWAIT = 64;
-
-    public const MSG_WAITALL = 256;
-
-    public const SHUT_RDWR = 2;
-
-    public const SHUT_RD = 0;
-
-    public const SHUT_WR = 1;
-
     private $onConnect;
 
     private $onError;
@@ -37,18 +23,13 @@ class Client extends \Swoole\Client
 
     private $onSSLReady;
 
+    /**
+     * @param int $type Socket type. Please check comments on property \Swoole\Client::$type for more details.
+     */
     public function __construct(int $type)
     {
     }
 
-    public function __destruct()
-    {
-    }
-
-    public function connect(string $host, int $port = 0, float $timeout = 0.5, int $sock_flag = 0): bool
-    {
-    }
-
     public function sleep(): bool
     {
     }
@@ -65,18 +46,20 @@ public function resume(): bool
     {
     }
 
+    /**
+     * Enable SSL encryption on the connection.
+     *
+     * This method is available only when OpenSSL support is enabled (i.e., when Swoole is installed with configuration
+     * option "--enable-openssl" included).
+     *
+     * {@inheritDoc}
+     * @param callable|null $onSslReady Callback function to be executed when SSL handshake is successful.
+     * @return bool TRUE if SSL handshake is successful; otherwise FALSE.
+     */
     public function enableSSL(?callable $onSslReady = null): bool
     {
     }
 
-    public function isConnected(): bool
-    {
-    }
-
-    public function close(bool $force = false): bool
-    {
-    }
-
     public function on(string $host, callable $callback): bool
     {
     }

src/swoole/Swoole/Atomic.php

@@ -17,7 +17,8 @@
  * This class uses unsigned 32-bit integers to store the value. To store the value using signed 64-bit integers, use class
  * \Swoole\Atomic\Long instead. Note that class \Swoole\Atomic\Long doesn't have method wait() nor wakeup() implemented.
  *
- * @see \Swoole\Atomic\Long
+ * @see \Swoole\Thread\Atomic Use this instead when PHP is compiled with Zend Thread Safety (ZTS) enabled.
+ * @see \Swoole\Atomic\Long Use this instead to store the value using signed 64-bit integers instead of unsigned 32-bit integers.
  * @not-serializable Objects of this class cannot be serialized.
  */
 class Atomic

src/swoole/Swoole/Atomic/Long.php

@@ -17,7 +17,8 @@
  * This class uses signed 64-bit integers to store the value. To store the value using unsigned 32-bit integers, use
  * class \Swoole\Atomic instead.
  *
- * @see \Swoole\Atomic
+ * @see \Swoole\Thread\Atomic\Long Use this instead when PHP is compiled with Zend Thread Safety (ZTS) enabled.
+ * @see \Swoole\Atomic Use this instead to store the value using unsigned 32-bit integers instead of signed 64-bit integers.
  * @not-serializable Objects of this class cannot be serialized.
  */
 class Long

src/swoole/Swoole/Client.php

@@ -115,12 +115,16 @@ public function shutdown(int $how): bool
     }
 
     /**
+     * Enable SSL encryption on the connection.
+     *
      * This method is available only when OpenSSL support is enabled (i.e., when Swoole is installed with configuration
      * option "--enable-openssl" included).
      *
+     * @param callable|null $onSslReady Callback function to be executed when SSL handshake is successful.
+     *                                  Added in v6.0.0 for child class Swoole\Async\Client only. It has no effect on this class.
      * @return bool TRUE if SSL handshake is successful; otherwise FALSE.
      */
-    public function enableSSL(): bool
+    public function enableSSL(?callable $onSslReady = null): bool
     {
     }
 

src/swoole/Swoole/Coroutine.php

@@ -480,14 +480,14 @@ public static function waitPid(int $pid, float $timeout = -1): array|false
      * Wait for given signal(s) with a timeout.
      *
      * @param int|array<int> $signals An integer or an array of integers representing the signal number(s).
-     *                                Before Swoole v6.0.0-rc1, only integer is supported.
+     *                                Before Swoole v6.0.0, only integer is supported.
      * @param float $timeout The timeout value in seconds. Minimum value is 0.001. -1 means no timeout.
-     * @return bool Returns true on success. Returns false on failure.
+     * @return int|false Returns the signal number received on success, or false on failure.
      * @alias Alias of method \Swoole\Coroutine\System::waitSignal().
      * @see \Swoole\Coroutine\System::waitSignal()
      * @since 4.5.0
      */
-    public static function waitSignal(int|array $signals, float $timeout = -1): bool
+    public static function waitSignal(int|array $signals, float $timeout = -1): int|false
     {
     }
 

src/swoole/Swoole/Coroutine/Channel.php

@@ -5,6 +5,7 @@
 namespace Swoole\Coroutine;
 
 /**
+ * @template TData
  * @not-serializable Objects of this class cannot be serialized.
  * @alias This class has two aliases: \chan and \Co\Channel (when directive "swoole.use_shortname" is not explicitly turned off).
  * @see \chan
@@ -45,7 +46,7 @@ public function __construct(int $size = 1)
     /**
      * Push an element into the channel.
      *
-     * @param mixed $data The element to be pushed into the channel. It's allowed to be any type of value. However, to avoid any confusion, it's recommended not to use empty values like 0, 0.0, false, ' ', null, etc.
+     * @param TData $data The element to be pushed into the channel. It's allowed to be any type of value. However, to avoid any confusion, it's recommended not to use empty values like 0, 0.0, false, ' ', null, etc.
      * @param float $timeout > 0 means waiting for the specified number of seconds. other means no waiting.
      * @return bool TRUE on success. If failed, return FALSE and set the error code ($this->errCode) with a non-zero value.
      */
@@ -59,7 +60,7 @@ public function push(mixed $data, float $timeout = -1): bool
      * This pop operation works in a FIFO (first-in-first-out) manner, since elements in the channel are stored in a queue but not a stack.
      *
      * @param float $timeout > 0 means waiting for the specified number of seconds. other means no waiting.
-     * @return mixed Remove an element from the front end of the channel, and return the element back. If failed, return FALSE and set the error code ($this->errCode) with a non-zero value.
+     * @return TData|false Remove an element from the front end of the channel, and return the element back. If failed, return FALSE and set the error code ($this->errCode) with a non-zero value.
      */
     public function pop(float $timeout = -1): mixed
     {

src/swoole/Swoole/Coroutine/Http/Server.php

@@ -42,7 +42,7 @@ public function set(array $settings): bool
      * @param string $pattern The URL pattern to match, e.g., "/index".
      * @param callable $callback The callback function to handle the HTTP request.
      * @return bool Return true on success. Return false on failure.
-     *              Before Swoole v6.0.0-rc1, it returns void.
+     *              Before Swoole v6.0.0, it returns void.
      */
     public function handle(string $pattern, callable $callback): bool
     {

src/swoole/Swoole/Coroutine/Lock.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Swoole\Coroutine;
+
+/**
+ * This Lock class provides a way to synchronize concurrent coroutines.
+ *
+ * @see \Swoole\Lock Use this instead when using locks accross processes.
+ * @since 6.0.1
+ */
+class Lock
+{
+    /**
+     * The error code of the last operation. It is set to 0 if the last operation was successful.
+     */
+    public int $errCode = 0;
+
+    /**
+     * @param bool $shared Use preserved shared memory of Swoole to create the lock or not.
+     */
+    public function __construct(bool $shared = false)
+    {
+    }
+
+    /**
+     * Lock the lock.
+     *
+     * If the lock is already acquired by another coroutine, this method will block until the lock is released.
+     *
+     * @return bool TRUE on success, FALSE on failure.
+     * @see Lock::trylock()
+     */
+    public function lock(): bool
+    {
+    }
+
+    /**
+     * Lock the lock in a non-blocking way.
+     *
+     * This method returns immediately even if the lock is not acquired. Thus, the caller should check the return value
+     * to see if the lock is acquired or not.
+     *
+     * @return bool TRUE on success, FALSE on failure.
+     * @see Lock::lock()
+     */
+    public function trylock(): bool
+    {
+    }
+
+    /**
+     * Unlock the lock.
+     *
+     * @return bool TRUE on success, FALSE on failure.
+     */
+    public function unlock(): bool
+    {
+    }
+}

src/swoole/Swoole/Coroutine/System.php

@@ -105,14 +105,14 @@ public static function waitPid(int $pid, float $timeout = -1): array|false
      * Wait for given signal(s) with a timeout.
      *
      * @param int|array<int> $signals An integer or an array of integers representing the signal number(s).
-     *                                Before Swoole v6.0.0-rc1, only integer is supported.
+     *                                Before Swoole v6.0.0, only integer is supported.
      * @param float $timeout The timeout value in seconds. Minimum value is 0.001. -1 means no timeout.
-     * @return bool Returns true on success. Returns false on failure.
+     * @return int|false Returns the signal number received on success, or false on failure.
      * @alias This method has an alias of \Swoole\Coroutine::waitSignal().
      * @see \Swoole\Coroutine::waitSignal()
      * @since 4.5.0
      */
-    public static function waitSignal(int|array $signals, float $timeout = -1): bool
+    public static function waitSignal(int|array $signals, float $timeout = -1): int|false
     {
     }
 

src/swoole/Swoole/Http/Request.php

@@ -19,7 +19,17 @@ class Request
 
     public $server;
 
-    public $cookie;
+    /**
+     * The cookies parsed from the request.
+     *
+     * It's null if option 'parse_cookie' is set to FALSE when creating the Request object. e.g.,
+     * ```php
+     * $request = Request::create(['parse_cookie' => false]);
+     * $request->parse($data);
+     * var_dump($request->cookie); // NULL
+     * ```
+     */
+    public ?array $cookie;
 
     public $get;
 
@@ -56,11 +66,27 @@ public function getData(): string|false
     {
     }
 
+    /**
+     * Create an HTTP request object.
+     *
+     * @param array $options The options for the Request object. Only the following options are supported:
+     *                       - 'parse_cookie' (boolean; default is TRUE): To parse the cookies or not.
+     *                       - 'parse_body' (boolean; default is TRUE): To parse the HTTP body or not.
+     *                       - 'parse_files' (boolean; default is TRUE): To parse the uploaded files or not.
+     *                       - 'upload_tmp_dir' (string; default is "/tmp"): The temporary directory to store the uploaded files.
+     *                       - 'enable_compression' (boolean; default is TRUE if Swoole is installed with zlib/Brotli/zstd, otherwise FALSE): To enable HTTP compression or not.
+     *                       - 'compression_level' (integer): Compression level. 1-9 are supported. The higher the level, the better the compression, but the more CPU it will consume. The default is 1.
+     *                       - 'websocket_compression' (boolean; default is TRUE if zlib extension is enabled, otherwise FALSE): To enable WebSocket compression or not. This is for WebSocket requests only.
+     * @since 4.6.0
+     */
     public static function create(array $options = []): Request
     {
     }
 
     /**
+     * Parse the raw HTTP request data.
+     *
+     * @return int|false Return the parsed length of the data; return FALSE when error happens.
      * @since 4.6.0
      */
     public function parse(string $data): int|false

src/swoole/Swoole/Http/Response.php

@@ -250,6 +250,18 @@ public function push(Frame|string $data, int $opcode = SWOOLE_WEBSOCKET_OPCODE_T
     {
     }
 
+    /**
+     * Receive data from the attached WebSocket connection.
+     *
+     * @param float $timeout Timeout in seconds. -1 means never timeout; 0 means to use the default value of option "socket_read_timeout".
+     * @return Frame|string|false
+     *                            Returns a \Swoole\WebSocket\Frame object when succeeds.
+     *                            Returns an empty string when the HTTP connection is closed.
+     *                            Returns FALSE when error happens. Use method \swoole_last_error() to get error code.
+     * @see \Swoole\Constant::OPTION_SOCKET_READ_TIMEOUT
+     * @see \Swoole\WebSocket\Frame
+     * @see \swoole_last_error()
+     */
     public function recv(float $timeout = 0): Frame|string|false
     {
     }

src/swoole/Swoole/Lock.php

@@ -14,8 +14,9 @@
  * cause memory leaks since memory usage could keep increasing as new requests keep coming in. In general, it's not
  * recommended to keep creating/destroying locks since this could cause memory leaks.
  *
- * Locks should not be used in coroutines, especially when there are coroutine switching between method calls to
- * \Swoole\Lock::lock() and \Swoole\Lock::unlock(). For example, the following example will cause deadlock:
+ * This Lock class is not coroutine-friendly. It should not be used across different coroutines, especially when there
+ * are coroutine switching between method calls to \Swoole\Lock::lock() and \Swoole\Lock::unlock(). For example, the
+ * following example will cause deadlock:
  *
  *   Swoole\Coroutine\run(function () {
  *       $lock = new Swoole\Lock();
@@ -28,8 +29,12 @@
  *       }
  *   });
  *
- * If you think you need to use locks with coroutines, you can probably use channels instead.
+ * If you think you need to use locks with coroutines, there are two options:
+ * 1. use channels instead (before Swoole 6.0.1).
+ * 2. use class \Swoole\Coroutine\Lock instead (since Swoole 6.0.1).
  *
+ * @see \Swoole\Thread\Lock Use this instead when PHP is compiled with Zend Thread Safety (ZTS) enabled.
+ * @see \Swoole\Coroutine\Lock Use this instead when using locks accross coroutines.
  * @see https://github.com/deminy/swoole-by-examples/blob/master/examples/csp/deadlocks/swoole-lock.php
  * @not-serializable Objects of this class cannot be serialized.
  */
@@ -158,13 +163,4 @@ public function trylock_read(): bool
     public function unlock(): bool
     {
     }
-
-    /**
-     * Destroy the lock and release any resources used by the lock.
-     *
-     * After calling this method, the lock object should not be used anymore.
-     */
-    public function destroy(): void
-    {
-    }
 }