protocol SecureCodingProvider {
  associatedtype T : Generic<Self>
}

class Generic<Value> {}

internal struct Foo {
}

extension Foo: SecureCodingProvider {
  class T: Generic<Foo> {}
}

protocol SecureCodingProvider {
  associatedtype T : Generic<Self.U>
  associatedtype U
}

class Generic<Value> {}

internal struct Foo: SecureCodingProvider {
  class T: Generic<U> {}
  struct U {}
}

protocol BaseInterface {
  associatedtype Mode: Equatable
}

protocol P {}
class GenericStorage<Mode: Equatable> {}
typealias SpecialStorage<Mode: Equatable> = GenericStorage<Mode> & P

protocol StorageInterface: BaseInterface {
  associatedtype StorageA: GenericStorage<Mode>
  associatedtype StorageB: SpecialStorage<Mode>
}

enum ConcreteMode: Equatable {}

class A: GenericStorage<ConcreteMode> {}
class B: A, P {}

// rejected
struct ConcreteInterface: StorageInterface {
  typealias Mode = ConcreteMode
  typealias StorageA = A
  typealias StorageB = B
}