[gardening]: remove unnecessary semicolons (#316)

aalemayhu · parkera · commit 9f4651a4fee0 · 2016-04-14T13:17:30.000-07:00
No intended functionality change.
diff --git a/Foundation/FoundationErrors.swift b/Foundation/FoundationErrors.swift
@@ -207,39 +207,39 @@ public extension NSCocoaError {
     }
     
     public var isCoderError: Bool {
-        return rawValue >= 4864 && rawValue <= 4991;
+        return rawValue >= 4864 && rawValue <= 4991
     }
     
     public var isExecutableError: Bool {
-        return rawValue >= 3584 && rawValue <= 3839;
+        return rawValue >= 3584 && rawValue <= 3839
     }
     
     public var isFileError: Bool {
-        return rawValue >= 0 && rawValue <= 1023;
+        return rawValue >= 0 && rawValue <= 1023
     }
     
     public var isFormattingError: Bool {
-        return rawValue >= 2048 && rawValue <= 2559;
+        return rawValue >= 2048 && rawValue <= 2559
     }
     
     public var isPropertyListError: Bool {
-        return rawValue >= 3840 && rawValue <= 4095;
+        return rawValue >= 3840 && rawValue <= 4095
     }
     
     public var isUbiquitousFileError: Bool {
-        return rawValue >= 4352 && rawValue <= 4607;
+        return rawValue >= 4352 && rawValue <= 4607
     }
     
     public var isUserActivityError: Bool {
-        return rawValue >= 4608 && rawValue <= 4863;
+        return rawValue >= 4608 && rawValue <= 4863
     }
     
     public var isValidationError: Bool {
-        return rawValue >= 1024 && rawValue <= 2047;
+        return rawValue >= 1024 && rawValue <= 2047
     }
     
     public var isXPCConnectionError: Bool {
-        return rawValue >= 4096 && rawValue <= 4224;
+        return rawValue >= 4096 && rawValue <= 4224
     }
 }
 
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
@@ -148,7 +148,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
             aCoder.encodeObject(self.locale, forKey: "NS.locale")
             aCoder.encodeInteger(self.firstWeekday, forKey: "NS.firstwkdy")
             aCoder.encodeInteger(self.minimumDaysInFirstWeek, forKey: "NS.mindays")
-            aCoder.encodeObject(self._startDate, forKey: "NS.gstartdate");
+            aCoder.encodeObject(self._startDate, forKey: "NS.gstartdate")
         } else {
             NSUnimplemented()
         }
@@ -368,7 +368,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         if r.location == kCFNotFound {
             return NSMakeRange(NSNotFound, NSNotFound)
         }
-        return NSMakeRange(r.location, r.length);
+        return NSMakeRange(r.location, r.length)
     }
     
     public func ordinalityOfUnit(_ smaller: NSCalendarUnit, inUnit larger: NSCalendarUnit, forDate date: NSDate) -> Int {
diff --git a/Foundation/NSKeyedArchiver.swift b/Foundation/NSKeyedArchiver.swift
@@ -196,7 +196,7 @@ public class NSKeyedArchiver : NSCoder {
                                           kCFPropertyListOpenStepFormat, 0, nil) > 0
         }
         
