Use unavailability instead

Author: rockbruno

include/swift/AST/DiagnosticsParse.def

@@ -909,11 +909,8 @@ WARNING(parameter_unnamed_warn,none,
 ERROR(parameter_curry_syntax_removed,none,
       "cannot have more than one parameter list", ())
 
-ERROR(unavailability_does_not_support_expressions,none,
-      "availability equality only supports boolean literals", ())
-
-ERROR(availability_cannot_be_positive_and_negative_at_same_time,none,
-      "cannot have availability and unavailability in the same statement; result may cause impossible constraints", ())
+ERROR(availability_cannot_be_mixed,none,
+      "#available and #unavailable cannot be in the same statement", ())
 
 ERROR(initializer_as_typed_pattern,none,
       "unexpected initializer in pattern; did you mean to use '='?", ())
@@ -1204,8 +1201,8 @@ ERROR(invalid_float_literal_missing_leading_zero,none,
       "'.%0' is not a valid floating point literal; it must be written '0.%0'",
       (StringRef))
 ERROR(availability_query_outside_if_stmt_guard, none,
-      "#available may only be used as condition of an 'if', 'guard'"
-      " or 'while' statement", ())
+      "%0 may only be used as condition of an 'if', 'guard'"
+      " or 'while' statement", (StringRef))
 
 ERROR(empty_arg_label_underscore, none,
       "an empty argument label is spelled with '_'", ())

include/swift/AST/Stmt.h

@@ -340,8 +340,7 @@ class alignas(8) PoundAvailableInfo final :
   /// This is filled in by Sema.
   VersionRange VariantAvailableRange;
 
