Merge branch 'develop'

Baptouuuu · Baptouuuu · commit b2be414351c5 · 2024-11-11T11:33:24.000+01:00
* develop:
  specify next release
  fix psalm losing types of contraints when composing them
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.6.1 - 2024-11-11
+
+### Fixed
+
+- Psalm losing the types of contraints when composing them via `and`, `or`, `map` and `asPredicate`
+
 ## 1.6.0 - 2024-11-11
 
 ### Added
diff --git a/src/AndConstraint.php b/src/AndConstraint.php
@@ -56,21 +56,45 @@ public static function of(Constraint $a, Constraint $b): self
         return new self($a, $b);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<C, T> $constraint
+     *
+     * @return self<A, C, T>
+     */
     public function and(Constraint $constraint): self
     {
         return new self($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<A, T> $constraint
+     *
+     * @return Constraint<A, C|T>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param pure-callable(C): T $map
+     *
+     * @return Constraint<A, T>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<C>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/AssociativeArray.php b/src/AssociativeArray.php
@@ -46,21 +46,45 @@ public static function of(Constraint $key, Constraint $value): self
         return new self($key, $value);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<Map<K, V>, T> $constraint
+     *
+     * @return Constraint<mixed, T>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<mixed, T> $constraint
+     *
+     * @return Constraint<mixed, Map<K, V>|T>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param pure-callable(Map<K, V>): T $map
+     *
+     * @return Constraint<mixed, T>
+     */
     public function map(callable $map): Constraint
     {
         return namespace\Map::of($this, $map);
     }
 
+    /**
+     * @return Predicate<Map<K, V>>
+     */
     public function asPredicate(): Predicate
     {
         return namespace\Predicate::of($this);
diff --git a/src/Each.php b/src/Each.php
@@ -56,21 +56,45 @@ public static function of(Constraint $constraint): self
         return new self($constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<list<T>, V> $constraint
+     *
+     * @return Constraint<list, V>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<list, V> $constraint
+     *
+     * @return Constraint<list, list<T>|V>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param pure-callable(list<T>): V $map
+     *
+     * @return Constraint<list, V>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<list<T>>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/Has.php b/src/Has.php
@@ -63,21 +63,45 @@ public function withFailure(callable $message): self
         return new self($this->key, $message);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<mixed, T> $constraint
+     *
+     * @return Constraint<array, T>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<array, T> $constraint
+     *
+     * @return Constraint<array, mixed|T>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param pure-callable(mixed): T $map
+     *
+     * @return Constraint<array, T>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<mixed>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/Instance.php b/src/Instance.php
@@ -52,21 +52,45 @@ public static function of(string $class): self
         return new self(Predicate\Instance::of($class), $class);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<T, V> $constraint
+     *
+     * @return Constraint<mixed, V>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<mixed, V> $constraint
+     *
+     * @return Constraint<mixed, T|V>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param pure-callable(T): V $map
+     *
+     * @return Constraint<mixed, V>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return Predicate<T>
+     */
     public function asPredicate(): Predicate
     {
         return $this->assert;
diff --git a/src/Is.php b/src/Is.php
@@ -192,21 +192,45 @@ public function withFailure(string $message): self
         return new self($this->assert, $this->type, $message);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<U, V> $constraint
+     *
+     * @return Constraint<T, V>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<T, V> $constraint
+     *
+     * @return Constraint<T, U|V>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param pure-callable(U): V $map
+     *
+     * @return Constraint<T, V>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<U>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/Map.php b/src/Map.php
@@ -53,21 +53,45 @@ public static function of(Constraint $constraint, callable $map): self
         return new self($constraint, $map);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<T, V> $constraint
+     *
+     * @return Constraint<I, V>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param Constraint<I, V> $constraint
+     *
+     * @return Constraint<I, T|V>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template V
+     *
+     * @param pure-callable(T): V $map
+     *
+     * @return self<I, T, V>
+     */
     public function map(callable $map): self
     {
         return new self($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<T>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/Of.php b/src/Of.php
@@ -46,21 +46,45 @@ public static function callable(callable $assert): self
         return new self($assert);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<B, T> $constraint
+     *
+     * @return Constraint<A, T>
+     */
     public function and(Constraint $constraint): Constraint
     {
         return AndConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param Constraint<A, T> $constraint
+     *
+     * @return Constraint<A, B|T>
+     */
     public function or(Constraint $constraint): Constraint
     {
         return OrConstraint::of($this, $constraint);
     }
 
+    /**
+     * @template T
+     *
+     * @param pure-callable(B): T $map
+     *
+     * @return Constraint<A, T>
+     */
     public function map(callable $map): Constraint
     {
         return Map::of($this, $map);
     }
 
+    /**
+     * @return PredicateInterface<B>
+     */
     public function asPredicate(): PredicateInterface
     {
         return Predicate::of($this);
diff --git a/src/OrConstraint.php b/src/OrConstraint.php
diff --git a/src/PointInTime.php b/src/PointInTime.php
diff --git a/src/Shape.php b/src/Shape.php

Original file line number	Diff line number	Diff line change
`@@ -56,21 +56,45 @@ public static function of(Constraint $a, Constraint $b): self`
`56`	`56`	`return new self($a, $b);`
`57`	`57`	`}`
`58`	`58`
	`59`	`+ /**`
	`60`	`+ * @template T`
	`61`	`+ *`
	`62`	`+ * @param Constraint<C, T> $constraint`
	`63`	`+ *`
	`64`	`+ * @return self<A, C, T>`
	`65`	`+ */`
`59`	`66`	`public function and(Constraint $constraint): self`
`60`	`67`	`{`
`61`	`68`	`return new self($this, $constraint);`
`62`	`69`	`}`
`63`	`70`
	`71`	`+ /**`
	`72`	`+ * @template T`
	`73`	`+ *`
	`74`	`+ * @param Constraint<A, T> $constraint`
	`75`	`+ *`
	`76`	`+ * @return Constraint<A, C\|T>`
	`77`	`+ */`
`64`	`78`	`public function or(Constraint $constraint): Constraint`
`65`	`79`	`{`
`66`	`80`	`return OrConstraint::of($this, $constraint);`
`67`	`81`	`}`
`68`	`82`
	`83`	`+ /**`
	`84`	`+ * @template T`
	`85`	`+ *`
	`86`	`+ * @param pure-callable(C): T $map`
	`87`	`+ *`
	`88`	`+ * @return Constraint<A, T>`
	`89`	`+ */`
`69`	`90`	`public function map(callable $map): Constraint`
`70`	`91`	`{`
`71`	`92`	`return Map::of($this, $map);`
`72`	`93`	`}`
`73`	`94`
	`95`	`+ /**`
	`96`	`+ * @return PredicateInterface<C>`
	`97`	`+ */`
`74`	`98`	`public function asPredicate(): PredicateInterface`
`75`	`99`	`{`
`76`	`100`	`return Predicate::of($this);`
Original file line number	Diff line number	Diff line change
`@@ -46,21 +46,45 @@ public static function of(Constraint $key, Constraint $value): self`
`46`	`46`	`return new self($key, $value);`
`47`	`47`	`}`
`48`	`48`
	`49`	`+ /**`
	`50`	`+ * @template T`
	`51`	`+ *`
	`52`	`+ * @param Constraint<Map<K, V>, T> $constraint`
	`53`	`+ *`
	`54`	`+ * @return Constraint<mixed, T>`
	`55`	`+ */`
`49`	`56`	`public function and(Constraint $constraint): Constraint`
`50`	`57`	`{`
`51`	`58`	`return AndConstraint::of($this, $constraint);`
`52`	`59`	`}`
`53`	`60`
	`61`	`+ /**`
	`62`	`+ * @template T`
	`63`	`+ *`
	`64`	`+ * @param Constraint<mixed, T> $constraint`
	`65`	`+ *`
	`66`	`+ * @return Constraint<mixed, Map<K, V>\|T>`
	`67`	`+ */`
`54`	`68`	`public function or(Constraint $constraint): Constraint`
`55`	`69`	`{`
`56`	`70`	`return OrConstraint::of($this, $constraint);`
`57`	`71`	`}`
`58`	`72`
	`73`	`+ /**`
	`74`	`+ * @template T`
	`75`	`+ *`
	`76`	`+ * @param pure-callable(Map<K, V>): T $map`
	`77`	`+ *`
	`78`	`+ * @return Constraint<mixed, T>`
	`79`	`+ */`
`59`	`80`	`public function map(callable $map): Constraint`
`60`	`81`	`{`
`61`	`82`	`return namespace\Map::of($this, $map);`
`62`	`83`	`}`
`63`	`84`
	`85`	`+ /**`
	`86`	`+ * @return Predicate<Map<K, V>>`
	`87`	`+ */`
`64`	`88`	`public function asPredicate(): Predicate`
`65`	`89`	`{`
`66`	`90`	`return namespace\Predicate::of($this);`
Original file line number	Diff line number	Diff line change
`@@ -63,21 +63,45 @@ public function withFailure(callable $message): self`
`63`	`63`	`return new self($this->key, $message);`
`64`	`64`	`}`
`65`	`65`
	`66`	`+ /**`
	`67`	`+ * @template T`
	`68`	`+ *`
	`69`	`+ * @param Constraint<mixed, T> $constraint`
	`70`	`+ *`
	`71`	`+ * @return Constraint<array, T>`
	`72`	`+ */`
`66`	`73`	`public function and(Constraint $constraint): Constraint`
`67`	`74`	`{`
`68`	`75`	`return AndConstraint::of($this, $constraint);`
`69`	`76`	`}`
`70`	`77`
	`78`	`+ /**`
	`79`	`+ * @template T`
	`80`	`+ *`
	`81`	`+ * @param Constraint<array, T> $constraint`
	`82`	`+ *`
	`83`	`+ * @return Constraint<array, mixed\|T>`
	`84`	`+ */`
`71`	`85`	`public function or(Constraint $constraint): Constraint`
`72`	`86`	`{`
`73`	`87`	`return OrConstraint::of($this, $constraint);`
`74`	`88`	`}`
`75`	`89`
	`90`	`+ /**`
	`91`	`+ * @template T`
	`92`	`+ *`
	`93`	`+ * @param pure-callable(mixed): T $map`
	`94`	`+ *`
	`95`	`+ * @return Constraint<array, T>`
	`96`	`+ */`
`76`	`97`	`public function map(callable $map): Constraint`
`77`	`98`	`{`
`78`	`99`	`return Map::of($this, $map);`
`79`	`100`	`}`
`80`	`101`
	`102`	`+ /**`
	`103`	`+ * @return PredicateInterface<mixed>`
	`104`	`+ */`
`81`	`105`	`public function asPredicate(): PredicateInterface`
`82`	`106`	`{`
`83`	`107`	`return Predicate::of($this);`
Original file line number	Diff line number	Diff line change
`@@ -52,21 +52,45 @@ public static function of(string $class): self`
`52`	`52`	`return new self(Predicate\Instance::of($class), $class);`
`53`	`53`	`}`
`54`	`54`
	`55`	`+ /**`
	`56`	`+ * @template V`
	`57`	`+ *`
	`58`	`+ * @param Constraint<T, V> $constraint`
	`59`	`+ *`
	`60`	`+ * @return Constraint<mixed, V>`
	`61`	`+ */`
`55`	`62`	`public function and(Constraint $constraint): Constraint`
`56`	`63`	`{`
`57`	`64`	`return AndConstraint::of($this, $constraint);`
`58`	`65`	`}`
`59`	`66`
	`67`	`+ /**`
	`68`	`+ * @template V`
	`69`	`+ *`
	`70`	`+ * @param Constraint<mixed, V> $constraint`
	`71`	`+ *`
	`72`	`+ * @return Constraint<mixed, T\|V>`
	`73`	`+ */`
`60`	`74`	`public function or(Constraint $constraint): Constraint`
`61`	`75`	`{`
`62`	`76`	`return OrConstraint::of($this, $constraint);`
`63`	`77`	`}`
`64`	`78`
	`79`	`+ /**`
	`80`	`+ * @template V`
	`81`	`+ *`
	`82`	`+ * @param pure-callable(T): V $map`
	`83`	`+ *`
	`84`	`+ * @return Constraint<mixed, V>`
	`85`	`+ */`
`65`	`86`	`public function map(callable $map): Constraint`
`66`	`87`	`{`
`67`	`88`	`return Map::of($this, $map);`
`68`	`89`	`}`
`69`	`90`
	`91`	`+ /**`
	`92`	`+ * @return Predicate<T>`
	`93`	`+ */`
`70`	`94`	`public function asPredicate(): Predicate`
`71`	`95`	`{`
`72`	`96`	`return $this->assert;`
Original file line number	Diff line number	Diff line change
`@@ -192,21 +192,45 @@ public function withFailure(string $message): self`
`192`	`192`	`return new self($this->assert, $this->type, $message);`
`193`	`193`	`}`
`194`	`194`
	`195`	`+ /**`
	`196`	`+ * @template V`
	`197`	`+ *`
	`198`	`+ * @param Constraint<U, V> $constraint`
	`199`	`+ *`
	`200`	`+ * @return Constraint<T, V>`
	`201`	`+ */`
`195`	`202`	`public function and(Constraint $constraint): Constraint`
`196`	`203`	`{`
`197`	`204`	`return AndConstraint::of($this, $constraint);`
`198`	`205`	`}`
`199`	`206`
	`207`	`+ /**`
	`208`	`+ * @template V`
	`209`	`+ *`
	`210`	`+ * @param Constraint<T, V> $constraint`
	`211`	`+ *`
	`212`	`+ * @return Constraint<T, U\|V>`
	`213`	`+ */`
`200`	`214`	`public function or(Constraint $constraint): Constraint`
`201`	`215`	`{`
`202`	`216`	`return OrConstraint::of($this, $constraint);`
`203`	`217`	`}`
`204`	`218`
	`219`	`+ /**`
	`220`	`+ * @template V`
	`221`	`+ *`
	`222`	`+ * @param pure-callable(U): V $map`
	`223`	`+ *`
	`224`	`+ * @return Constraint<T, V>`
	`225`	`+ */`
`205`	`226`	`public function map(callable $map): Constraint`
`206`	`227`	`{`
`207`	`228`	`return Map::of($this, $map);`
`208`	`229`	`}`
`209`	`230`
	`231`	`+ /**`
	`232`	`+ * @return PredicateInterface<U>`
	`233`	`+ */`
`210`	`234`	`public function asPredicate(): PredicateInterface`
`211`	`235`	`{`
`212`	`236`	`return Predicate::of($this);`
Original file line number	Diff line number	Diff line change
`@@ -53,21 +53,45 @@ public static function of(Constraint $constraint, callable $map): self`
`53`	`53`	`return new self($constraint, $map);`
`54`	`54`	`}`
`55`	`55`
	`56`	`+ /**`
	`57`	`+ * @template V`
	`58`	`+ *`
	`59`	`+ * @param Constraint<T, V> $constraint`
	`60`	`+ *`
	`61`	`+ * @return Constraint<I, V>`
	`62`	`+ */`
`56`	`63`	`public function and(Constraint $constraint): Constraint`
`57`	`64`	`{`
`58`	`65`	`return AndConstraint::of($this, $constraint);`
`59`	`66`	`}`
`60`	`67`
	`68`	`+ /**`
	`69`	`+ * @template V`
	`70`	`+ *`
	`71`	`+ * @param Constraint<I, V> $constraint`
	`72`	`+ *`
	`73`	`+ * @return Constraint<I, T\|V>`
	`74`	`+ */`
`61`	`75`	`public function or(Constraint $constraint): Constraint`
`62`	`76`	`{`
`63`	`77`	`return OrConstraint::of($this, $constraint);`
`64`	`78`	`}`
`65`	`79`
	`80`	`+ /**`
	`81`	`+ * @template V`
	`82`	`+ *`
	`83`	`+ * @param pure-callable(T): V $map`
	`84`	`+ *`
	`85`	`+ * @return self<I, T, V>`
	`86`	`+ */`
`66`	`87`	`public function map(callable $map): self`
`67`	`88`	`{`
`68`	`89`	`return new self($this, $map);`
`69`	`90`	`}`
`70`	`91`
	`92`	`+ /**`
	`93`	`+ * @return PredicateInterface<T>`
	`94`	`+ */`
`71`	`95`	`public function asPredicate(): PredicateInterface`
`72`	`96`	`{`
`73`	`97`	`return Predicate::of($this);`