[SILGen]: extend uninhabited parameter checks to self param

SILGenProlog contains logic to emit an unreachable location if a
function contains a structurally uninhabited parameter. This change
extends this logic to include the `self` parameter, so instance members
of structurally uninhabited types will produce the same diagnostics and
have the same SIL emission behavior.

Author: jamieQ

lib/SILGen/SILGenProlog.cpp

@@ -1382,20 +1382,28 @@ void SILGenFunction::emitProlog(
 
   emitExpectedExecutorProlog();
 
-  // IMPORTANT: This block should be the last one in `emitProlog`,
-  // since it terminates BB and no instructions should be insterted after it.
-  // Emit an unreachable instruction if a parameter type is
-  // uninhabited
-  if (paramList) {
-    for (auto *param : *paramList) {
-      if (param->getTypeInContext()->isStructurallyUninhabited()) {
-        SILLocation unreachableLoc(param);
-        unreachableLoc.markAsPrologue();
-        B.createUnreachable(unreachableLoc);
-        break;
-      }
-    }
-  }
+  // Emits an unreachable instruction if a parameter type (including `self`) is
+  // uninhabited. Returns `true` if an unreachable location was created.
+  auto handleUninhabitedParam = [&](ParamDecl *param) -> bool {
+    if (!param->getTypeInContext()->isStructurallyUninhabited())
+      return false;
+
+    SILLocation unreachableLoc(param);
+    unreachableLoc.markAsPrologue();
+    B.createUnreachable(unreachableLoc);
+    return true;
+  };
+
+  // IMPORTANT: An unreachable block should be the last one in `emitProlog`,
+  // since it is a terminator and no instructions should be insterted after it.
+  if (selfParam)
+    if (handleUninhabitedParam(selfParam))
+      return;
+
+  if (paramList)
+    for (auto *param : *paramList)
+      if (handleUninhabitedParam(param))
+        return;
 }
 
 static void emitIndirectPackParameter(SILGenFunction &SGF,

test/SILGen/functions_uninhabited_param.swift

@@ -42,3 +42,42 @@ func empty_custom_product(_ xs: (E, Int)) { // expected-note {{'xs' is of type '
   print() // expected-warning{{will never be executed}}
 }
 
+//===--- Uninhabited self parameters
+
+extension Never {
+  var unreachableComputed: Int { // expected-note{{'self' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    42 // expected-warning{{will never be executed}}
+  }
+
+  subscript(_ i: Int) -> Int { // expected-note{{'self' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    42 // expected-warning{{will never be executed}}
+  }
+
+  func unreachableMethod() -> Int { // expected-note{{'self' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    42 // expected-warning{{will never be executed}}
+  }
+
+  func unreachableMethodWithParam(_ x: Int) -> Int { // expected-note{{'self' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    42 // expected-warning{{will never be executed}}
+  }
+
+  func unreachableMethodWithUninhabitedParam(_ p0: Int, _ p1: Self, _ p2: Never) -> Int { // expected-note{{'p1' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    42 // expected-warning{{will never be executed}}
+  }
+
+  func unreachableWithNestedDecls() -> Int { // expected-note{{'self' is of type 'Never' which cannot be constructed because it is an enum with no cases}}
+    func g() -> Int { 42 }
+    let c = { g() } // expected-warning{{will never be executed}}
+    return c()
+  }
+}
+
+protocol P {
+  var prop: Int { get }
+  func uncallable(_ n: Never)
+}
+
+extension Never: P {
+  var prop: Int { fatalError() }
+  func uncallable(_ n: Never) {}
+}