[SILOptimizer] Don't diagnose unreachable instructions that belong to no-return func

The pass is attempting to diagnose any user-written code that appears
after the result of no-return function call. It has to skip any
instructions that happen after the no-return call but are associated
with it, such as `alloc_stack` to pass result of such call indirectly.

This helps to avoid extraneous diagnostics for synthesized code i.e.
a result builder with `buildExpression`:

```
static func buildExpression<T>(_ e: T) -> T { e }
```

The following example would produce extraneous warning:

```
switch <value> {
case ...
default: fatalError()
}
```

because it is translated into:

```
switch <value> {
case ...
default: {
  var $__builderDefault = buildExpression(fatalError())
  $__builderSwitch = buildEither(second: $__builderDefault)
}
}
```

In such cases all instructions that follow `fatalError()` call
are synthesized except to `alloc_stack $Never` which is passed
to `buildExpression`, that instruction is anchored on the
`fatalError()` itself which is where the diagnostic would point,
which is incorrect.

Resolves: rdar://104775183

Author: xedin

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -745,6 +745,42 @@ static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
   // function, the entire block is dead.
   NoReturnCall = getPrecedingCallToNoReturn(BB);
 
+  // Diagnose the unreachable code within the same block as the call to
+  // noreturn.
+  auto diagnoseUnreachableCode = [&](SILInstruction *noReturnCall,
+                                     SILInstruction *currInst) {
+    if (DiagnosedUnreachableCode)
+      return false;
+
+    // If current instruction belongs to a no-return call itself, skip it.
+    // It could happen when result has to be copied.
+    if (currInst->getLoc().hasSameSourceLocation(noReturnCall->getLoc()))
+      return false;
+
+    if (!isUserCode(currInst))
+      return false;
+
+    // If we have an instruction that is an end_borrow, ignore it. This
+    // happens when passing a guaranteed argument through generic code paths
+    // to no return functions.
+    if (isa<EndBorrowInst>(currInst))
+      return false;
+
+    // If no-return instruction is not something we can point in code or
+    // it's an explicit cast, skip it.
+    if (!noReturnCall->getLoc().is<RegularLocation>() ||
+        noReturnCall->getLoc().isASTNode<ExplicitCastExpr>())
+      return false;
+
+    diagnose(BB.getModule().getASTContext(), currInst->getLoc().getSourceLoc(),
+             diag::unreachable_code);
+    diagnose(BB.getModule().getASTContext(),
+             noReturnCall->getLoc().getSourceLoc(),
+             diag::call_to_noreturn_note);
+
+    return true;
+  };
+
   // Does this block contain a call to a noreturn function?
   while (I != E) {
     auto *CurrentInst = &*I;
@@ -758,26 +794,8 @@ static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
       // We will need to delete the instruction later on.
       ToBeDeleted.push_back(CurrentInst);
 
-      // Diagnose the unreachable code within the same block as the call to
-      // noreturn.
-      if (isUserCode(CurrentInst) && !DiagnosedUnreachableCode) {
-        // If we have an instruction that is an end_borrow, ignore it. This
-        // happens when passing a guaranteed argument through generic code paths
-        // to no return functions.
-        if (!isa<EndBorrowInst>(CurrentInst)) {
-          if (NoReturnCall->getLoc().is<RegularLocation>()) {
-            if (!NoReturnCall->getLoc().isASTNode<ExplicitCastExpr>()) {
-              diagnose(BB.getModule().getASTContext(),
-                       CurrentInst->getLoc().getSourceLoc(),
-                       diag::unreachable_code);
-              diagnose(BB.getModule().getASTContext(),
-                       NoReturnCall->getLoc().getSourceLoc(),
-                       diag::call_to_noreturn_note);
-              DiagnosedUnreachableCode = true;
-            }
-          }
-        }
-      }
+      DiagnosedUnreachableCode |=
+          diagnoseUnreachableCode(NoReturnCall, CurrentInst);
 
       // We are going to bluntly remove these instructions. Change uses in
       // different basic blocks to undef. This is safe because all control flow

test/SILOptimizer/diagnose_unreachable.swift

@@ -518,3 +518,55 @@ func keypathWithDynamicLookup() {
   // when used in conjunction with a dynamicMemberLookup enum.
   let _ = \DynamicLookupEnum.innerEnum // no warning
 }
+
+func test_no_warnings_with_fatalError_when_wrapped_in_buildExpression() {
+  enum Either<T,U> {
+    case first(T)
+    case second(U)
+  }
+
+  @resultBuilder
+  struct MyBuilder {
+    static func buildExpression<T>(_ e: T) -> T { e }
+    static func buildBlock() -> () { }
+
+    static func buildBlock<T1>(_ t1: T1) -> T1 {
+      return t1
+    }
+
+    static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> (T1, T2) {
+      return (t1, t2)
+    }
+
+    static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3) -> (T1, T2, T3) {
+      return (t1, t2, t3)
+    }
+
+    static func buildEither<T,U>(first value: T) -> Either<T, U> {
+      return .first(value)
+    }
+
+    static func buildEither<T,U>(second value: U) -> Either<T, U> {
+      return .second(value)
+    }
+  }
+
+  func test<T>(@MyBuilder _: (Int) -> T) {}
+
+  test {
+    if $0 < 0 {
+      fatalError() // ok, no warning even though fatalError() is wrapped
+    } else if $0 > 0 {
+      42
+    } else {
+      0
+    }
+  }
+
+  test {
+    switch $0 {
+    case 0: "0"
+    default: fatalError() // Ok, no warning even though fatalError() is wrapped
+    }
+  }
+}