This seems like a variation on https://bugs.swift.org/browse/SR-13879 but with the keys property instead of the indices property.

@swift-ci create

This is because the unwrap operation for an optional value does not support in-place mutations – it works by copying the wrapped value out (making it non-unique), then writing it back after the mutation is done.

Dictionary implements two workarounds for this problem. First, you can get rid of the optional result by indexing into the values view:

    for index in elements.indices {
        elements.values[i].checkUniqueness()
    }

Second, if all you have is a key, then you can use the defaulted subscript operation to get a non-optional value.

    for key in elements.keys {
        elements[key, default: CopyOnWriteWrapper()].checkUniqueness()
    }

Both .values and subscript(_:default🙂 support in-place mutations.

Until the force-unwrap construct is changed to support in-place mutations, this can also be worked around more universally by adding an Optional extension:

extension Optional {
  mutating func withForceUnwrappedValue<R>(_ body: (inout Wrapped) throws-> R) rethrows -> R {
    var value = self!
    self = nil
    defer { self = value }
    return try body(value)
  }
}

    for key in elements.keys {
        elements[key].withForceUnwrappedValue { $0.checkUniqueness() }
    }

An alternate, less unwieldy, formulation is to use a property with a _modify accessor:

extension Optional {
  var unwrapped: Wrapped {
    get { self! }
    set { self = newValue }
    _modify {
      var value = self!
      self = nil
      defer { self = value }
      yield &value
    }
  }
}

    for key in elements.keys {
        elements[key].unwrapped.checkUniqueness()
    }