Overload resolution picks wrong initializer for some metatype arguments

[clackary]

Description

We noticed a regression (or a change in behavior at the very least) when using metatype arguments.

When two initializers differ only by (a) accepting Any.Type vs Any, and (b) sharing the same external label (of:), calls that pass metatype arguments like Int.self or Any.self sometimes resolve to the instance-taking overload instead of the metatype-taking overload. This produces unexpected stored types (Int.Type, Any.Protocol) and ends up breaking code that relies on equality checks that should otherwise succeed.

The included reproducer uses Any and Int examples, which do reproduce the bug. It also includes an example using String which does not reproduce the bug, so only happens with some types.

Reproduction

1. Create a single file type-resolution-repro.swift with the following code...

import Foundation

struct Wrapper {
    struct Store: Equatable, CustomStringConvertible {
        let theType: Any.Type

        // Labeled initializers
        init(of theType: Any.Type) { self.theType = theType }
        init(of instance: Any)     { self.init(of: type(of: instance)) }

        // Unlabeled initializers
        init(_ theType: Any.Type)  { self.theType = theType }
        init(_ instance: Any)      { self.init(type(of: instance)) }

        static func == (lhs: Self, rhs: Self) -> Bool { lhs.theType == rhs.theType }

        var description: String { "Store(\(String(reflecting: theType)))" }
    }

    let store: Store

    init(_ theType: Any.Type) {
        self.store = .init(of: theType)
    }
}

func check<T: Equatable & CustomStringConvertible>(_ a: T, _ b: T, _ label: String) {
    print("\(label): \(a) == \(b)  →  \(a == b ? "✅ true" : "❌ false")")
}

check(Wrapper(Any.self).store, .init(of: Any.self), "Any.self vs .init(of: Any.self) (labeled)")
check(Wrapper(Any.self).store, .init(Any.self),     "Any.self vs .init(Any.self) (unlabeled)")

check(Wrapper(Int.self).store, .init(of: Int.self), "Int.self vs .init(of: Int.self) (labeled)")
check(Wrapper(Int.self).store, .init(Int.self),     "Int.self vs .init(Int.self) (unlabeled)")

check(Wrapper(String.self).store, .init(of: "hello"), "String.self vs .init(of: \"hello\") (labeled)")
check(Wrapper(String.self).store, .init("hello"),     "String.self vs .init(\"hello\") (unlabeled)")

2. Run with swift type-resolution-repro.swift

Expected behavior

Actual behavior against Swift 6.2...

Any.self vs .init(of: Any.self) (labeled): Store(Any) == Store(Any)  →  ✅ true
Any.self vs .init(Any.self) (unlabeled): Store(Any) == Store(Any)  →  ✅ true
Int.self vs .init(of: Int.self) (labeled): Store(Swift.Int) == Store(Swift.Int)  →  ✅ true
Int.self vs .init(Int.self) (unlabeled): Store(Swift.Int) == Store(Swift.Int)  →  ✅ true
String.self vs .init(of: "hello") (labeled): Store(Swift.String) == Store(Swift.String)  →  ✅ true
String.self vs .init("hello") (unlabeled): Store(Swift.String) == Store(Swift.String)  →  ✅ true

The expected behavior against main-snapshots is that it matches the 6.2 behavior.

The actual behavior against nightly main-snapshots...

Any.self vs .init(of: Any.self) (labeled): Store(Any) == Store(Any.Protocol)  →  ❌ false
Any.self vs .init(Any.self) (unlabeled): Store(Any) == Store(Any)  →  ✅ true
Int.self vs .init(of: Int.self) (labeled): Store(Swift.Int) == Store(Swift.Int.Type)  →  ❌ false
Int.self vs .init(Int.self) (unlabeled): Store(Swift.Int) == Store(Swift.Int)  →  ✅ true
String.self vs .init(of: "hello") (labeled): Store(Swift.String) == Store(Swift.String)  →  ✅ true
String.self vs .init("hello") (unlabeled): Store(Swift.String) == Store(Swift.String)  →  ✅ true

Environment

This reproduces on macOS and linux.

Additional information

This seems to be a regression that first landed in the main-snapshot-2025-08-16 nightly toolchain. The latest known-good toolchain was main-snapshot-2025-08-14.

[clackary]

This seems possibly related to the type checker -- cc @xedin @hborla

[clackary]

This seems to be introduced by c46f9e4

I built a copy of the 2025-10-16 toolchain with that commit reverted, and the behavior returns to the 'normal' 6.2 behavior.

[clackary]

Took another look at this, and have a simpler reproducer...

struct Store {
    let theType: Any.Type

    init(of theType: Any.Type) {
        print("init from TYPE : \(theType)\n")
        self.theType = theType
    }

    init(of instance: Any) {
        print("init from VALUE : \(instance)")
        self.init(of: type(of: instance))
    }
}

let a: (any Numeric)? = 42
print("a: \(type(of: a))")
let storeA = Store(of: a!)

let b: (any Numeric.Type)? = type(of: 42)
print("b: \(type(of: b))")
let storeB = Store(of: b!)

if let c = b {
    print("c: \(type(of: c))")
    _ = Store(of: c)
}

Running against the 6.2.1 release...

➜  swiftly run swift /tmp/abc.swift +6.2.1        
a: Optional<Numeric>
init from VALUE : 42
init from TYPE : Int

b: Optional<Numeric.Type>
init from TYPE : Int

c: Int.Type
init from TYPE : Int

Running against a recent main snapshot...

➜  swiftly run swift /tmp/abc.swift +main-snapshot            
a: Optional<Numeric>
init from VALUE : 42
init from TYPE : Int

b: Optional<Numeric.Type>
init from VALUE : Int
init from TYPE : Int.Type

c: Int.Type
init from VALUE : Int
init from TYPE : Int.Type