[TypeChecker] SE-360: Add support for if #unavailable

Lift a temporary restriction and make `if #available`
and `if #unavailable` behave consistently.

Author: xedin

lib/IRGen/GenMeta.cpp

@@ -2335,6 +2335,7 @@ namespace {
 
               assert(condition.first.hasLowerEndpoint());
 
+              bool isUnavailability = condition.second;
               auto version = condition.first.getLowerEndpoint();
               auto *major = getInt32Constant(version.getMajor());
               auto *minor = getInt32Constant(version.getMinor());
@@ -2348,6 +2349,13 @@ namespace {
               auto success = IGF.Builder.CreateICmpNE(
                   isAtLeast, llvm::Constant::getNullValue(IGM.Int32Ty));
 
+              if (isUnavailability) {
+                // Invert the result of "at least" check by xor'ing resulting
+                // boolean with `-1`.
+                success =
+                    IGF.Builder.CreateXor(success, IGF.Builder.getIntN(1, -1));
+              }
+
               auto nextCondOrRet = condIndex == conditions.size() - 1
                                        ? returnTypeBB
                                        : conditionBlocks[condIndex + 1];

lib/Sema/MiscDiagnostics.cpp

@@ -2886,12 +2886,10 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         return {true, S};
       }
 
-      // If this is `if #available` statement with no other dynamic
+      // If this is `if #(un)available` statement with no other dynamic
       // conditions, let's check if it returns opaque type directly.
       if (llvm::all_of(If->getCond(), [&](const auto &condition) {
-            return condition.getKind() ==
-                       StmtConditionElement::CK_Availability &&
-                   !condition.getAvailability()->isUnavailability();
+            return condition.getKind() == StmtConditionElement::CK_Availability;
           })) {
         // Check return statement directly with availability context set.
         if (auto *Then = dyn_cast<BraceStmt>(If->getThenStmt())) {

test/Serialization/Inputs/opaque_with_limited_availability.swift

@@ -52,6 +52,14 @@ public func test() -> some P {
   return Empty()
 }
 
+public func testUnavailable() -> some P {
+  if #unavailable(macOS 100.0.1) {
+    return Tuple<(Int, Int)>((0, 1))
+  }
+
+  return Empty()
+}
+
 public func test_return_from_conditional() -> some P {
   if #available(macOS 10.15, *) {
     return Named()

test/Serialization/opaque_with_availability_cross_module.swift

@@ -45,3 +45,7 @@ Test().sayHello()
 let conditionalR = LimitedAvailOpaque.test_return_from_conditional()
 conditionalR.hello()
 // CHECK: Hello from Named
+
+let unavailableTest = LimitedAvailOpaque.testUnavailable()
+unavailableTest.hello()
+// CHECK: Hello from Tuple

test/type/opaque_with_conditional_availability.swift

@@ -107,14 +107,14 @@ func test_fail_without_universally_available_type() -> some P {
   }
 }
 
-// Treat `if #unavailable` like regular conditions.
-func test_fail_with_unavailability_condition() -> some P {
-  // expected-error@-1 {{function declares an opaque return type 'some P', but the return statements in its body do not have matching underlying types}}
-  // expected-note@-2 {{add @available attribute to enclosing global function}}
+func test_unavailability_condition() -> some P {
   if #unavailable(macOS 12) {
-    return X() // expected-error {{'X' is only available in macOS 11.0 or newer}} expected-note {{return statement has underlying type 'X'}}
-    // expected-note@-1 {{add 'if #available' version check}}
+    return Y()
   }
 
-  return Y() // expected-note {{return statement has underlying type 'Y'}}
+  if #available(macOS 16, *) {
+    return X()
+  }
+
+  return Z()
 }