[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 specially 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);
 
+    // In the past we perhaps tried a bit too hard to avoid emitting a load,
+    // which led to this bug: https://github.com/swiftlang/swift/issues/74478.
+    if (LE->getType()->isStructurallyUninhabited()) {
+      // If the lvalue is structurally uninhabited, we emit the load so that
+      // DI will not miss potential uses before initialization. It should not
+      // be possible to ever really load such a value, so this should result
+      // in some form of downstream error.
+
+      // TODO: check if this seems like the right emission & params
+      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

@@ -1667,3 +1667,30 @@ 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 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}}
+  }
+}