SILOptimizer: Suppress unreachable code diagnostics for unavailable stubs.

User code should not be diagnosed as "unreachable" by the SIL optimizer when
the no-return function that made the code unreachable is a compiler inserted
call to `_diagnoseUnavailableCodeReached()`.

Part of rdar://107388493

Author: tshortli

include/swift/SIL/ApplySite.h

@@ -241,6 +241,12 @@ class ApplySite {
     FOREACH_IMPL_RETURN(isCalleeKnownProgramTerminationPoint());
   }
 
+  /// Returns true if the callee function is annotated with
+  /// @_semantics("unavailable_code_reached")
+  bool isCalleeUnavailableCodeReached() const {
+    FOREACH_IMPL_RETURN(isCalleeUnavailableCodeReached());
+  }
+
   /// Check if this is a call of a never-returning function.
   bool isCalleeNoReturn() const { FOREACH_IMPL_RETURN(isCalleeNoReturn()); }
 

include/swift/SIL/SILInstruction.h

@@ -2777,6 +2777,14 @@ class ApplyInstBase<Impl, Base, false> : public Base {
     return calleeFn->hasSemanticsAttr(SEMANTICS_PROGRAMTERMINATION_POINT);
   }
 
+  /// Returns true if the callee function is annotated with
+  /// @_semantics("unavailable_code_reached")
+  bool isCalleeUnavailableCodeReached() const {
+    auto calleeFn = getCalleeFunction();
+    if (!calleeFn) return false;
+    return calleeFn->hasSemanticsAttr(SEMANTICS_UNAVAILABLE_CODE_REACHED);
+  }
+
   /// True if this application has generic substitutions.
   bool hasSubstitutions() const {
     return Substitutions.hasAnySubstitutableParams();

include/swift/Strings.h

@@ -60,6 +60,9 @@ constexpr static const StringLiteral SEMANTICS_PROGRAMTERMINATION_POINT =
 constexpr static const StringLiteral SEMANTICS_DEFAULT_ACTOR =
     "defaultActor";
 
+constexpr static const StringLiteral SEMANTICS_UNAVAILABLE_CODE_REACHED =
+    "unavailable_code_reached";
+
 constexpr static const StringLiteral DEFAULT_ACTOR_STORAGE_FIELD_NAME =
     "$defaultActor";
 

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -724,6 +724,14 @@ static SILInstruction *getPrecedingCallToNoReturn(SILBasicBlock &BB) {
   return first;
 }
 
+static bool isUnavailableCodeReachedCall(SILInstruction *I) {
+  if (auto *AI = dyn_cast<ApplyInst>(I))
+    if (AI->hasSemantics(SEMANTICS_UNAVAILABLE_CODE_REACHED))
+      return true;
+
+  return false;
+}
+
 static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
                                      UnreachableUserCodeReportingState *State) {
   auto I = BB.begin(), E = BB.end();
@@ -766,6 +774,13 @@ static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
         noReturnCall->getLoc().isASTNode<ExplicitCastExpr>())
       return false;
 
+    // If the no-return instruction is a call to the unavailable code reached
+    // diagnostic function then we assume that the call was inserted by the
+    // compiler because the function is semantically unavailable. Diagnosing the
+    // user written body of the function as unreachable would be redundant.
+    if (isUnavailableCodeReachedCall(noReturnCall))
+      return false;
+
     diagnose(BB.getModule().getASTContext(), currInst->getLoc().getSourceLoc(),
              diag::unreachable_code);
     diagnose(BB.getModule().getASTContext(),

test/SILOptimizer/unavailable_decl_optimization_stub.swift

@@ -0,0 +1,16 @@
+// RUN: %target-swift-emit-sil -module-name Test -parse-as-library %s -verify -unavailable-decl-optimization=stub | %FileCheck %s --check-prefixes=CHECK
+
+public struct S {}
+
+// CHECK-LABEL: sil {{.*}} @$s4Test15unavailableFuncAA1SVyF
+// CHECK:         [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyF
+// CHECK-NEXT:    [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK-NEXT:    unreachable
+// CHECK-NEXT:  end sil function '$s4Test15unavailableFuncAA1SVyF'
+@available(*, unavailable)
+public func unavailableFunc() -> S {
+
+  // No warning should be produced for this code even though the compiler
+  // inserted call to _diagnoseUnavailableCodeReached() makes it unreachable.
+  return S()
+}