Merge pull request #570 from apple/revert-567-pr-grabbag

Revert "Foundation API Conformance Update: Miscellaneous"

Author: itaiferber

Foundation/NSArray.swift

@@ -508,11 +508,11 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
             NSInvalidArgument("range \(r) extends beyond bounds \(bounds)")
         }
 
-        if opts.contains(.firstEqual) && opts.contains(.lastEqual) {
-            NSInvalidArgument("both NSBinarySearching.firstEqual and NSBinarySearching.lastEqual options cannot be specified")
+        if opts.contains(.FirstEqual) && opts.contains(.LastEqual) {
+            NSInvalidArgument("both NSBinarySearching.FirstEqual and NSBinarySearching.LastEqual options cannot be specified")
         }
 
-        let searchForInsertionIndex = opts.contains(.insertionIndex)
+        let searchForInsertionIndex = opts.contains(.InsertionIndex)
 
         // fringe cases
         if r.length == 0 {
@@ -530,8 +530,8 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
         }
 
         // common processing
-        let firstEqual = opts.contains(.firstEqual)
-        let lastEqual = opts.contains(.lastEqual)
+        let firstEqual = opts.contains(.FirstEqual)
+        let lastEqual = opts.contains(.LastEqual)
         let anyEqual = !(firstEqual || lastEqual)
 
         var result = NSNotFound
@@ -627,9 +627,9 @@ public struct NSBinarySearchingOptions : OptionSet {
     public let rawValue : UInt
     public init(rawValue: UInt) { self.rawValue = rawValue }
 
-    public static let firstEqual = NSBinarySearchingOptions(rawValue: 1 << 8)
-    public static let lastEqual = NSBinarySearchingOptions(rawValue: 1 << 9)
-    public static let insertionIndex = NSBinarySearchingOptions(rawValue: 1 << 10)
+    public static let FirstEqual = NSBinarySearchingOptions(rawValue: 1 << 8)
+    public static let LastEqual = NSBinarySearchingOptions(rawValue: 1 << 9)
+    public static let InsertionIndex = NSBinarySearchingOptions(rawValue: 1 << 10)
 }
 
 open class NSMutableArray : NSArray {

Foundation/NSCache.swift

@@ -7,36 +7,39 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-private class NSCacheEntry<KeyType : AnyObject, ObjectType : AnyObject> {
-    var key: KeyType
-    var value: ObjectType
-    var cost: Int
-    var prevByCost: NSCacheEntry?
-    var nextByCost: NSCacheEntry?
-    init(key: KeyType, value: ObjectType, cost: Int) {
-        self.key = key
-        self.value = value
-        self.cost = cost
-    }
-}
 
-open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
-    private var _entries = Dictionary<UnsafeRawPointer, NSCacheEntry<KeyType, ObjectType>>()
+open class Cache: NSObject {
+    private class NSCacheEntry {
+        var key: AnyObject
+        var value: AnyObject
+        var cost: Int
+        var prevByCost: NSCacheEntry?
+        var nextByCost: NSCacheEntry?
+        init(key: AnyObject, value: AnyObject, cost: Int) {
+            self.key = key
+            self.value = value
+            self.cost = cost
+        }
+    }
+    
+    private var _entries = Dictionary<UnsafeRawPointer, NSCacheEntry>()
     private let _lock = NSLock()
     private var _totalCost = 0
-    private var _byCost: NSCacheEntry<KeyType, ObjectType>?
+    private var _byCost: NSCacheEntry?
 
     open var name: String = ""
     open var totalCostLimit: Int = -1 // limits are imprecise/not strict
     open var countLimit: Int = -1 // limits are imprecise/not strict
     open var evictsObjectsWithDiscardedContent: Bool = false
 
-    public override init() {}
+    public override init() {
+        
+    }
 
     open weak var delegate: NSCacheDelegate?
 
-    open func object(forKey key: KeyType) -> ObjectType? {
-        var object: ObjectType?
+    open func object(forKey key: AnyObject) -> AnyObject? {
+        var object: AnyObject?
 
         let keyRef = unsafeBitCast(key, to: UnsafeRawPointer.self)
 
@@ -49,11 +52,11 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         return object
     }
 
-    open func setObject(_ obj: ObjectType, forKey key: KeyType) {
+    open func setObject(_ obj: AnyObject, forKey key: AnyObject) {
         setObject(obj, forKey: key, cost: 0)
     }
 
-    private func remove(_ entry: NSCacheEntry<KeyType, ObjectType>) {
+    private func remove(_ entry: NSCacheEntry) {
         let oldPrev = entry.prevByCost
         let oldNext = entry.nextByCost
         oldPrev?.nextByCost = oldNext
@@ -63,7 +66,7 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         }
     }
 
-    private func insert(_ entry: NSCacheEntry<KeyType, ObjectType>) {
+    private func insert(_ entry: NSCacheEntry) {
         if _byCost == nil {
             _byCost = entry
         } else {
@@ -80,7 +83,7 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         }
     }
 
-    open func setObject(_ obj: ObjectType, forKey key: KeyType, cost g: Int) {
+    open func setObject(_ obj: AnyObject, forKey key: AnyObject, cost g: Int) {
         let keyRef = unsafeBitCast(key, to: UnsafeRawPointer.self)
 
         _lock.lock()
@@ -108,7 +111,7 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         }
         _lock.unlock()
 
-        var toRemove = [NSCacheEntry<KeyType, ObjectType>]()
+        var toRemove = [NSCacheEntry]()
 
         if purgeAmount > 0 {
             _lock.lock()
@@ -143,7 +146,7 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
 
         if let del = delegate {
             for entry in toRemove {
-                del.cache(unsafeBitCast(self, to:NSCache<AnyObject, AnyObject>.self), willEvictObject: entry.value)
+                del.cache(self, willEvictObject: entry.value)
             }
         }
 
@@ -174,12 +177,12 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
     }    
 }
 
-public protocol NSCacheDelegate : NSObjectProtocol {
-    func cache(_ cache: NSCache<AnyObject, AnyObject>, willEvictObject obj: AnyObject)
+public protocol NSCacheDelegate : class {
+    func cache(_ cache: Cache, willEvictObject obj: AnyObject)
 }
 
 extension NSCacheDelegate {
-    func cache(_ cache: NSCache<AnyObject, AnyObject>, willEvictObject obj: AnyObject) {
+    func cache(_ cache: Cache, willEvictObject obj: AnyObject) {
         // Default implementation does nothing
     }
 }

Foundation/NSComparisonPredicate.swift

@@ -7,8 +7,9 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
+
 // Flags(s) that can be passed to the factory to indicate that a operator operating on strings should do so in a case insensitive fashion.
-extension NSComparisonPredicate {
+extension ComparisonPredicate {
     public struct Options : OptionSet {
         public let rawValue : UInt
         public init(rawValue: UInt) { self.rawValue = rawValue }
@@ -20,13 +21,15 @@ extension NSComparisonPredicate {
 
     // Describes how the operator is modified: can be direct, ALL, or ANY
     public enum Modifier : UInt {
+        
         case direct // Do a direct comparison
         case all // ALL toMany.x = y
         case any // ANY toMany.x = y
     }
 
     // Type basic set of operators defined. Most are obvious
     public enum Operator : UInt {
+        
         case lessThan // compare: returns NSOrderedAscending
         case lessThanOrEqualTo // compare: returns NSOrderedAscending || NSOrderedSame
         case greaterThan // compare: returns NSOrderedDescending
@@ -42,9 +45,9 @@ extension NSComparisonPredicate {
         case between
     }
 }
-
 // Comparison predicates are predicates which do some form of comparison between the results of two expressions and return a BOOL. They take an operator, a left expression, and a right expression, and return the result of invoking the operator with the results of evaluating the expressions.
-open class NSComparisonPredicate : NSPredicate {
+
+open class ComparisonPredicate : Predicate {
 
     public init(leftExpression lhs: NSExpression, rightExpression rhs: NSExpression, modifier: Modifier, type: Operator, options: Options) { NSUnimplemented() }
     public required init?(coder: NSCoder) { NSUnimplemented() }

Foundation/NSCompoundPredicate.swift

@@ -10,38 +10,38 @@
 
 // Compound predicates are predicates which act on the results of evaluating other operators. We provide the basic boolean operators: AND, OR, and NOT.
 
-extension NSCompoundPredicate {
+extension CompoundPredicate {
     public enum LogicalType : UInt {
+        
         case not
         case and
         case or
     }
 }
 
-open class NSCompoundPredicate : NSPredicate {
-    public init(type: LogicalType, subpredicates: [NSPredicate]) {
+open class CompoundPredicate : Predicate {
+    
+    public init(type: LogicalType, subpredicates: [Predicate]) {
         if type == .not && subpredicates.count == 0 {
             preconditionFailure("Unsupported predicate count of \(subpredicates.count) for \(type)")
         }
-
         self.compoundPredicateType = type
         self.subpredicates = subpredicates
         super.init(value: false)
     }
-
     public required init?(coder: NSCoder) { NSUnimplemented() }
 
-    open var compoundPredicateType: LogicalType
-    open var subpredicates: [NSPredicate]
+    public let compoundPredicateType: LogicalType
+    public let subpredicates: [Predicate]
 
     /*** Convenience Methods ***/
-    public convenience init(andPredicateWithSubpredicates subpredicates: [NSPredicate]) {
+    public convenience init(andPredicateWithSubpredicates subpredicates: [Predicate]) {
         self.init(type: .and, subpredicates: subpredicates)
     }
-    public convenience init(orPredicateWithSubpredicates subpredicates: [NSPredicate]) {
+    public convenience init(orPredicateWithSubpredicates subpredicates: [Predicate]) {
         self.init(type: .or, subpredicates: subpredicates)
     }
-    public convenience init(notPredicateWithSubpredicate predicate: NSPredicate) {
+    public convenience init(notPredicateWithSubpredicate predicate: Predicate) {
         self.init(type: .not, subpredicates: [predicate])
     }
 

Foundation/NSError.swift

@@ -145,8 +145,8 @@ open class NSError : NSObject, NSCopying, NSSecureCoding, NSCoding {
         return userInfo[NSLocalizedRecoveryOptionsErrorKey] as? [String]
     }
 
-    open var recoveryAttempter: Any? {
-        return userInfo[NSRecoveryAttempterErrorKey]
+    open var recoveryAttempter: AnyObject? {
+        return userInfo[NSRecoveryAttempterErrorKey] as? AnyObject
     }
 
     open var helpAnchor: String? {

Foundation/NSExpression.swift

@@ -50,14 +50,13 @@ open class NSExpression : NSObject, NSSecureCoding, NSCopying {
         NSUnimplemented()
     }
 
-    public /*not inherited*/ init(format expressionFormat: String, argumentArray arguments: [Any]) { NSUnimplemented() }
-    public /*not inherited*/ init(format expressionFormat: String, arguments argList: CVaListPointer) { NSUnimplemented() }
+    public /*not inherited*/ init(format expressionFormat: String, argumentArray arguments: [AnyObject]) { NSUnimplemented() }
 
-    public /*not inherited*/ init(forConstantValue obj: Any?) { NSUnimplemented() } // Expression that returns a constant value
+    public /*not inherited*/ init(forConstantValue obj: AnyObject?) { NSUnimplemented() } // Expression that returns a constant value
     open class func expressionForEvaluatedObject() -> NSExpression { NSUnimplemented() } // Expression that returns the object being evaluated
     public /*not inherited*/ init(forVariable string: String) { NSUnimplemented() } // Expression that pulls a value from the variable bindings dictionary
     public /*not inherited*/ init(forKeyPath keyPath: String) { NSUnimplemented() } // Expression that invokes valueForKeyPath with keyPath
-    public /*not inherited*/ init(forFunction name: String, arguments parameters: [Any]) { NSUnimplemented() } // Expression that invokes one of the predefined functions. Will throw immediately if the selector is bad; will throw at runtime if the parameters are incorrect.
+    public /*not inherited*/ init(forFunction name: String, arguments parameters: [AnyObject]) { NSUnimplemented() } // Expression that invokes one of the predefined functions. Will throw immediately if the selector is bad; will throw at runtime if the parameters are incorrect.
     // Predefined functions are:
     // name              parameter array contents				returns
     //-------------------------------------------------------------------------------------------------------------------------------------
@@ -99,43 +98,40 @@ open class NSExpression : NSObject, NSSecureCoding, NSCopying {
     //                   two NSExpression instances representing CLLocations    NSNumber
     // length:           an NSExpression instance representing a string         NSNumber
 
-    public /*not inherited*/ init(forAggregate subexpressions: [Any]) { NSUnimplemented() } // Expression that returns a collection containing the results of other expressions
+    public /*not inherited*/ init(forAggregate subexpressions: [AnyObject]) { NSUnimplemented() } // Expression that returns a collection containing the results of other expressions
     public /*not inherited*/ init(forUnionSet left: NSExpression, with right: NSExpression) { NSUnimplemented() } // return an expression that will return the union of the collections expressed by left and right
     public /*not inherited*/ init(forIntersectSet left: NSExpression, with right: NSExpression) { NSUnimplemented() } // return an expression that will return the intersection of the collections expressed by left and right
     public /*not inherited*/ init(forMinusSet left: NSExpression, with right: NSExpression) { NSUnimplemented() } // return an expression that will return the disjunction of the collections expressed by left and right
-    public /*not inherited*/ init(forSubquery expression: NSExpression, usingIteratorVariable variable: String, predicate: Any) { NSUnimplemented() } // Expression that filters a collection by storing elements in the collection in the variable variable and keeping the elements for which qualifer returns true; variable is used as a local variable, and will shadow any instances of variable in the bindings dictionary, the variable is removed or the old value replaced once evaluation completes
-    public /*not inherited*/ init(forFunction target: NSExpression, selectorName name: String, arguments parameters: [Any]?) { NSUnimplemented() } // Expression that invokes the selector on target with parameters. Will throw at runtime if target does not implement selector or if parameters are wrong.
+    public /*not inherited*/ init(forSubquery expression: NSExpression, usingIteratorVariable variable: String, predicate: AnyObject) { NSUnimplemented() } // Expression that filters a collection by storing elements in the collection in the variable variable and keeping the elements for which qualifer returns true; variable is used as a local variable, and will shadow any instances of variable in the bindings dictionary, the variable is removed or the old value replaced once evaluation completes
+    public /*not inherited*/ init(forFunction target: NSExpression, selectorName name: String, arguments parameters: [AnyObject]?) { NSUnimplemented() } // Expression that invokes the selector on target with parameters. Will throw at runtime if target does not implement selector or if parameters are wrong.
     open class func expressionForAnyKey() -> NSExpression { NSUnimplemented() }
-    public /*not inherited*/ init(block: @escaping (Any?, [Any], NSMutableDictionary?) -> Any, arguments: [NSExpression]?) { NSUnimplemented() } // Expression that invokes the block with the parameters; note that block expressions are not encodable or representable as parseable strings.
-    public /*not inherited*/ init(forConditional predicate: Any, trueExpression: NSExpression, falseExpression: NSExpression) { NSUnimplemented() } // Expression that will return the result of trueExpression or falseExpression depending on the value of predicate
+    public /*not inherited*/ init(forBlock block: (AnyObject?, [AnyObject], NSMutableDictionary?) -> AnyObject, arguments: [NSExpression]?) { NSUnimplemented() } // Expression that invokes the block with the parameters; note that block expressions are not encodable or representable as parseable strings.
+    public /*not inherited*/ init(forConditional predicate: Predicate, trueExpression: NSExpression, falseExpression: NSExpression) { NSUnimplemented() } // Expression that will return the result of trueExpression or falseExpression depending on the value of predicate
 
     public init(expressionType type: ExpressionType) { NSUnimplemented() }
 
     // accessors for individual parameters - raise if not applicable
     open var expressionType: ExpressionType { NSUnimplemented() }
-    open var constantValue: Any { NSUnimplemented() }
+    open var constantValue: AnyObject { NSUnimplemented() }
     open var keyPath: String { NSUnimplemented() }
     open var function: String { NSUnimplemented() }
     open var variable: String { NSUnimplemented() }
     /*@NSCopying*/ open var operand: NSExpression { NSUnimplemented() } // the object on which the selector will be invoked (the result of evaluating a key path or one of the defined functions)
     open var arguments: [NSExpression]? { NSUnimplemented() } // array of expressions which will be passed as parameters during invocation of the selector on the operand of a function expression
 
-    open var collection: Any { NSUnimplemented() }
-    /*@NSCopying*/ open var predicate: NSPredicate { NSUnimplemented() }
+    open var collection: AnyObject { NSUnimplemented() }
+    /*@NSCopying*/ open var predicate: Predicate { NSUnimplemented() }
     /*@NSCopying*/ open var left: NSExpression { NSUnimplemented() } // expression which represents the left side of a set expression
     /*@NSCopying*/ open var right: NSExpression { NSUnimplemented() } // expression which represents the right side of a set expression
 
     /*@NSCopying*/ open var `true`: NSExpression { NSUnimplemented() } // expression which will be evaluated if a conditional expression's predicate evaluates to true
     /*@NSCopying*/ open var `false`: NSExpression { NSUnimplemented() } // expression which will be evaluated if a conditional expression's predicate evaluates to false
 
-    open var expressionBlock: (Any?, [Any], NSMutableDictionary?) -> Any { NSUnimplemented() }
+    open var expressionBlock: (AnyObject?, [AnyObject], NSMutableDictionary?) -> AnyObject { NSUnimplemented() }
 
     // evaluate the expression using the object and bindings- note that context is mutable here and can be used by expressions to store temporary state for one predicate evaluation
-    open func expressionValue(with object: Any?, context: NSMutableDictionary?) -> Any? { NSUnimplemented() }
+    open func expressionValueWithObject(_ object: AnyObject?, context: NSMutableDictionary?) -> AnyObject { NSUnimplemented() }
 
     open func allowEvaluation() { NSUnimplemented() } // Force an expression which was securely decoded to allow evaluation
 }
 
-extension NSExpression {
-    public convenience init(format expressionFormat: String, _ args: CVarArg...) { NSUnimplemented() }
-}