Oops, we fixed this for functions, but I guess we missed subscripts. Thanks, Ben! cc @DougGregor, @huonw

@swift-ci create

Comment by Ben Stock (JIRA)

@belkadan No problem! I have ADD, so seeing that little yellow warning indicator in Xcode’s activity area ❓ has been driving me a little nuts. 😃

I tried with

struct Key<T> {}

struct Thing1 {
    subscript<K, V>(_: Key<[K: V]>, _: K) -> V? { return nil }
}
struct Thing2 {
    subscript<K: Hashable, V>(_: Key<[K: V]>, _: K) -> V? { return nil }
}

And it seems to compile without a warning or error with a recent development compiler and with Xcode 9.3. Could you provide a little more context for the code?

Comment by Ben Stock (JIRA)

@huonw

Update
I just tried your examples, and they both worked. I then tried to add the key and nestedKey parameter names, and I was back in my original pickle. 🙁

So, it looks like the parameter names or argument labels are causing some discrepancy. Weird. I’m not the most knowledgable about the inner workings of the compiler (or any compiler, for that matter), so I think I’ll let you professionals take a stab at it.

I’m basically creating a lightweight key-value store. The subscript causing the problems is defined in this store. Here is an overview of the types I’m working with:

1. struct Cache
   The key-value store described above. The type simply wraps a dictionary of Any values, keyed by AnyCacheKey values. That brings us to:

2. class AnyCacheKey
   This class is abstract in nature and has no type information associated with it. It simply serves as a base implementation of the following more “concrete” key type.

3. class Cache.Key<T>
   As mentioned above, the Cache.Key class inherits from AnyCacheKey and serves as the primary means of accessing values in a Cache instance.

If none of that makes sense, here’s a slightly condensed version of the code:

public class AnyCacheKey : RawRepresentable, Hashable, Comparable {
    public let rawValue: String
    // ... 
    // Hashable and Comparable implementations 
    // ...
}

public struct Cache {

    // This is the concrete key class with the additional static type information.
    final public class Key<T> : AnyCacheKey {}

    // The underlying dictionary containing the cached values.
    private var storage: [AnyCacheKey: Any]
  
    // ...
    // Some other code
    // ...
  
    // Base getter and setter
    public subscript <T>(key: Key<T>) -> T? {
        get { return storage[key] as? T }
        set { storage[key] = newValue }
    }

    // The problem child
    public subscript <K, V>(key: Key<[K: V]>, _ nestedKey: K) -> V? where K : Hashable {
        get {
            return self[key]?[nestedKey]
        }
        set {
            var values = storage[key] as? [K: V] ?? [:]
            values[nestedKey] = newValue
            self[key] = values
        }
    }
}

Thanks for the additional info! It's looking like this might have been fixed between Xcode 9.2 and 9.3, which is always nice: theoretically this issue should be fixed with just an update.

I tried both my example with argument names and your example after adding the required methods for it to compile (for future reference, it's really helpful if any examples can just be copied-pasted into a file to demonstrate your problem, to make sure we're both looking at exactly the same thing 🙂 ) and there wasn't an error, with or without the where K: Hashable:

struct Key<T> {}

struct Thing1 {
    subscript<K, V>(key: Key<[K: V]>, nestedKey: K) -> V? { return nil }
}
struct Thing2 {
    subscript<K: Hashable, V>(key: Key<[K: V]>, nestedKey: K) -> V? { return nil }
}

and also after updating your example to compile:

public class AnyCacheKey: RawRepresentable, Hashable, Comparable {
    public let rawValue: String = ""

    // added:
    public required init?(rawValue: String) {}
    public var hashValue: Int { return 0 }
    public static func ==(lhs: AnyCacheKey, rhs: AnyCacheKey) -> Bool {
        return false
    }
    public static func <(lhs: AnyCacheKey, rhs: AnyCacheKey) -> Bool {
        return false
    }
}

public struct Cache {

    // This is the concrete key class with the additional static type information.
    final public class Key<T> : AnyCacheKey {}

    // The underlying dictionary containing the cached values.
    private var storage: [AnyCacheKey: Any]
    
    // ...
    // Some other code
    // ...
    
    // Base getter and setter
    public subscript <T>(key: Key<T>) -> T? {
        get { return storage[key] as? T }
        set { storage[key] = newValue }
    }

    // The problem child
    public subscript <K, V>(key: Key<[K: V]>, _ nestedKey: K) -> V? where K : Hashable {
        get {
            return self[key]?[nestedKey]
        }
        set {
            var values = storage[key] as? [K: V] ?? [:]
            values[nestedKey] = newValue
            self[key] = values
        }
    }
}

That might just be Doug scoping down the "redundant" warning. We should add these as test cases in case we ever decide to ramp it back up.

I believe this was fixed by 98e88bc