[SILGen]: Emit ignored loads of uninhabited lvalues to address DI edge cases

Previously we would crash on this pattern:

```swift
let x: Never
switch x {}
```

This appears to be due to the fact that the switch over the uninhabited
value did not result in any instructions DI considers a use being
produced. This change adds special handling of this case so that we
now emit a load of the value so DI correctly diagnoses the use before
init.

Author: jamieQ

lib/SILGen/SILGenExpr.cpp

@@ -7628,6 +7628,19 @@ void SILGenFunction::emitIgnoredExpr(Expr *E) {
   if (auto *LE = dyn_cast<LoadExpr>(E)) {
     LValue lv = emitLValue(LE->getSubExpr(), SGFAccessKind::IgnoredRead);
 
+    if (LE->getType()->isStructurallyUninhabited()) {
+      // If the lvalue is structurally uninhabited, we emit the load so that
+      // DI will see any uses before initialization. It should not be possible
+      // to ever really load such a value, so this should result in some sort
+      // of downstream error.
+      //
+      // Failure to do this in the past resulted in this bug:
+      // https://github.com/swiftlang/swift/issues/74478.
+
+      emitLoadOfLValue(E, std::move(lv), SGFContext::AllowImmediatePlusZero);
+      return;
+    }
+
     // If loading from the lvalue is guaranteed to have no side effects, we
     // don't need to drill into it.
     if (lv.isLoadingPure())

test/SILOptimizer/definite_init_diagnostics.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -enable-copy-propagation=requested-passes-only -emit-sil -primary-file %s -o /dev/null -verify
+// RUN: %target-swift-emit-sil -enable-copy-propagation=requested-passes-only -primary-file %s -o /dev/null -verify
 
 import Swift
 
@@ -1667,3 +1667,52 @@ final class HasInitAccessors {
     ints.append(0)
   }
 }
+
+// https://github.com/swiftlang/swift/issues/74478
+
+func structurallyUninhabitedLvalueSwitch() {
+
+  enum NeverEver {}
+
+  func gh_74478() {
+    let x: Never // expected-note {{constant defined here}}
+    switch x {} // expected-error {{constant 'x' used before being initialized}}
+  }
+
+  func nested_switch() {
+    let x: Never // expected-note {{constant defined here}}
+    let y: Never = switch () {
+      default:
+        switch x { // expected-error {{constant 'x' used before being initialized}}
+          default: x
+        }
+    }
+    _ = y
+  }
+
+  func customNever() {
+    let x: NeverEver // expected-note {{constant defined here}}
+    switch x {} // expected-error {{constant 'x' used before being initialized}}
+  }
+
+  func structurallyUninhabited() {
+    let x: (Int, Never, Bool) // expected-note {{constant defined here}}
+    switch x {} // expected-error {{constant 'x.0' used before being initialized}}
+  }
+
+  func structurallyUninhabited_variant1() {
+    let x: (Int, NeverEver, Bool) // expected-note {{constant defined here}}
+    switch x.2 { default: fatalError() } // expected-error {{constant 'x.2' used before being initialized}}
+  }
+}
+
+protocol P_74478 {
+  associatedtype A
+}
+
+extension P_74478 where A == (Int, (Bool, Never)) {
+  func structurallyUninhabitedGenericIndirection() {
+    let x: A // expected-note {{constant defined here}}
+    switch x {} // expected-error {{constant 'x.0' used before being initialized}}
+  }
+}