Let a callable union member take the callable argument it accepts before it can flow into a naked template argument marker

src/Analyser/Generics/TemplateArgumentObserver.php

@@ -630,6 +630,15 @@
 						}
 						continue;
 					}
+					// a callable member says nothing flows into its markers, but
+					// it still takes the callable it accepts: (callable(T): bool)|T
+					// receiving a closure does not bind T to the closure
+					if ($member->isCallable()->yes()) {
+						if ($member->isSuperTypeOf($argumentMember)->yes()) {
+							$taken = true;
+						}
+						continue;
+					}
 					$before = $constraints;
 					$constraints = $this->observeLowerBound($constraints, $member, $argumentMember);
 					if ($constraints === $before) {

tests/PHPStan/Analyser/nsrt/bug-15414.php

@@ -0,0 +1,112 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug15414;
+
+use Closure;
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template TValue
+ * @implements \IteratorAggregate<int, TValue>
+ */
+final class Coll implements \IteratorAggregate
+{
+	/** @param list<TValue> $items */
+	public function __construct(private array $items = [])
+	{
+	}
+
+	/** @return \ArrayIterator<int, TValue> */
+	#[\Override]
+	public function getIterator(): \ArrayIterator
+	{
+		return new \ArrayIterator($this->items);
+	}
+
+	/**
+	 * @template TMergeValue
+	 * @param iterable<TMergeValue> $items
+	 * @return Coll<TValue|TMergeValue>
+	 */
+	public function merge(iterable $items): Coll
+	{
+		return new Coll();
+	}
+
+	/**
+	 * @param (callable(TValue): bool)|TValue $callback
+	 * @return Coll<TValue>
+	 */
+	public function reject($callback): Coll
+	{
+		return $this;
+	}
+
+	/**
+	 * @param (Closure(TValue): bool)|TValue $callback
+	 * @return Coll<TValue>
+	 */
+	public function rejectClosure($callback): Coll
+	{
+		return $this;
+	}
+}
+
+final class Field
+{
+	public bool $hidden = false;
+
+	public function isHidden(Field $field): bool
+	{
+		return $field->hidden;
+	}
+
+	public static function isHiddenStatic(Field $field): bool
+	{
+		return $field->hidden;
+	}
+}
+
+final class FieldFilter
+{
+	public function __invoke(Field $field): bool
+	{
+		return $field->hidden;
+	}
+}
+
+function isExcluded(Field $field): bool
+{
+	return $field->hidden;
+}
+
+/**
+ * @param Coll<Field> $a
+ * @param Coll<Field> $b
+ */
+function test(Coll $a, Coll $b, Field $f, FieldFilter $filter): void
+{
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject(isExcluded(...)));
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject(static fn (Field $f): bool => isExcluded($f)));
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->reject(isExcluded(...)));
+
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject($f->isHidden(...)));
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject(Field::isHiddenStatic(...)));
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject(static function (Field $f): bool {
+		return isExcluded($f);
+	}));
+
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->rejectClosure(isExcluded(...)));
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->rejectClosure(static fn (Field $f): bool => isExcluded($f)));
+
+	assertType('Bug15414\Coll<Bug15414\Field>', $a->merge($b)->reject($filter));
+}
+
+function testEmpty(Field $f): void
+{
+	$c = new Coll();
+	$c = $c->merge([$f])->reject(isExcluded(...));
+	assertType('Bug15414\Coll<Bug15414\Field>', $c);
+}

turbo-ext/src/TemplateArgumentObserver.cpp

@@ -989,6 +989,16 @@ class TemplateArgumentObserver
 						if (verdict == PT_TRI_YES) taken = true;
 						continue;
 					}
+					zend_long memberCallable = pt_type_op_trinary(Z_OBJ_P(member), PT_OP_IS_CALLABLE, 0, NULL);
+					if (UNEXPECTED(memberCallable < 0)) return zv::Val();
+					if (memberCallable == PT_TRI_YES) {
+						zv::Val superType = pt_type_op(Z_OBJ_P(member), PT_OP_IS_SUPER_TYPE_OF, 1, argumentMember);
+						if (UNEXPECTED(superType.isUndef())) return zv::Val();
+						zend_long verdict = pt_type_result_trinary(superType.raw());
+						if (UNEXPECTED(verdict < 0)) return zv::Val();
+						if (verdict == PT_TRI_YES) taken = true;
+						continue;
+					}
 					zv::Val before = zv::Val::copyOf(zv::Ref(constraints.raw()));
 					constraints = observeLowerBound(std::move(constraints), member, argumentMember);
 					if (UNEXPECTED(constraints.isUndef())) return zv::Val();