Do not type callable parameters from closure arguments

internal/aggregate/aggregate.go

@@ -66,6 +66,12 @@ func resolveGroups(groups map[string]map[string]struct{}) map[string]Resolved {
 		}
 		sort.Strings(types)
 
+		// a callable argument (a closure) leaves the parameter untyped, since a
+		// callable can take many shapes that must not be narrowed
+		if contains(types, "callable") {
+			continue
+		}
+
 		nullable := contains(types, "null")
 		members := without(types, "null")
 		if len(members) == 0 {

internal/apply/apply_test.go

@@ -163,20 +163,28 @@ func TestApply(t *testing.T) {
 			want:   "<?php\nfunction take(array $items = []) {}",
 		},
 		{
-			name:   "types closure argument",
+			name:   "leaves a closure argument untyped",
 			target: "<?php\nfunction run($cb) {}",
 			callers: []string{
 				"<?php\nrun(function () {});",
 			},
-			want: "<?php\nfunction run(\\Closure $cb) {}",
+			want: "<?php\nfunction run($cb) {}",
 		},
 		{
-			name:   "types arrow function argument",
+			name:   "leaves an arrow function argument untyped",
 			target: "<?php\nfunction run($cb) {}",
 			callers: []string{
 				"<?php\nrun(fn () => 1);",
 			},
-			want: "<?php\nfunction run(\\Closure $cb) {}",
+			want: "<?php\nfunction run($cb) {}",
+		},
+		{
+			name:   "a closure poisons the parameter even with another type",
+			target: "<?php\nfunction run($cb) {}",
+			callers: []string{
+				"<?php\nrun(function () {});\nrun(1);",
+			},
+			want: "<?php\nfunction run($cb) {}",
 		},
 		{
 			name:   "types from builtin return value",

internal/valuetype/valuetype.go

@@ -25,7 +25,11 @@ func Of(expr ast.Vertex) string {
 	case *ast.ExprArray:
 		return "array"
 	case *ast.ExprClosure, *ast.ExprArrowFunction:
-		return "object:Closure"
+		// a closure argument means the parameter takes a callable, which can be
+		// many things (a closure, a "func" string, a [$obj, method] array, a
+		// first-class callable). "callable" is a poison type: it is never
+		// written, and it stops the parameter from being typed at all.
+		return "callable"
 	case *ast.ExprUnaryMinus:
 		return numericType(typed.Expr)
 	case *ast.ExprUnaryPlus:

internal/valuetype/valuetype_test.go

@@ -21,8 +21,8 @@ func TestOf(t *testing.T) {
 		{"true", "true", "bool"},
 		{"null", "null", "null"},
 		{"negative int", "-3", "int"},
-		{"closure", "function () {}", "object:Closure"},
-		{"arrow function", "fn () => 1", "object:Closure"},
+		{"closure", "function () {}", "callable"},
+		{"arrow function", "fn () => 1", "callable"},
 		{"class name fetch", "Foo::class", "string"},
 		{"new object", "new Money()", "object:Money"},
 		{"builtin int return", "strlen($x)", "int"},