Merge branch '7.4' into 8.0

* 7.4: (40 commits)
  [PropertyInfo] treat mixed[] the same as array when getting types from docblocks
  treat `mixed[]` the same as `array` when getting types from docblocks
  install ext-zstd on PHP 8.5 as well
  fix merge
  [Console] Fix profile invokable command
  sync ControllerHelper docblock with latest AbstractController changes
  fix: Typehint for `createForm` in abstractController
  [Notifier][Mercure] Add support for Mercure 0.7
  register attribute loader arguments in a forward-compatible way
  ensure compatibility with RelayCluster 0.20.0
  mark test using a Redis connection as an integration test
  ensure compatibility with Relay extension 0.20.0
  [FrameworkBundle] Allow backed enum to be used in initial_marking workflow configuration
  [DependencyInjection] Fix `query_string` env processor for URLs without query string
  [HttpFoundation] Fix Expires response header for EventStream
  Bump Symfony version to 7.4.1
  Update VERSION for 7.4.0
  Update CHANGELOG for 7.4.0
  -
  [DependencyInjection] Fix state corruption in PhpFileLoader during recursive imports
  ...

Author: xabbuh

Tests/UnicodeStringTest.php

@@ -11,11 +11,58 @@
 
 namespace Symfony\Component\String\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Symfony\Component\String\AbstractString;
 use Symfony\Component\String\UnicodeString;
 
 class UnicodeStringTest extends AbstractUnicodeTestCase
 {
+    #[DataProvider('provideTrimNormalization')]
+    public function testTrimPrefixNormalization(string $expected, string $string, $prefix)
+    {
+        $str = new UnicodeString($string);
+        $this->assertSame($expected, $str->trimPrefix($prefix)->toString());
+    }
+
+    #[DataProvider('provideTrimNormalization')]
+    public function testTrimSuffixNormalization(string $expected, string $string, $suffix)
+    {
+        $suffixStr = match (true) {
+            $suffix instanceof AbstractString => $suffix->toString(),
+            \is_array($suffix) => implode('', $suffix),
+            $suffix instanceof \Traversable => implode('', iterator_to_array($suffix)),
+            default => (string) $suffix,
+        };
+
+        $str = new UnicodeString($expected.$suffixStr);
+        $this->assertSame($expected, $str->trimSuffix($suffix)->toString());
+    }
+
+    public static function provideTrimNormalization(): iterable
+    {
+        // "é" in NFC (\xC3\xA9) vs NFD (\x65\xCC\x81)
+        $nfc = "\xC3\xA9";
+        $nfd = "\x65\xCC\x81";
+
+        yield 'nfc_string_nfd_prefix' => ['abc', $nfc.'abc', $nfd];
+        yield 'nfd_string_nfc_prefix' => ['abc', $nfd.'abc', $nfc];
+
+        yield 'abstract_string' => ['abc', $nfc.'abc', new UnicodeString($nfd)];
+
+        yield 'array' => ['abc', $nfc.'abc', [$nfd]];
+
+        yield 'stringable' => ['abc', $nfc.'abc', new class($nfd) implements \Stringable {
+            public function __construct(private string $s)
+            {
+            }
+
+            public function __toString(): string
+            {
+                return $this->s;
+            }
+        }];
+    }
+
     protected static function createFromString(string $string): AbstractString
     {
         return new UnicodeString($string);

UnicodeString.php

@@ -366,6 +366,44 @@ public function startsWith(string|iterable|AbstractString $prefix): bool
         return $prefix === $grapheme;
     }
 
+    public function trimPrefix($prefix): static
+    {
+        if (\is_array($prefix) || $prefix instanceof \Traversable) {
+            return parent::trimPrefix($prefix);
+        }
+
+        if ($prefix instanceof AbstractString) {
+            $prefix = $prefix->string;
+        } else {
+            $prefix = (string) $prefix;
+        }
+
+        if (!normalizer_is_normalized($prefix, \Normalizer::NFC)) {
+            $prefix = normalizer_normalize($prefix, \Normalizer::NFC);
+        }
+
+        return parent::trimPrefix($prefix);
+    }
+
+    public function trimSuffix($suffix): static
+    {
+        if (\is_array($suffix) || $suffix instanceof \Traversable) {
+            return parent::trimSuffix($suffix);
+        }
+
+        if ($suffix instanceof AbstractString) {
+            $suffix = $suffix->string;
+        } else {
+            $suffix = (string) $suffix;
+        }
+
+        if (!normalizer_is_normalized($suffix, \Normalizer::NFC)) {
+            $suffix = normalizer_normalize($suffix, \Normalizer::NFC);
+        }
+
+        return parent::trimSuffix($suffix);
+    }
+
     public function __unserialize(array $data): void
     {
         $this->string = $data['string'] ?? $data["\0*\0string"];