NSNull: fix === returning false when both operands are nil (#5486)

The current `===(NSNull?, NSNull?)` overload uses
`guard let _ = lhs, let _ = rhs` and falls through to `return false`
when either operand is nil. That makes `nil === nil` return false,
contradicting the standard identity-operator contract. Two non-nil
NSNull instances still compare ===, so the existing test_alwaysEqual
case continues to pass.

Replace the guard with a switch over the optional pair so the cases
are explicit: (nil, nil) is true, mixed-nil is false, and two non-nil
NSNull instances remain identical (preserving the singleton-like
behavior). Add a matching !== overload so the symmetric operator
agrees with === for the NSNull? signature. Without it, Swift's
default !== for AnyObject? would return true for two distinct NSNull
instances even though === says they are identical.

Resolves #5248.

Author: ayush-that

Sources/Foundation/NSNull.swift

@@ -44,6 +44,16 @@ open class NSNull : NSObject, NSCopying, NSSecureCoding, @unchecked Sendable {
 }
 
 public func ===(lhs: NSNull?, rhs: NSNull?) -> Bool {
-    guard let _ = lhs, let _ = rhs else { return false }
-    return true
+    switch (lhs, rhs) {
+    case (nil, nil):
+        return true
+    case (nil, _), (_, nil):
+        return false
+    default:
+        return true
+    }
+}
+
+public func !==(lhs: NSNull?, rhs: NSNull?) -> Bool {
+    return !(lhs === rhs)
 }

Tests/Foundation/TestNSNull.swift

@@ -11,23 +11,44 @@ class TestNSNull : XCTestCase {
     func test_alwaysEqual() {
         let null_1 = NSNull()
         let null_2 = NSNull()
-        
+
         let null_3: NSNull? = NSNull()
         let null_4: NSNull? = nil
-        
+
         //Check that any two NSNull's are ==
         XCTAssertEqual(null_1, null_2)
 
         //Check that any two NSNull's are ===, preserving the singleton behavior
         XCTAssertTrue(null_1 === null_2)
-        
+        XCTAssertFalse(null_1 !== null_2)
+
         //Check that NSNull() == .Some(NSNull)
         XCTAssertEqual(null_1, null_3)
-        
+
         //Make sure that NSNull() != .None
-        XCTAssertNotEqual(null_1, null_4)        
+        XCTAssertNotEqual(null_1, null_4)
     }
-    
+
+    func test_identityOperator() {
+        let null_1: NSNull? = NSNull()
+        let null_2: NSNull? = NSNull()
+        let null_nil: NSNull? = nil
+
+        //Check that two non-nil NSNull values are ===
+        XCTAssertTrue(null_1 === null_2)
+        XCTAssertFalse(null_1 !== null_2)
+
+        //Check that nil === nil for the NSNull? overload
+        XCTAssertTrue(null_nil === null_nil)
+        XCTAssertFalse(null_nil !== null_nil)
+
+        //Check that a non-nil NSNull is not === to nil in either order
+        XCTAssertFalse(null_1 === null_nil)
+        XCTAssertFalse(null_nil === null_1)
+        XCTAssertTrue(null_1 !== null_nil)
+        XCTAssertTrue(null_nil !== null_1)
+    }
+
     func test_description() {
         XCTAssertEqual(NSNull().description, "<null>")
     }