-  /// Indicates if the expression is checking if something is **not** available,
-  /// as represented by #available(...) == false.
+  /// Indicates that the expression is checking if something is **not** available.
   bool isUnavailability;
 
   PoundAvailableInfo(SourceLoc PoundLoc, SourceLoc LParenLoc,

include/swift/Parse/Parser.h

@@ -1641,7 +1641,7 @@ class Parser {
                             StringRef &BindingKindStr);
   ParserStatus parseStmtCondition(StmtCondition &Result, Diag<> ID,
                                   StmtKind ParentKind);
-  ParserResult<PoundAvailableInfo> parseStmtConditionPoundAvailable(bool isUnavailability);
+  ParserResult<PoundAvailableInfo> parseStmtConditionPoundAvailable();
   ParserResult<Stmt> parseStmtIf(LabeledStmtInfo LabelInfo,
                                  bool IfWasImplicitlyInserted = false);
   ParserResult<Stmt> parseStmtGuard();

lib/Parse/ParseExpr.cpp

@@ -218,9 +218,8 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
       // so the code is invalid.  We get better recovery if we bail out from
       // this, because then we can produce a fixit to rewrite the && into a ,
       // if we're in a stmt-condition.
-      // FIXME
       if (Tok.getText() == "&&" &&
-          peekToken().isAny(tok::pound_available,
+          peekToken().isAny(tok::pound_available, tok::pound_unavailable,
                             tok::kw_let, tok::kw_var, tok::kw_case))
         goto done;
 
@@ -1636,12 +1635,12 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
   case tok::l_square:
     return parseExprCollection();
 
-  case tok::pound_available: {
+  case tok::pound_available:
+  case tok::pound_unavailable: {
     // For better error recovery, parse but reject #available in an expr
     // context.
-    // FIXME
-    diagnose(Tok.getLoc(), diag::availability_query_outside_if_stmt_guard);
-    auto res = parseStmtConditionPoundAvailable(false);
+    diagnose(Tok.getLoc(), diag::availability_query_outside_if_stmt_guard, Tok.getText());
+    auto res = parseStmtConditionPoundAvailable();
     if (res.hasCodeCompletion())
       return makeParserCodeCompletionStatus();
     if (res.isParseError() || res.isNull())

lib/Parse/ParseStmt.cpp

@@ -1245,15 +1245,21 @@ static void validateAvailabilitySpecList(Parser &P,
   Specs = RecognizedSpecs;
 }
 
-// #available(...) / !#available(...) / #available(...) == true/false
-ParserResult<PoundAvailableInfo> Parser::parseStmtConditionPoundAvailable(bool isUnavailability) {
+// #available(...)
+// #unavailable(...)
+ParserResult<PoundAvailableInfo> Parser::parseStmtConditionPoundAvailable() {
   SyntaxParsingContext ConditonCtxt(SyntaxContext,
                                     SyntaxKind::AvailabilityCondition);
+  SourceLoc PoundLoc;
 
-  if (isUnavailability) {
-    consumeToken(tok::exclaim_postfix);
+  bool isUnavailability;
+  if (Tok.is(tok::pound_available)) {
+    isUnavailability = false;
+    PoundLoc = consumeToken();
+  } else {
+    isUnavailability = true;
+    PoundLoc = consumeToken(tok::pound_unavailable);
   }
-  SourceLoc PoundLoc = consumeToken(tok::pound_available);
 
   if (!Tok.isFollowingLParen()) {
     diagnose(Tok, diag::avail_query_expected_condition);
@@ -1287,22 +1293,6 @@ ParserResult<PoundAvailableInfo> Parser::parseStmtConditionPoundAvailable(bool i
                          diag::avail_query_expected_rparen, LParenLoc))
     Status.setIsParseError();
 
-  // == true/false
-  if (Tok.isAnyOperator() && Tok.getText() == "==") {
-    consumeToken();
-    if (Tok.is(tok::kw_false)) {
-        // Treat double negation from
-        // !#available(...) == false
-        isUnavailability = !isUnavailability;
-        consumeToken();
-    } else if (Tok.is(tok::kw_true)) {
-      consumeToken();
-    } else {
-      diagnose(Tok, diag::unavailability_does_not_support_expressions);
-      Status.setIsParseError();
-    }
-  }
-
   auto *result = PoundAvailableInfo::create(Context, PoundLoc, LParenLoc, Specs,
                                             RParenLoc, isUnavailability);
   return makeParserResult(Status, result);
@@ -1398,9 +1388,8 @@ Parser::parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,
   ParserStatus Status;
 
   // Parse a leading #available condition if present.
-  if (Tok.is(tok::pound_available) || (Tok.is(tok::exclaim_postfix) && 
-      peekToken().is(tok::pound_available))) {
-    auto res = parseStmtConditionPoundAvailable(Tok.is(tok::exclaim_postfix));
+  if (Tok.isAny(tok::pound_available, tok::pound_unavailable)) {
+    auto res = parseStmtConditionPoundAvailable();
     if (res.isNull() || res.hasCodeCompletion()) {
       Status |= res;
       return Status;

lib/Sema/BuilderTransform.cpp

@@ -1232,6 +1232,7 @@ class BuilderClosureRewriter
     // have had the chance to adopt buildLimitedAvailability(), we'll upgrade
     // this warning to an error.
     if (auto availabilityCond = findAvailabilityCondition(ifStmt->getCond())) {
+      // FIXME: #unavailable
       SourceLoc loc = availabilityCond->getStartLoc();
       Type thenBodyType = solution.simplifyType(
           solution.getType(target.captured.second[0]));

lib/Sema/TypeCheckAvailability.cpp

@@ -437,13 +437,17 @@ class TypeRefinementContextBuilder : private ASTWalker {
       // condition elements following it.
       auto *Query = Element.getAvailability();
 
-      // Prevent availability and unavailability from mixing, like
-      // if #available(...) == false, #available(...)
       if (isRefiningUnavailability == None) {
         isRefiningUnavailability = Query->getIsUnavailability();
       } else if (isRefiningUnavailability != Query->getIsUnavailability()) {
+        // Mixing availability with unavailability in the same statement will
+        // cause the false flow's version range to be ambiguous. Report it.
+        //
+        // Technically we can support this by not refining ambiguous flows,
+        // but there are currently no legitimate cases where one would have
+        // to mix availability with unavailability.
         Context.Diags.diagnose(Query->getLoc(),
-        diag::availability_cannot_be_positive_and_negative_at_same_time);
+        diag::availability_cannot_be_mixed);
         break;
       }
 
@@ -546,6 +550,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
       ++NestedCount;
     }
 
+
     Optional<AvailabilityContext> FalseRefinement = None;
     // The version range for the false branch should never have any versions
     // that weren't possible when the condition started evaluating.
@@ -569,7 +574,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
     if (!isRefiningUnavailability.hasValue() || !isRefiningUnavailability.getValue()) {
       return std::make_pair(NestedTRC->getAvailabilityInfo(), FalseRefinement);
     } else {
-      // If this is an unavailability check, simply invert the result.
+      // If this is an unavailability check, invert the result.
       return std::make_pair(FalseRefinement, NestedTRC->getAvailabilityInfo());
     }
   }

test/Parse/availability_query.swift

@@ -12,6 +12,11 @@ let x = #available(OSX 10.51, *)  // expected-error {{#available may only be use
 
 (#available(OSX 10.51, *) ? 1 : 0) // expected-error {{#available may only be used as condition of an}}
 
+if !#available(OSX 10.52, *) { // expected-error {{#available may only be used as condition of an}}
+}
+if let _ = Optional(5), !#available(OSX 10.52, *) { // expected-error {{#available may only be used as condition}}
+}
+
 if #available(OSX 10.51, *) && #available(OSX 10.52, *) { // expected-error {{expected ',' joining parts of a multi-clause condition}} {{28-31=,}}
 }
 
@@ -103,21 +108,3 @@ if let _ = Optional(42), #available(iOS 8.0, *) {}
 // Allow "macOS" as well.
 if #available(macOS 10.51, *) {
 }
-
-// Negative availability.
-//if !#available(OSX 10.52, *) {
-//}
-//if let _ = Optional(5), !#available(OSX 10.52, *) {
-//}
-//if !#available(OSX 10.52, *), let _ = Optional(5) {
-//}
-if let _ = Optional(5), #available(OSX 10.52, *) == false {
-}
-if #available(OSX 10.52, *) == false, let _ = Optional(5) {
-}
-if #available(macOS 10.51, *) == false {
-}
-
-// Allow verbose positive form as well.
-if #available(macOS 10.51, *) == true {
-}

test/Parse/availability_query_unavailablility.swift

@@ -0,0 +1,134 @@
+// RUN: %target-typecheck-verify-swift
+
+// REQUIRES: OS=macosx
+
+// This file is mostly an inverted version of availability_query.swift
+
+if #unavailable(OSX 10.51, *) {
+}
+
+// Disallow use as an expression.
+if (#unavailable(OSX 10.51, *)) {}  // expected-error {{#unavailable may only be used as condition of an 'if', 'guard'}}
+
+let x = #unavailable(OSX 10.51, *)  // expected-error {{#unavailable may only be used as condition of}}
+
+(#unavailable(OSX 10.51, *) ? 1 : 0) // expected-error {{#unavailable may only be used as condition of an}}
+
+if !unavailable(OSX 10.52, *) { // expected-error {{#unavailable may only be used as condition of an}}
+}
+if let _ = Optional(5), !unavailable(OSX 10.52, *) { // expected-error {{#unavailable may only be used as condition}}
+}
+
+if #unavailable(OSX 10.51, *) && #unavailable(OSX 10.52, *) { // expected-error {{expected ',' joining parts of a multi-clause condition}} {{30-33=,}}
+}
+
+
+if #unavailable { // expected-error {{expected availability condition}} expected-error {{closure expression is unused}} expected-error {{top-level statement cannot begin with a closure expression}} expected-note {{did you mean to use a 'do' statement?}} {{17-17=do }}
+}
+
+if #unavailable( { // expected-error {{expected platform name}} expected-error {{expected ')'}} expected-note {{to match this opening '('}}
+}
+
+if #unavailable() { // expected-error {{expected platform name}}
+}
+
+if #unavailable(OSX { // expected-error {{expected version number}} expected-error {{expected ')'}} expected-note {{to match this opening '('}}
+}
+
+if #unavailable(OSX) { // expected-error {{expected version number}}
+}
+
+if #unavailable(OSX 10.51 { // expected-error {{expected ')'}} expected-note {{to match this opening '('}} expected-error {{must handle potential future platforms with '*'}} {{26-26=, *}}
+}
+
+if #unavailable(iDishwasherOS 10.51) { // expected-warning {{unrecognized platform name 'iDishwasherOS'}}
+// expected-error@-1 {{must handle potential future platforms with '*'}}
+}
+
+if #unavailable(iDishwasherOS 10.51, *) { // expected-warning {{unrecognized platform name 'iDishwasherOS'}}
+}
+
+if #unavailable(OSX 10.51, OSX 10.52, *) {  // expected-error {{version for 'macOS' already specified}}
+}
+
+if #unavailable(OSX 10.52) { }  // expected-error {{must handle potential future platforms with '*'}} {{26-26=, *}}
+
+if #unavailable(OSX 10.51, iOS 8.0) { }  // expected-error {{must handle potential future platforms with '*'}} {{35-35=, *}}
+
+if #unavailable(iOS 8.0, *) {
+}
+
+if #unavailable(iOSApplicationExtension, unavailable) { // expected-error 2{{expected version number}}
+}
+	
+// Want to make sure we can parse this. Perhaps we should not let this validate, though.
+if #unavailable(*) {
+}
+
+if #unavailable(* { // expected-error {{expected ')' in availability query}} expected-note {{to match this opening '('}}
+}
+
+// Multiple platforms
+if #unavailable(OSX 10.51, iOS 8.0, *) {
+}
+
+
+if #unavailable(OSX 10.51, { // expected-error {{expected platform name}} // expected-error {{expected ')'}} expected-note {{to match this opening '('}}
+}
+
+if #unavailable(OSX 10.51,) { // expected-error {{expected platform name}}
+}
+
+if #unavailable(OSX 10.51, iOS { // expected-error {{expected version number}} // expected-error {{expected ')'}} expected-note {{to match this opening '('}}
+}
+
+if #unavailable(OSX 10.51, iOS 8.0, iDishwasherOS 10.51) { // expected-warning {{unrecognized platform name 'iDishwasherOS'}}
+// expected-error@-1 {{must handle potential future platforms with '*'}}
+}
+
+if #unavailable(iDishwasherOS 10.51, OSX 10.51) { // expected-warning {{unrecognized platform name 'iDishwasherOS'}}
+// expected-error@-1 {{must handle potential future platforms with '*'}}
+}
+
+if #unavailable(OSX 10.51 || iOS 8.0) {// expected-error {{'||' cannot be used in an availability condition}}
+}
+
+// Emit Fix-It removing un-needed >=, for the moment.
+
+if #unavailable(OSX >= 10.51, *) { // expected-error {{version comparison not needed}} {{21-24=}}
+}
+
+// <rdar://problem/20904820> Following a "let" condition with #unavailable is incorrectly rejected
+
+// Bool then #unavailable.
+if 1 != 2, #unavailable(iOS 8.0, *) {}
+
+// Pattern then #unavailable(iOS 8.0, *) {
+if case 42 = 42, #unavailable(iOS 8.0, *) {}
+if let _ = Optional(42), #unavailable(iOS 8.0, *) {}
+
+// Allow "macOS" as well.
+if #unavailable(macOS 10.51, *) {
+}
+
+// Prevent availability and unavailability being present in the same statement.
+if #unavailable(macOS 10.51, *), #available(macOS 10.52, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+if #available(macOS 10.51, *), #unavailable(macOS 10.52, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+if #available(macOS 10.51, *), #available(macOS 10.55, *), #unavailable(macOS 10.53, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+if #unavailable(macOS 10.51, *), #unavailable(macOS 10.55, *), #available(macOS 10.53, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+if case 42 = 42, #available(macOS 10.51, *), #unavailable(macOS 10.52, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+if #available(macOS 10.51, *), case 42 = 42, #unavailable(macOS 10.52, *) { // expected-error {{#available and #unavailable cannot be in the same statement}}
+}
+
+// Allow availabiility and unavailability to mix if they are not in the same statement.
+if #unavailable(macOS 11, *) {
+  if #available(macOS 10, *) { }
+}
+if #available(macOS 10, *) {
+  if #unavailable(macOS 11, *) { }
+}

