[Sema] Remove DisableExprAvailabilityChecking

Author: hamishknight

include/swift/Sema/ConstraintSystem.h

@@ -6519,9 +6519,8 @@ bool hasResultExpr(ClosureExpr *closure);
 
 /// Emit diagnostics for syntactic restrictions within a given solution
 /// application target.
-void performSyntacticDiagnosticsForTarget(
-    const SyntacticElementTarget &target, bool isExprStmt,
-    bool disableExprAvailabilityChecking = false);
+void performSyntacticDiagnosticsForTarget(const SyntacticElementTarget &target,
+                                          bool isExprStmt);
 
 /// Given a member of a protocol, check whether `Self` type of that
 /// protocol is contextually bound to some concrete type via same-type

lib/Sema/MiscDiagnostics.cpp

@@ -6373,7 +6373,7 @@ diagnoseDictionaryLiteralDuplicateKeyEntries(const Expr *E,
 void swift::performSyntacticExprDiagnostics(
     const Expr *E, const DeclContext *DC,
     std::optional<ContextualTypePurpose> contextualPurpose, bool isExprStmt,
-    bool disableExprAvailabilityChecking, bool disableOutOfPlaceExprChecking) {
+    bool disableOutOfPlaceExprChecking) {
   auto &ctx = DC->getASTContext();
   TypeChecker::diagnoseSelfAssignment(E);
   diagSyntacticUseRestrictions(E, DC, isExprStmt);
@@ -6385,7 +6385,7 @@ void swift::performSyntacticExprDiagnostics(
   diagnoseComparisonWithNaN(E, DC);
   if (!ctx.isSwiftVersionAtLeast(5))
     diagnoseDeprecatedWritableKeyPath(E, DC);
-  if (!ctx.LangOpts.DisableAvailabilityChecking && !disableExprAvailabilityChecking)
+  if (!ctx.LangOpts.DisableAvailabilityChecking)
     diagnoseExprAvailability(E, const_cast<DeclContext*>(DC));
   if (ctx.LangOpts.EnableObjCInterop)
     diagDeprecatedObjCSelectors(DC, E);

lib/Sema/MiscDiagnostics.h

@@ -52,7 +52,6 @@ namespace swift {
   void performSyntacticExprDiagnostics(
       const Expr *E, const DeclContext *DC,
       std::optional<ContextualTypePurpose> contextualPurpose, bool isExprStmt,
-      bool disableExprAvailabilityChecking = false,
       bool disableOutOfPlaceExprChecking = false);
 
   /// Emit diagnostics for a given statement.

lib/Sema/TypeCheckConstraints.cpp

@@ -341,7 +341,6 @@ class FunctionSyntacticDiagnosticWalker : public ASTWalker {
     // We skip out-of-place expr checking here since we've already performed it.
     performSyntacticExprDiagnostics(expr, dcStack.back(), /*ctp*/ std::nullopt,
                                     /*isExprStmt=*/false,
-                                    /*disableAvailabilityChecking*/ false,
                                     /*disableOutOfPlaceExprChecking*/ true);
 
     if (auto closure = dyn_cast<ClosureExpr>(expr)) {
@@ -383,15 +382,14 @@ class FunctionSyntacticDiagnosticWalker : public ASTWalker {
 } // end anonymous namespace
 
 void constraints::performSyntacticDiagnosticsForTarget(
-    const SyntacticElementTarget &target, bool isExprStmt,
-    bool disableExprAvailabilityChecking) {
+    const SyntacticElementTarget &target, bool isExprStmt) {
   auto *dc = target.getDeclContext();
   switch (target.kind) {
   case SyntacticElementTarget::Kind::expression: {
     // First emit diagnostics for the main expression.
-    performSyntacticExprDiagnostics(
-        target.getAsExpr(), dc, target.getExprContextualTypePurpose(),
-        isExprStmt, disableExprAvailabilityChecking);
+    performSyntacticExprDiagnostics(target.getAsExpr(), dc,
+                                    target.getExprContextualTypePurpose(),
+                                    isExprStmt);
     return;
   }
 
@@ -400,8 +398,7 @@ void constraints::performSyntacticDiagnosticsForTarget(
 
     // First emit diagnostics for the main expression.
     performSyntacticExprDiagnostics(stmt->getTypeCheckedSequence(), dc,
-                                    CTP_ForEachSequence, isExprStmt,
-                                    disableExprAvailabilityChecking);
+                                    CTP_ForEachSequence, isExprStmt);
 
     if (auto *whereExpr = stmt->getWhere())
       performSyntacticExprDiagnostics(whereExpr, dc, CTP_Condition,
@@ -544,9 +541,7 @@ TypeChecker::typeCheckTarget(SyntacticElementTarget &target,
   // expression now.
   if (!cs.shouldSuppressDiagnostics()) {
     bool isExprStmt = options.contains(TypeCheckExprFlags::IsExprStmt);
-    performSyntacticDiagnosticsForTarget(
-        *resultTarget, isExprStmt,
-        options.contains(TypeCheckExprFlags::DisableExprAvailabilityChecking));
+    performSyntacticDiagnosticsForTarget(*resultTarget, isExprStmt);
   }
 
   return *resultTarget;

lib/Sema/TypeChecker.h

@@ -131,15 +131,12 @@ enum class TypeCheckExprFlags {
   /// not affect type checking itself.
   IsExprStmt = 0x02,
 
-  /// Don't type check expressions for correct availability.
-  DisableExprAvailabilityChecking = 0x04,
-
   /// Don't expand macros.
-  DisableMacroExpansions = 0x08,
+  DisableMacroExpansions = 0x04,
 
   /// If set, typeCheckExpression will avoid invalidating the AST if
   /// type-checking fails. Do not add new uses of this.
-  AvoidInvalidatingAST = 0x10,
+  AvoidInvalidatingAST = 0x08,
 };
 
 using TypeCheckExprOptions = OptionSet<TypeCheckExprFlags>;