Merge pull request #7 from Innmind/fix-transitions

Fix Psalm losing types of contraints when composing them
Innmind · Nov 11, 2024 · 900f290 · 900f290
2 parents 129ddec + 9fcb55c
commit 900f290
Show file tree

Hide file tree

Showing 12 changed files with 270 additions and 0 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## [Unreleased]
+
+### 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);