test/attr/attr_availability_unavailability.swift

@@ -0,0 +1,48 @@
+// RUN: %target-typecheck-verify-swift -parse-as-library
+// REQUIRES: OS=macosx
+
+@available(OSX 998.0, *)
+@discardableResult
+func foo() -> Int { return 0 }
+
+@available(OSX 999.0, *)
+@discardableResult
+func bar() -> Int { return 0 }
+
+// Verify that #unavailable is the opposite of #available.
+// expected-note@+1 *{{add @available attribute to enclosing global function}}
+func testUnavailable() {
+  if #unavailable(OSX 998.0, *) {
+    foo() // expected-error{{'foo()' is only available in macOS 998.0 or newer}}
+    // expected-note@-1 {{add 'if #available' version check}}
+    bar() // expected-error{{'bar()' is only available in macOS 999.0 or newer}}
+    // expected-note@-1 {{add 'if #available' version check}}
+  } else {
+    foo()
+    bar() // expected-error{{'bar()' is only available in macOS 999.0 or newer}}
+    // expected-note@-1 {{add 'if #available' version check}}
+    if #unavailable(OSX 999.0, *) {
+      foo()
+      bar() // expected-error{{'bar()' is only available in macOS 999.0 or newer}}
+      // expected-note@-1 {{add 'if #available' version check}}
+    } else {
+      foo()
+      bar()
+    }
+  }
+}
+
+// Verify that #unavailable doesn't complain about useless specs.
+// expected-note@+1 *{{add @available attribute to enclosing global function}}
+func testUnavailableDoesntWarnUselessSpecs() {
+  if #unavailable(OSX 998.0, *), #unavailable(OSX 999.0, *) {
+    foo() // expected-error{{'foo()' is only available in macOS 998.0 or newer}}
+    // expected-note@-1 {{add 'if #available' version check}}
+    bar() // expected-error{{'bar()' is only available in macOS 999.0 or newer}}
+    // expected-note@-1 {{add 'if #available' version check}}
+  } else {
+    foo()
+    bar()
+  }
+}
+