Associatedtype not inferred?

Using Swift
1

On Xcode13beta3, BigSur 11.5:

protocol MyProtocol {
    associatedtype T: SignedNumeric & Comparable
    
    var prop: T { get }
    func myMax(x: T, y: T) -> T
    func myAbs(x: T) -> T
}

struct MyStruct: MyProtocol {    
    var prop: Int
    func myMax(x: T, y: T) -> T { x < y ? y : x }
    func myAbs(x: T) -> T { x < 0 ? -x : x }
}

for myAbs(x:) Xcode first complains of the return T, "Reference to invalid associated type 'T' of type 'MyStruct'". If I change the return T to Int and cast the return value to Int, then it makes the same complain about the parameter type T.

Two workarounds:

  1. Change both Ts in myAbs(x:) to Int:
struct MyStruct: MyProtocol {    
    var prop: Int
    func myMax(x: T, y: T) -> T { x < y ? y : x }
    func myAbs(x: Int) -> Int { x < 0 ? -x : x }
}

or

  1. add typealias T = Int in MyStruct:
struct MyStruct: MyProtocol { 
    typealias T = Int
    var prop: T
    func myMax(x: T, y: T) -> T { x < y ? y : x }
    func myAbs(x: T) -> T { x < 0 ? -x : x }
}

My question is whether it is expected behavior that the two Ts in myAbs(x:) cannot be inferred or am I doing something wrong?

Also, if I swap the ordering of myAbs(x:) and myMax(x:y:) in MyStruct, Xcode happily accepts myAbs(x:) and complains about the Ts in myMax(x:y:) instead.

Of the five threads this topic is similar to, three asked about why an associatedtype inference succeeded, one was a pitch to remove associatedtype inference, only one asked about associatedtype not inferred. My case seems to be much simpler than the one reported in the last thread.

Thanks.

Recent improvements to associated type inference
2

This looks like a bug, and it's in Xcode 12.5.1 (12E507) too, ie:

protocol P {
  associatedtype T
  var p: T { get }
  func foo(x: T)
  func bar(x: T)
}

struct S: P {
  var p: Int
  func foo(x: T) {}
  func bar(x: T) {} // ERROR: Reference to invalid associated type 'T' of type 'S'
}

Here's a variation without a property, which compiles with two methods, but not with three:

protocol P {
  associatedtype T
  func foo(x: T)
  func bar(x: T)
  func baz(x: T)
}

struct S: P {
  func foo(x: Int) {}
  func bar(x: T) {}
  func baz(x: T) {} // ERROR: Reference to invalid associated type 'T' of type 'S'
}
1 Like
3

Thanks for looking into it.

Apparently even with one method it won't compile if the method returns T:

protocol P {
  associatedtype T
  func foo(x: T) -> T
}

struct S: P {
  func foo(x: Int) -> T { return 0 } // ERROR: Reference to invalid associated type 'T' of type 'S'
}
1 Like
4

Filed SR-15027