-        return success;
+        return success
     }
     
     private func _writeBinaryData(_ plist : NSDictionary) -> Bool {
@@ -205,7 +205,7 @@ public class NSKeyedArchiver : NSCoder {
     
     public func finishEncoding() {
         if _flags.contains(ArchiverFlags.FinishedEncoding) {
-            return;
+            return
         }
 
         var plist = Dictionary<String, Any>()
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
@@ -568,7 +568,7 @@ public class NSKeyedUnarchiver : NSCoder {
      */
     public func finishDecoding() {
         if _flags.contains(UnarchiverFlags.FinishedDecoding) {
-            return;
+            return
         }
         
         if let unwrappedDelegate = self.delegate {
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
@@ -271,7 +271,7 @@ extension NSRegularExpression {
             var length = str.length
             while (orderOfMagnitude < numberOfRanges && numberOfDigits < 20) {
                 numberOfDigits += 1
-                orderOfMagnitude *= 10;
+                orderOfMagnitude *= 10
             }
             while range.length > 0 {
                 var c = str.characterAtIndex(range.location)
diff --git a/Foundation/NSScanner.swift b/Foundation/NSScanner.swift
@@ -91,7 +91,7 @@ internal struct _NSStringBuffer {
         stringLen = end
     
         if _stringLoc < stringLen {
-            bufferLen = min(32, stringLen - _stringLoc);
+            bufferLen = min(32, stringLen - _stringLoc)
             let range = NSMakeRange(_stringLoc, bufferLen)
             bufferLoc = 1
             buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
@@ -111,7 +111,7 @@ internal struct _NSStringBuffer {
         stringLen = end
         
         if _stringLoc < stringLen {
-            bufferLen = min(32, stringLen - _stringLoc);
+            bufferLen = min(32, stringLen - _stringLoc)
             let range = NSMakeRange(_stringLoc, bufferLen)
             bufferLoc = 1
             buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
@@ -134,7 +134,7 @@ internal struct _NSStringBuffer {
     }
     
     mutating func fill() {
-        bufferLen = min(32, stringLen - _stringLoc);
+        bufferLen = min(32, stringLen - _stringLoc)
         let range = NSMakeRange(_stringLoc, bufferLen)
         buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
             string.getCharacters(ptr.baseAddress!, range: range)
@@ -271,7 +271,7 @@ private func numericOrHexValue(_ ch: unichar) -> Int {
     } else if (ch >= unichar(unicodeScalarLiteral: "a") && ch <= unichar(unicodeScalarLiteral: "f")) {
         return Int(ch) + 10 - Int(unichar(unicodeScalarLiteral: "a"))
     } else {
-        return -1;
+        return -1
     }
 }
 
diff --git a/Foundation/NSXMLDTDNode.swift b/Foundation/NSXMLDTDNode.swift
@@ -117,7 +117,7 @@ public class NSXMLDTDNode : NSXMLNode {
                 return .NSXMLEntityParsedKind
                 
             default:
-                fatalError("Invalid entity declaration type");
+                fatalError("Invalid entity declaration type")
             }
             
         case _kCFXMLDTDNodeTypeAttribute:
diff --git a/Foundation/NSXMLDocument.swift b/Foundation/NSXMLDocument.swift
@@ -162,7 +162,7 @@ public class NSXMLDocument : NSXMLNode {
     */
     public var documentContentKind: NSXMLDocumentContentKind  {
         get {
-            let properties = _CFXMLDocProperties(_xmlDoc);
+            let properties = _CFXMLDocProperties(_xmlDoc)
 
             if properties & Int32(_kCFXMLDocTypeHTML) != 0 {
                 return .HTMLKind
@@ -197,7 +197,7 @@ public class NSXMLDocument : NSXMLNode {
     */
     /*@NSCopying*/ public var DTD: NSXMLDTD? {
         get {
-            return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc)!);
+            return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc)!)
         }
         set {
             if let currDTD = _CFXMLDocDTD(_xmlDoc) {
diff --git a/Foundation/NSXMLNode.swift b/Foundation/NSXMLNode.swift
@@ -717,7 +717,7 @@ public class NSXMLNode : NSObject, NSCopying {
     */
     public func nodesForXPath(_ xpath: String) throws -> [NSXMLNode] {
         guard let nodes = _CFXMLNodesForXPath(_xmlNode, xpath) else {
-            NSUnimplemented();
+            NSUnimplemented()
         }
 
         var result: [NSXMLNode] = []
diff --git a/TestFoundation/TestNSArray.swift b/TestFoundation/TestNSArray.swift
@@ -380,7 +380,7 @@ class TestNSArray : XCTestCase {
             return l < r ? .OrderedAscending : (l > r ? .OrderedSame : .OrderedDescending)
         }
 
-        XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers);
+        XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers)
 
         // check that it works in the way self.sortWithOptions([], usingComparator: cmptr) does
         let inputStrings = ["this", "is", "a", "test", "of", "sort", "with", "strings"]
diff --git a/TestFoundation/TestNSNotificationQueue.swift b/TestFoundation/TestNSNotificationQueue.swift
@@ -130,7 +130,7 @@ class TestNSNotificationQueue : XCTestCase {
         let queue = NSNotificationQueue.defaultQueue()
         queue.enqueueNotification(notification, postingStyle: .PostASAP)
 
-        scheduleTimer(withInterval: 0.001); // run timer trigger the notifications
+        scheduleTimer(withInterval: 0.001) // run timer trigger the notifications
         XCTAssertEqual(numberOfCalls, 1)
     }
 
@@ -147,7 +147,7 @@ class TestNSNotificationQueue : XCTestCase {
         queue.enqueueNotification(notification, postingStyle: .PostASAP)
         queue.enqueueNotification(notification, postingStyle: .PostASAP)
 
-        scheduleTimer(withInterval: 0.001);
+        scheduleTimer(withInterval: 0.001)
         XCTAssertEqual(numberOfCalls, 1)
     }
 
@@ -176,7 +176,7 @@ class TestNSNotificationQueue : XCTestCase {
         queue.enqueueNotification(notification2, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnName, forModes: nil)
         // #5
         queue.enqueueNotification(notification1, postingStyle: .PostASAP,  coalesceMask: .CoalescingOnSender, forModes: nil)
-        scheduleTimer(withInterval: 0.001);
+        scheduleTimer(withInterval: 0.001)
         // check that we received notifications #4 and #5
         XCTAssertEqual(numberOfNameCoalescingCalls, 1)
         XCTAssertEqual(numberOfObjectCoalescingCalls, 1)
@@ -194,7 +194,7 @@ class TestNSNotificationQueue : XCTestCase {
         }
         NSNotificationQueue.defaultQueue().enqueueNotification(notification, postingStyle: .PostWhenIdle)
         // add a timer to wakeup the runloop, process the timer and call the observer awaiting for any input sources/timers
-        scheduleTimer(withInterval: 0.001);
+        scheduleTimer(withInterval: 0.001)
         XCTAssertEqual(numberOfCalls, 1)
     }
 
diff --git a/TestFoundation/TestNSNumber.swift b/TestFoundation/TestNSNumber.swift
@@ -74,7 +74,7 @@ class TestNSNumber : XCTestCase {
         XCTAssertEqual(NSNumber(char: Int8(0)).unsignedIntValue, UInt32(0))
         XCTAssertEqual(NSNumber(char: Int8(0)).longLongValue, Int64(0))
         XCTAssertEqual(NSNumber(char: Int8(0)).unsignedLongLongValue, UInt64(0))
-        XCTAssertEqual(NSNumber(char: Int8(-37)).boolValue, true);
+        XCTAssertEqual(NSNumber(char: Int8(-37)).boolValue, true)
         XCTAssertEqual(NSNumber(char: Int8(-37)).charValue, Int8(-37))
 #if !(os(Linux) && arch(arm))
         // Linux/arm chars are unsigned, so Int8 in Swift, until this issue is resolved, these tests will always fail.
@@ -184,7 +184,7 @@ class TestNSNumber : XCTestCase {
         XCTAssertEqual(NSNumber(short: Int16(0)).unsignedIntValue, UInt32(0))
         XCTAssertEqual(NSNumber(short: Int16(0)).longLongValue, Int64(0))
         XCTAssertEqual(NSNumber(short: Int16(0)).unsignedLongLongValue, UInt64(0))
-        XCTAssertEqual(NSNumber(short: Int16(-37)).boolValue, true);
+        XCTAssertEqual(NSNumber(short: Int16(-37)).boolValue, true)
         XCTAssertEqual(NSNumber(short: Int16(-37)).charValue, Int8(-37))
         XCTAssertEqual(NSNumber(short: Int16(-37)).shortValue, Int16(-37))
         XCTAssertEqual(NSNumber(short: Int16(-37)).intValue, Int32(-37))
@@ -218,7 +218,7 @@ class TestNSNumber : XCTestCase {
         XCTAssertEqual(NSNumber(float: Float(0)).unsignedIntValue, UInt32(0))
         XCTAssertEqual(NSNumber(float: Float(0)).longLongValue, Int64(0))
         XCTAssertEqual(NSNumber(float: Float(0)).unsignedLongLongValue, UInt64(0))
-        XCTAssertEqual(NSNumber(float: Float(-37)).boolValue, true);
+        XCTAssertEqual(NSNumber(float: Float(-37)).boolValue, true)
         XCTAssertEqual(NSNumber(float: Float(-37)).charValue, Int8(-37))
         XCTAssertEqual(NSNumber(float: Float(-37)).shortValue, Int16(-37))
         XCTAssertEqual(NSNumber(float: Float(-37)).intValue, Int32(-37))
@@ -250,7 +250,7 @@ class TestNSNumber : XCTestCase {
         XCTAssertEqual(NSNumber(double: Double(0)).unsignedIntValue, UInt32(0))
         XCTAssertEqual(NSNumber(double: Double(0)).longLongValue, Int64(0))
         XCTAssertEqual(NSNumber(double: Double(0)).unsignedLongLongValue, UInt64(0))
-        XCTAssertEqual(NSNumber(double: Double(-37)).boolValue, true);
+        XCTAssertEqual(NSNumber(double: Double(-37)).boolValue, true)
         XCTAssertEqual(NSNumber(double: Double(-37)).charValue, Int8(-37))
         XCTAssertEqual(NSNumber(double: Double(-37)).shortValue, Int16(-37))
         XCTAssertEqual(NSNumber(double: Double(-37)).intValue, Int32(-37))
diff --git a/TestFoundation/TestNSRegularExpression.swift b/TestFoundation/TestNSRegularExpression.swift
diff --git a/TestFoundation/TestNSTimeZone.swift b/TestFoundation/TestNSTimeZone.swift

Original file line number	Diff line number	Diff line change
`@@ -207,39 +207,39 @@ public extension NSCocoaError {`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`public var isCoderError: Bool {`
`210`		`- return rawValue >= 4864 && rawValue <= 4991;`
	`210`	`+ return rawValue >= 4864 && rawValue <= 4991`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`public var isExecutableError: Bool {`
`214`		`- return rawValue >= 3584 && rawValue <= 3839;`
	`214`	`+ return rawValue >= 3584 && rawValue <= 3839`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`public var isFileError: Bool {`
`218`		`- return rawValue >= 0 && rawValue <= 1023;`
	`218`	`+ return rawValue >= 0 && rawValue <= 1023`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`public var isFormattingError: Bool {`
`222`		`- return rawValue >= 2048 && rawValue <= 2559;`
	`222`	`+ return rawValue >= 2048 && rawValue <= 2559`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`public var isPropertyListError: Bool {`
`226`		`- return rawValue >= 3840 && rawValue <= 4095;`
	`226`	`+ return rawValue >= 3840 && rawValue <= 4095`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`public var isUbiquitousFileError: Bool {`
`230`		`- return rawValue >= 4352 && rawValue <= 4607;`
	`230`	`+ return rawValue >= 4352 && rawValue <= 4607`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`public var isUserActivityError: Bool {`
`234`		`- return rawValue >= 4608 && rawValue <= 4863;`
	`234`	`+ return rawValue >= 4608 && rawValue <= 4863`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`public var isValidationError: Bool {`
`238`		`- return rawValue >= 1024 && rawValue <= 2047;`
	`238`	`+ return rawValue >= 1024 && rawValue <= 2047`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`public var isXPCConnectionError: Bool {`
`242`		`- return rawValue >= 4096 && rawValue <= 4224;`
	`242`	`+ return rawValue >= 4096 && rawValue <= 4224`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {`
`148`	`148`	`aCoder.encodeObject(self.locale, forKey: "NS.locale")`
`149`	`149`	`aCoder.encodeInteger(self.firstWeekday, forKey: "NS.firstwkdy")`
`150`	`150`	`aCoder.encodeInteger(self.minimumDaysInFirstWeek, forKey: "NS.mindays")`
`151`		`- aCoder.encodeObject(self._startDate, forKey: "NS.gstartdate");`
	`151`	`+ aCoder.encodeObject(self._startDate, forKey: "NS.gstartdate")`
`152`	`152`	`} else {`
`153`	`153`	`NSUnimplemented()`
`154`	`154`	`}`
`@@ -368,7 +368,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {`
`368`	`368`	`if r.location == kCFNotFound {`
`369`	`369`	`return NSMakeRange(NSNotFound, NSNotFound)`
`370`	`370`	`}`
`371`		`- return NSMakeRange(r.location, r.length);`
	`371`	`+ return NSMakeRange(r.location, r.length)`
`372`	`372`	`}`
`373`	`373`
`374`	`374`	`public func ordinalityOfUnit(_ smaller: NSCalendarUnit, inUnit larger: NSCalendarUnit, forDate date: NSDate) -> Int {`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ public class NSKeyedArchiver : NSCoder {`
`196`	`196`	`kCFPropertyListOpenStepFormat, 0, nil) > 0`
`197`	`197`	`}`
`198`	`198`
`199`		`- return success;`
	`199`	`+ return success`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`private func _writeBinaryData(_ plist : NSDictionary) -> Bool {`
`@@ -205,7 +205,7 @@ public class NSKeyedArchiver : NSCoder {`
`205`	`205`
`206`	`206`	`public func finishEncoding() {`
`207`	`207`	`if _flags.contains(ArchiverFlags.FinishedEncoding) {`
`208`		`- return;`
	`208`	`+ return`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`var plist = Dictionary<String, Any>()`
Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ public class NSKeyedUnarchiver : NSCoder {`
`568`	`568`	`*/`
`569`	`569`	`public func finishDecoding() {`
`570`	`570`	`if _flags.contains(UnarchiverFlags.FinishedDecoding) {`
`571`		`- return;`
	`571`	`+ return`
`572`	`572`	`}`
`573`	`573`
`574`	`574`	`if let unwrappedDelegate = self.delegate {`
Original file line number	Diff line number	Diff line change
`@@ -271,7 +271,7 @@ extension NSRegularExpression {`
`271`	`271`	`var length = str.length`
`272`	`272`	`while (orderOfMagnitude < numberOfRanges && numberOfDigits < 20) {`
`273`	`273`	`numberOfDigits += 1`
`274`		`- orderOfMagnitude *= 10;`
	`274`	`+ orderOfMagnitude *= 10`
`275`	`275`	`}`
`276`	`276`	`while range.length > 0 {`
`277`	`277`	`var c = str.characterAtIndex(range.location)`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ public class NSXMLDTDNode : NSXMLNode {`
`117`	`117`	`return .NSXMLEntityParsedKind`
`118`	`118`
`119`	`119`	`default:`
`120`		`- fatalError("Invalid entity declaration type");`
	`120`	`+ fatalError("Invalid entity declaration type")`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`case _kCFXMLDTDNodeTypeAttribute:`
Original file line number	Diff line number	Diff line change
`@@ -717,7 +717,7 @@ public class NSXMLNode : NSObject, NSCopying {`
`717`	`717`	`*/`
`718`	`718`	`public func nodesForXPath(_ xpath: String) throws -> [NSXMLNode] {`
`719`	`719`	`guard let nodes = _CFXMLNodesForXPath(_xmlNode, xpath) else {`
`720`		`- NSUnimplemented();`
	`720`	`+ NSUnimplemented()`
`721`	`721`	`}`
`722`	`722`
`723`	`723`	`var result: [NSXMLNode] = []`
Original file line number	Diff line number	Diff line change
`@@ -380,7 +380,7 @@ class TestNSArray : XCTestCase {`
`380`	`380`	`return l < r ? .OrderedAscending : (l > r ? .OrderedSame : .OrderedDescending)`
`381`	`381`	`}`
`382`	`382`
`383`		`- XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers);`
	`383`	`+ XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers)`
`384`	`384`
`385`	`385`	`// check that it works in the way self.sortWithOptions([], usingComparator: cmptr) does`
`386`	`386`	`let inputStrings = ["this", "is", "a", "test", "of", "sort", "with", "strings"]`