Clang Importer: Enable OptionSetType import.

Update the tests to match.

Swift SVN r28906

include/swift/Basic/LangOptions.h

@@ -137,7 +137,7 @@ namespace swift {
     bool EnableInterfaceTypeMangling = true;
     
     /// Import NS_OPTIONS types using the new OptionSetType interface.
-    bool ImportNSOptionsAsOptionSetType = false;
+    bool ImportNSOptionsAsOptionSetType = true;
 
     /// The target we are building for.
     ///

stdlib/public/SDK/CoreMedia/CMTime.swift

@@ -23,35 +23,32 @@
 // CMTimeConvertScale
 extension CMTime {
   public var isValid: Bool {
-    return (self.flags & CMTimeFlags.Valid) == CMTimeFlags.Valid
+    return self.flags.contains(.Valid)
   }
 
   public var isPositiveInfinity: Bool {
     return self.isValid &&
-      ((self.flags & CMTimeFlags.PositiveInfinity) ==
-        CMTimeFlags.PositiveInfinity)
+      self.flags.contains(.PositiveInfinity)
   }
 
   public var isNegativeInfinity: Bool {
     return self.isValid &&
-      ((self.flags & CMTimeFlags.NegativeInfinity) ==
-        CMTimeFlags.NegativeInfinity)
+      self.flags.contains(.NegativeInfinity)
   }
 
   public var isIndefinite: Bool {
     return self.isValid &&
-      ((self.flags & CMTimeFlags.Indefinite) == CMTimeFlags.Indefinite)
+      self.flags.contains(.Indefinite)
   }
 
   public var isNumeric: Bool {
     return
-      (self.flags & (CMTimeFlags.Valid | CMTimeFlags.ImpliedValueFlagsMask)) ==
-      CMTimeFlags.Valid
+      self.flags.intersect([.Valid, .ImpliedValueFlagsMask]) == .Valid
   }
 
   public var hasBeenRounded: Bool {
     return self.isNumeric &&
-      ((self.flags & CMTimeFlags.HasBeenRounded) == CMTimeFlags.HasBeenRounded)
+      self.flags.contains(.HasBeenRounded)
   }
 
   public var seconds: Double {

stdlib/public/SDK/Foundation/NSStringAPI.swift

@@ -361,7 +361,7 @@ extension String {
   /// returns the lexical ordering for the range.
   public func compare(
     aString: String,
-    options mask: NSStringCompareOptions = nil,
+    options mask: NSStringCompareOptions = [],
     range: Range<Index>? = nil,
     locale: NSLocale? = nil
   ) -> NSComparisonResult {
@@ -378,7 +378,7 @@ extension String {
       options: mask,
       range: _toNSRange(range ?? self.characters.indices))
 
-    : mask != nil ? _ns.compare(aString, options: mask)
+    : !mask.isEmpty ? _ns.compare(aString, options: mask)
 
     : _ns.compare(aString)
   }
@@ -953,7 +953,7 @@ extension String {
   public func linguisticTagsInRange(
     range: Range<Index>,
     scheme tagScheme: String,
-    options opts: NSLinguisticTaggerOptions = nil,
+    options opts: NSLinguisticTaggerOptions = [],
     orthography: NSOrthography? = nil,
     tokenRanges: UnsafeMutablePointer<[Range<Index>]> = nil // FIXME:Can this be nil?
   ) -> [String] {
@@ -1092,7 +1092,7 @@ extension String {
   /// given options.
   public func rangeOfCharacterFromSet(
     aSet: NSCharacterSet,
-    options mask:NSStringCompareOptions = nil,
+    options mask:NSStringCompareOptions = [],
     range aRange: Range<Index>? = nil
   )-> Range<Index>? {
     return _optionalRange(
@@ -1146,7 +1146,7 @@ extension String {
   /// given options, using the specified locale, if any.
   public func rangeOfString(
     aString: String,
-    options mask: NSStringCompareOptions = nil,
+    options mask: NSStringCompareOptions = [],
     range searchRange: Range<Index>? = nil,
     locale: NSLocale? = nil
   ) -> Range<Index>? {
@@ -1159,7 +1159,7 @@ extension String {
       : searchRange != nil ? _ns.rangeOfString(
         aString, options: mask, range: _toNSRange(searchRange!)
       )
-      : mask != nil ? _ns.rangeOfString(aString, options: mask)
+      : !mask.isEmpty ? _ns.rangeOfString(aString, options: mask)
       : _ns.rangeOfString(aString)
     )
   }
@@ -1347,10 +1347,10 @@ extension String {
   public func stringByReplacingOccurrencesOfString(
     target: String,
     withString replacement: String,
-    options: NSStringCompareOptions = nil,
+    options: NSStringCompareOptions = [],
     range searchRange: Range<Index>? = nil
   ) -> String {
-    return (searchRange != nil) || (options != nil)
+    return (searchRange != nil) || (!options.isEmpty)
     ? _ns.stringByReplacingOccurrencesOfString(
       target,
       withString: replacement, options: options,

test/1_stdlib/KVO.swift

@@ -45,7 +45,7 @@ class Observer : NSObject {
   func observeTarget(t: Target) {
     target = t
     target!.addObserver(self, forKeyPath:"objcValue",
-      options:NSKeyValueObservingOptions.New | NSKeyValueObservingOptions.Old, 
+      options: [.New, .Old],
       context: nil)
   }
 
@@ -89,7 +89,7 @@ class ObserverKVO : NSObject {
     self.target = target
     self.target!.addObserver(self,
        forKeyPath: "objcValue",
-       options:NSKeyValueObservingOptions.New | NSKeyValueObservingOptions.Old, 
+       options: [.New, .Old],
        context: &kvoContext)
   }
   

test/1_stdlib/NSStringAPI.swift

@@ -248,12 +248,12 @@ NSStringAPIs.test("caseInsensitiveCompare(_:)") {
 
 NSStringAPIs.test("commonPrefixWithString(_:options:)") {
   expectEqual("ab",
-      "abcd".commonPrefixWithString("abdc", options: NSStringCompareOptions(0)))
+      "abcd".commonPrefixWithString("abdc", options: []))
   expectEqual("abC",
       "abCd".commonPrefixWithString("abce", options: .CaseInsensitiveSearch))
 
   expectEqual("аб",
-      "абвг".commonPrefixWithString("абгв", options: NSStringCompareOptions(0)))
+      "абвг".commonPrefixWithString("абгв", options: []))
   expectEqual("абВ",
       "абВг".commonPrefixWithString("абвд", options: .CaseInsensitiveSearch))
 }
@@ -442,7 +442,7 @@ NSStringAPIs.test("enumerateLinguisticTagsInRange(_:scheme:options:orthography:_
   var sentences: [String] = []
   s.enumerateLinguisticTagsInRange(startIndex..<endIndex,
       scheme: NSLinguisticTagSchemeTokenType,
-      options: NSLinguisticTaggerOptions(0),
+      options: [],
       orthography: nil) {
     (tag: String, tokenRange: Range<String.Index>, sentenceRange: Range<String.Index>, inout stop: Bool)
   in
@@ -482,8 +482,7 @@ NSStringAPIs.test("enumerateSubstringsInRange(_:options:_:)") {
   if true {
     var substrings: [String] = []
     s.enumerateSubstringsInRange(startIndex..<endIndex,
-      options: NSStringEnumerationOptions.ByComposedCharacterSequences
-        | NSStringEnumerationOptions.SubstringNotRequired) {
+      options: [.ByComposedCharacterSequences, .SubstringNotRequired]) {
       (substring_: String?, substringRange: Range<String.Index>,
        enclosingRange: Range<String.Index>, inout stop: Bool)
     in
@@ -531,7 +530,7 @@ NSStringAPIs.test("getBytes(_:maxLength:usedLength:encoding:options:range:remain
     var remainingRange = startIndex..<endIndex
     var result = s.getBytes(&buffer, maxLength: 11, usedLength: &usedLength,
         encoding: NSUTF8StringEncoding,
-        options: NSStringEncodingConversionOptions(0),
+        options: [],
         range: startIndex..<endIndex, remainingRange: &remainingRange)
     expectTrue(result)
     expectEqualSequence(expectedStr, buffer)
@@ -552,7 +551,7 @@ NSStringAPIs.test("getBytes(_:maxLength:usedLength:encoding:options:range:remain
     var remainingRange = startIndex..<endIndex
     var result = s.getBytes(&buffer, maxLength: 11, usedLength: &usedLength,
         encoding: NSUTF8StringEncoding,
-        options: NSStringEncodingConversionOptions(0),
+        options: [],
         range: startIndex..<endIndex, remainingRange: &remainingRange)
     expectTrue(result)
     expectEqualSequence(expectedStr, buffer)
@@ -572,7 +571,7 @@ NSStringAPIs.test("getBytes(_:maxLength:usedLength:encoding:options:range:remain
     var remainingRange = startIndex..<endIndex
     var result = s.getBytes(&buffer, maxLength: bufferLength,
         usedLength: &usedLength, encoding: NSUTF8StringEncoding,
-        options: NSStringEncodingConversionOptions(0),
+        options: [],
         range: startIndex..<endIndex, remainingRange: &remainingRange)
     expectTrue(result)
     expectEqualSequence(expectedStr, buffer)
@@ -592,7 +591,7 @@ NSStringAPIs.test("getBytes(_:maxLength:usedLength:encoding:options:range:remain
     var remainingRange = startIndex..<endIndex
     var result = s.getBytes(&buffer, maxLength: bufferLength,
         usedLength: &usedLength, encoding: NSASCIIStringEncoding,
-        options: NSStringEncodingConversionOptions(0),
+        options: [],
         range: startIndex..<endIndex, remainingRange: &remainingRange)
     expectTrue(result)
     expectEqualSequence(expectedStr, buffer)
@@ -857,7 +856,7 @@ NSStringAPIs.test("linguisticTagsInRange(_:scheme:options:orthography:tokenRange
   var tokenRanges: [Range<String.Index>] = []
   var tags = s.linguisticTagsInRange(startIndex..<endIndex,
       scheme: NSLinguisticTagSchemeTokenType,
-      options: NSLinguisticTaggerOptions(0),
+      options: [],
       orthography: nil, tokenRanges: &tokenRanges)
   expectEqual(
       [ NSLinguisticTagWord, NSLinguisticTagWhitespace,

test/ClangModules/enum-with-target.swift

@@ -5,7 +5,7 @@
 import Foundation
 
 // Ignore deprecated constants in prefix stripping, even if they aren't deprecated /yet/.
-let calendarUnits: NSCalendarUnit = .Era | .Year | .Calendar
-let calendarUnits2: NSCalendarUnit = .NSMonthCalendarUnit | .NSYearCalendarUnit // expected-error 2 {{unavailable}}
+let calendarUnits: NSCalendarUnit = [.Era, .Year, .Calendar]
+let calendarUnits2: NSCalendarUnit = [.NSMonthCalendarUnit, .NSYearCalendarUnit] // expected-error 2 {{unavailable}}
   // ...unless they're all deprecated.
-let calendarUnitsDep: NSCalendarUnitDeprecated = .EraCalendarUnitDeprecated | .YearCalendarUnitDeprecated // expected-error 2 {{unavailable}}
+let calendarUnitsDep: NSCalendarUnitDeprecated = [.EraCalendarUnitDeprecated, .YearCalendarUnitDeprecated] // expected-error 2 {{unavailable}}

test/ClangModules/enum.swift

@@ -121,38 +121,32 @@ var withQuince: NSRuncingOptions = .EnableQuince
 var singleValue: NSSingleOptions = .Value
 
 // Check RawOptionSetType conformance.
-var minceAndQuince: NSRuncingOptions = .EnableMince & .EnableQuince
-var minceOrQuince: NSRuncingOptions = .EnableMince | .EnableQuince
-var noMince: NSRuncingOptions = ~NSRuncingOptions.EnableMince
-minceOrQuince &= noMince
-minceOrQuince |= minceAndQuince
-minceOrQuince ^= .EnableMince
+var minceAndQuince: NSRuncingOptions = NSRuncingOptions.EnableMince.intersect(NSRuncingOptions.EnableQuince)
+var minceOrQuince: NSRuncingOptions = [.EnableMince, .EnableQuince]
+minceOrQuince.intersectInPlace(minceAndQuince)
+minceOrQuince.unionInPlace(minceAndQuince)
 
 var minceValue: UInt = minceAndQuince.rawValue
-var minceFromMask: NSRuncingOptions = NSRuncingOptions(0)
-
-var nothing: NSRuncingOptions = NSRuncingOptions()
-var nothing2: NSRuncingOptions = nil
-let nothing3: NSRuncingOptions = .allZeros
+var minceFromMask: NSRuncingOptions = []
 
 // Strip leading 'k' in "kConstant".
-let calendarUnit: CFCalendarUnit = .Year | .Weekday
+let calendarUnit: CFCalendarUnit = [.Year, .Weekday]
 
 // Match various plurals.
-let observingOpts: NSKeyValueObservingOptions = .New | .Old
-let bluetoothProps: CBCharacteristicProperties = .Write | .WriteWithoutResponse
-let buzzFilter: AlertBuzzes = .Funk | .Sosumi
+let observingOpts: NSKeyValueObservingOptions = [.New, .Old]
+let bluetoothProps: CBCharacteristicProperties = [.Write, .WriteWithoutResponse]
+let buzzFilter: AlertBuzzes = [.Funk, .Sosumi]
 
 // Match multi-capital acronym.
-let bitmapFormat: NSBitmapFormat = .NSAlphaFirstBitmapFormat | .NS32BitBigEndianBitmapFormat;
-let bitmapFormatR: NSBitmapFormatReversed = .NSAlphaFirstBitmapFormatR | .NS32BitBigEndianBitmapFormatR;
-let bitmapFormat2: NSBitmapFormat2 = .NSU16a | .NSU32a;
-let bitmapFormat3: NSBitmapFormat3 = .NSU16b | .NSS32b;
-let bitmapFormat4: NSUBitmapFormat4 = .NSU16c | .NSU32c;
-let bitmapFormat5: NSABitmapFormat5 = .NSAA16d | .NSAB32d;
+let bitmapFormat: NSBitmapFormat = [.NSAlphaFirstBitmapFormat, .NS32BitBigEndianBitmapFormat];
+let bitmapFormatR: NSBitmapFormatReversed = [.NSAlphaFirstBitmapFormatR, .NS32BitBigEndianBitmapFormatR];
+let bitmapFormat2: NSBitmapFormat2  = [.NSU16a  , .NSU32a]
+let bitmapFormat3: NSBitmapFormat3  = [.NSU16b  , .NSS32b]
+let bitmapFormat4: NSUBitmapFormat4 = [.NSU16c  , .NSU32c]
+let bitmapFormat5: NSABitmapFormat5 = [.NSAA16d , .NSAB32d]
 
 // Drop trailing underscores when possible.
-let timeFlags: CMTimeFlags = .Valid | .HasBeenRounded
-let timeFlags2: CMTimeFlagsWithNumber = ._Valid | ._888
+let timeFlags: CMTimeFlags = [.Valid , .HasBeenRounded]
+let timeFlags2: CMTimeFlagsWithNumber = [._Valid, ._888]
 
-let objcFlags: objc_flags = .taggedPointer | .swiftRefcount
+let objcFlags: objc_flags = [.taggedPointer, .swiftRefcount]

test/ClangModules/enum_OptionSetType.swift

@@ -1,36 +0,0 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -import-ns-options-as-option-set-type -parse %s -verify
-// -- Check that we can successfully round-trip.
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -import-ns-options-as-option-set-type -D IRGEN -emit-ir %s >/dev/null
-
-// REQUIRES: objc_interop
-
-import Foundation
-import user_objc
-
-var withMince: NSRuncingOptions = .EnableMince
-var withQuince: NSRuncingOptions = .EnableQuince
-
-// When there is a single enum constant, compare it against the type name to
-// derive the namespaced name.
-var singleValue: NSSingleOptions = .Value
-
-// Check OptionSetType conformance.
-func useOptionSet<T: _OptionSetType>(x: T) {}
-useOptionSet(singleValue)
-useOptionSet(withMince)
-useOptionSet(withQuince)
-
-var minceFromMask: NSRuncingOptions = NSRuncingOptions(rawValue: 0)
-var minceValue: UInt = minceFromMask.rawValue
-
-/* TODO: OptionSet operations
-var minceAndQuince: NSRuncingOptions = .EnableMince.intersect(.EnableQuince)
-var minceOrQuince: NSRuncingOptions = .EnableMince.union(.EnableQuince)
-var noMince: NSRuncingOptions = NSRuncingOptions.EnableMince.inverse
-minceOrQuince.intersectInPlace(noMince)
-minceOrQuince.unionInPlace(minceAndQuince)
-
-var nothing: NSRuncingOptions = NSRuncingOptions()
-var nothing2: NSRuncingOptions = nil
-let nothing3: NSRuncingOptions = .allZeros
- */

test/DebugInfo/test-foundation.swift

@@ -99,7 +99,7 @@ public func date() {
 // Make sure we build some witness tables for enums.
 func useOptions(var opt: NSURLBookmarkCreationOptions)
        -> NSURLBookmarkCreationOptions {
-  return opt | opt
+  return [opt, opt]
 }
 
 // LOC-CHECK: ![[THUNK:.*]] = !DISubprogram({{.*}}linkageName: "_TToFC4main8MyObjectg5MyArrCSo7NSArray"

test/IDE/Inputs/mock-sdk/Foo.annotated.txt

@@ -36,15 +36,11 @@ enum <loc>FooComparisonResult</loc> : <ref:Struct>Int</ref> {
 }</decl>
 
 <decl:Struct>/// Aaa.  FooRuncingOptions.  Bbb.
-struct <loc>FooRuncingOptions</loc> : <ref:Protocol>RawOptionSetType</ref> {
-  <decl:Constructor><loc>init()</loc></decl>
-  <decl:Constructor><loc>init(_ rawValue: <ref:Struct>Int</ref>)</loc></decl>
+struct <loc>FooRuncingOptions</loc> : <ref:Protocol>OptionSetType</ref> {
   <decl:Constructor><loc>init(rawValue: <ref:Struct>Int</ref>)</loc></decl>
   <decl:Var>let <loc>rawValue</loc>: <ref:Struct>Int</ref></decl>
   <decl:Var>static var <loc>EnableMince</loc>: <ref:Struct>FooRuncingOptions</ref> { get }</decl>
   <decl:Var>static var <loc>EnableQuince</loc>: <ref:Struct>FooRuncingOptions</ref> { get }</decl>
-  <decl:Var>static var <loc>allZeros</loc>: <ref:Struct>FooRuncingOptions</ref> { get }</decl>
-  <decl:Constructor><loc>init(nilLiteral _: ())</loc></decl>
 }</decl>
 <decl:Struct>struct <loc>FooStruct1</loc> {
   <decl:Var>var <loc>x</loc>: <ref:Struct>Int32</ref></decl>

test/IDE/Inputs/mock-sdk/Foo.printed.recursive.txt

@@ -36,15 +36,11 @@ enum FooComparisonResult : Int {
 }
 
 /// Aaa.  FooRuncingOptions.  Bbb.
-struct FooRuncingOptions : RawOptionSetType {
-  init()
-  init(_ rawValue: Int)
+struct FooRuncingOptions : OptionSetType {
   init(rawValue: Int)
   let rawValue: Int
   static var EnableMince: FooRuncingOptions { get }
   static var EnableQuince: FooRuncingOptions { get }
-  static var allZeros: FooRuncingOptions { get }
-  init(nilLiteral _: ())
 }
 struct FooStruct1 {
   var x: Int32

test/IDE/Inputs/mock-sdk/Foo.printed.txt

@@ -47,17 +47,13 @@ enum FooComparisonResult : Int {
 }
 
 /// Aaa.  FooRuncingOptions.  Bbb.
-struct FooRuncingOptions : RawOptionSetType {
-  init()
-  init(_ rawValue: Int)
+struct FooRuncingOptions : OptionSetType {
   init(rawValue: Int)
   let rawValue: Int
   
   // This is mince.
   static var EnableMince: FooRuncingOptions { get }
   static var EnableQuince: FooRuncingOptions { get } /* But this is quince */
-  static var allZeros: FooRuncingOptions { get }
-  init(nilLiteral _: ())
 }
 
 struct FooStruct1 {

test/IDE/print_ast_tc_decls.swift

@@ -1041,8 +1041,8 @@ enum d2300_EnumDeclWithValues1 : Int {
 // PASS_COMMON: {{^}}enum d2300_EnumDeclWithValues1 : Int {{{$}}
 // PASS_COMMON-NEXT: {{^}}  case EDV2_First{{$}}
 // PASS_COMMON-NEXT: {{^}}  case EDV2_Second{{$}}
-// PASS_COMMON-NEXT: {{^}}  var hashValue: Int { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}  typealias RawValue = Int
+// PASS_COMMON-NEXT: {{^}}  var hashValue: Int { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}  init?(rawValue: Int){{$}}
 // PASS_COMMON-NEXT: {{^}}  var rawValue: Int { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}}{{$}}
@@ -1054,8 +1054,8 @@ enum d2400_EnumDeclWithValues2 : Double {
 // PASS_COMMON: {{^}}enum d2400_EnumDeclWithValues2 : Double {{{$}}
 // PASS_COMMON-NEXT: {{^}}  case EDV3_First{{$}}
 // PASS_COMMON-NEXT: {{^}}  case EDV3_Second{{$}}
-// PASS_COMMON-NEXT: {{^}}  var hashValue: Int { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}  typealias RawValue = Double
+// PASS_COMMON-NEXT: {{^}}  var hashValue: Int { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}  init?(rawValue: Double){{$}}
 // PASS_COMMON-NEXT: {{^}}  var rawValue: Double { get }{{$}}
 // PASS_COMMON-NEXT: {{^}}}{{$}}

test/IDE/print_clang_decls.swift

@@ -89,15 +89,11 @@
 // FOUNDATION-NEXT: {{^}}}{{$}}
 
 // FOUNDATION-LABEL: {{^}}/// Aaa.  NSRuncingOptions.  Bbb.{{$}}
-// FOUNDATION-NEXT: {{^}}struct NSRuncingOptions : RawOptionSetType {{{$}}
-// FOUNDATION-NEXT: {{^}}  init(){{$}}
-// FOUNDATION-NEXT: {{^}}  init(_ rawValue: UInt){{$}}
+// FOUNDATION-NEXT: {{^}}struct NSRuncingOptions : OptionSetType {{{$}}
 // FOUNDATION-NEXT: {{^}}  init(rawValue: UInt){{$}}
 // FOUNDATION-NEXT: {{^}}  let rawValue: UInt{{$}}
 // FOUNDATION-NEXT: {{^}}  static var EnableMince: NSRuncingOptions { get }{{$}}
 // FOUNDATION-NEXT: {{^}}  static var EnableQuince: NSRuncingOptions { get }{{$}}
-// FOUNDATION-NEXT: {{^}}  static var allZeros: NSRuncingOptions { get }{{$}}
-// FOUNDATION-NEXT: {{^}}  init(nilLiteral _: ()){{$}}
 // FOUNDATION-NEXT: {{^}}}{{$}}
 
 // FOUNDATION-LABEL: {{^}}/// Unavailable Global Functions{{$}}

test/IDE/print_clang_framework.swift

@@ -39,12 +39,10 @@
 
 // FOUNDATION-LABEL: {{^}}/// Aaa.  NSPotentiallyUnavailableOptions.  Bbb.
 // FOUNDATION-NEXT: {{^}}@available(OSX 10.10, *){{$}}
-// FOUNDATION-NEXT: {{^}}struct NSPotentiallyUnavailableOptions : RawOptionSetType {{{$}}
+// FOUNDATION-NEXT: {{^}}struct NSPotentiallyUnavailableOptions : OptionSetType {{{$}}
 
 // FOUNDATION-LABEL: {{^}}/// Aaa.  NSOptionsWithUnavailableElement.  Bbb.
-// FOUNDATION-NEXT: {{^}}struct NSOptionsWithUnavailableElement : RawOptionSetType {{{$}}
-// FOUNDATION-NEXT: {{^}}  init(){{$}}
-// FOUNDATION-NEXT: {{^}}  init(_ rawValue: UInt){{$}}
+// FOUNDATION-NEXT: {{^}}struct NSOptionsWithUnavailableElement : OptionSetType {{{$}}
 // FOUNDATION-NEXT: {{^}}  init(rawValue: UInt){{$}}
 // FOUNDATION-NEXT: {{^}}  let rawValue: UInt{{$}}
 // FOUNDATION-NEXT: {{^}}  static var First: NSOptionsWithUnavailableElement { get }{{$}}

test/Interpreter/SDK/Cocoa_enums.swift

@@ -4,12 +4,12 @@
 
 import Foundation
 
-let opts: NSBinarySearchingOptions = .FirstEqual | .InsertionIndex
+let opts: NSBinarySearchingOptions = [.FirstEqual, .InsertionIndex]
 
 // CHECK: true
-print(opts & (.LastEqual | .InsertionIndex) == .InsertionIndex)
+print(opts.intersect([.LastEqual, .InsertionIndex]) == .InsertionIndex)
 // CHECK: false
-print((opts & .LastEqual) != nil)
+print(!opts.intersect(.LastEqual).isEmpty)
 
-// CHECK: {{^}}0 0 0{{$}}
-print("\((nil as NSBinarySearchingOptions).rawValue) \(NSBinarySearchingOptions.allZeros.rawValue) \(NSBinarySearchingOptions(0).rawValue)")
+// CHECK: {{^}}0 0{{$}}
+print("\(([] as NSBinarySearchingOptions).rawValue) \(NSBinarySearchingOptions(rawValue: 0).rawValue)")

test/Interpreter/SDK/KVO.swift

@@ -16,8 +16,8 @@ class Observer : NSObject {
 
   override init() {
     super.init()
-    model.addObserver(self, forKeyPath: "name", options: nil, context: &kvoContext)
-    self.addObserver(self, forKeyPath: "model.number", options: nil, context: &kvoContext)
+    model.addObserver(self, forKeyPath: "name", options: [], context: &kvoContext)
+    self.addObserver(self, forKeyPath: "model.number", options: [], context: &kvoContext)
   }
 
   deinit {
@@ -50,7 +50,7 @@ class Foo: NSObject {
 }
 
 let foo = Foo()
-foo.addObserver(foo, forKeyPath: "foo", options: nil, context: &kvoContext)
+foo.addObserver(foo, forKeyPath: "foo", options: [], context: &kvoContext)
 let bar = foo.foo
 // CHECK-NEXT: 0
 print(bar)

test/Interpreter/SDK/objc_subclass.swift

@@ -106,7 +106,7 @@ testB()
 class MyNSData : NSData {
   init?(base64EncodedString str: String) {
     super.init(base64EncodedString:str, 
-               options:NSDataBase64DecodingOptions(0))
+               options:[])
     print("MyNSData code should not be executed")
   }
 
@@ -127,7 +127,7 @@ if let myNSData = MyNSData(base64EncodedString:"\n\n\n") {
 extension NSData {
   convenience init?(myString str: String) {
     self.init(base64EncodedString:str, 
-              options:NSDataBase64DecodingOptions(0))
+              options:[])
     print("NSData code should not be executed")
   }
 }

test/SILGen/objc_enum.swift

@@ -9,8 +9,6 @@ import gizmo
 // CHECK-DAG: sil shared @_TFOSC16NSRuncingOptionsg8rawValueSi
 // CHECK-DAG: sil shared @_TFOSC16NSRuncingOptionsg9hashValueSi
 
-// CHECK-DAG: sil shared @_TZF5gizmooi2eeFTOSC16NSRuncingOptionsS0__Sb
-
 // CHECK-DAG: sil shared [transparent] @_TFOSC16NSRuncingOptions5MinceFMS_S_
 // CHECK-DAG: sil shared [transparent] @_TFOSC16NSRuncingOptions12QuinceSlicedFMS_S_
 // CHECK-DAG: sil shared [transparent] @_TFOSC16NSRuncingOptions15QuinceJuliennedFMS_S_

test/SILGen/objc_options.swift

@@ -1,14 +0,0 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen %s | FileCheck %s
-
-// REQUIRES: objc_interop
-
-import Foundation
-
-func foo(a: NSKeyValueObservingOptions) -> Bool {
-  return (a ^ a) == nil
-}
-
-// Note: nothing needs the BitwiseOperationsType conformance, so don't emit it
-// CHECK-NOT: sil_witness_table shared NSKeyValueObservingOptions: BitwiseOperationsType module Foundation
-// CHECK: sil_witness_table shared NSKeyValueObservingOptions: _RawOptionSetType module Foundation
-// CHECK-NOT: sil_witness_table shared NSKeyValueObservingOptions: BitwiseOperationsType module Foundation

test/Sema/enum_equatable_hashable.swift

@@ -77,7 +77,7 @@ if .A == getFromOtherFile() {}
 // FIXME: This should work.
 func overloadFromOtherFile() -> YetAnotherFromOtherFile { return .A }
 func overloadFromOtherFile() -> Bool { return false }
-if .A == overloadFromOtherFile() {} // expected-error {{could not find member 'A'}}
+if .A == overloadFromOtherFile() {}
 
 
 // Complex enums are not implicitly Equatable or Hashable.

validation-test/stdlib/UnicodeUTFEncoders.swift

@@ -84,7 +84,7 @@ func nsEncode<CodeUnit>(
     maxLength: buffer.count,
     usedLength: &used,
     encoding: encoding,
-    options: NSStringEncodingConversionOptions(0),
+    options: [],
     range: NSRange(location: 0, length: s.length),
     remainingRange: nil)
 }