[diagnose-unreachable] Fix incorrect diagnostic on keypath creation

If the property referred to by the final component of a KeyPath is a
type that is considered uninhabited by the compiler (e.g. caseless enums),
we currently emit an unreachable code warning at the location of the KeyPath
expression. This warning is emitted by the NoReturnFolding pass of the SILOptimizer
when it checks the property getter function generated for the KeyPath. This
change fixes the issue by emitting keypath accessor functions with artificial
SILLocations so that the diagnostics pass will skip it as non-user-written code.

rdar://80415811

Author: Josh Learn

lib/SILGen/SILGenExpr.cpp

@@ -2692,7 +2692,6 @@ getRepresentativeAccessorForKeyPath(AbstractStorageDecl *storage) {
 }
 
 static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
-                         SILLocation loc,
                          AbstractStorageDecl *property,
                          SubstitutionMap subs,
                          GenericEnvironment *genericEnv,
@@ -2759,6 +2758,8 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
   auto name = Mangle::ASTMangler()
     .mangleKeyPathGetterThunkHelper(property, genericSig, baseType,
                                     subs, expansion);
+  auto loc = RegularLocation::getAutoGeneratedLocation();
+
   SILGenFunctionBuilder builder(SGM);
   auto thunk = builder.getOrCreateSharedFunction(
       loc, name, signature, IsBare, IsNotTransparent,
@@ -2806,7 +2807,6 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
   auto baseSubstValue = emitKeyPathRValueBase(subSGF, property,
                                                loc, baseArg,
                                                baseType, subs);
-  
   auto subscriptIndices =
     loadIndexValuesForKeyPathComponent(subSGF, loc, property,
                                        indexes, indexPtrArg);
@@ -2832,7 +2832,6 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
 }
 
 static SILFunction *getOrCreateKeyPathSetter(SILGenModule &SGM,
-                          SILLocation loc,
                           AbstractStorageDecl *property,
                           SubstitutionMap subs,
                           GenericEnvironment *genericEnv,
@@ -2907,6 +2906,7 @@ static SILFunction *getOrCreateKeyPathSetter(SILGenModule &SGM,
   auto name = Mangle::ASTMangler()
     .mangleKeyPathSetterThunkHelper(property, genericSig, baseType,
                                     subs, expansion);
+  auto loc = RegularLocation::getAutoGeneratedLocation();
 
   SILGenFunctionBuilder builder(SGM);
   auto thunk = builder.getOrCreateSharedFunction(
@@ -3536,13 +3536,13 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
     // expected by the key path runtime.
     auto id = getIdForKeyPathComponentComputedProperty(*this, var,
                                                        strategy);
-    auto getter = getOrCreateKeyPathGetter(*this, loc,
+    auto getter = getOrCreateKeyPathGetter(*this,
              var, subs,
              needsGenericContext ? genericEnv : nullptr,
              expansion, {}, baseTy, componentTy);
 
     if (isSettableInComponent()) {
-      auto setter = getOrCreateKeyPathSetter(*this, loc,
+      auto setter = getOrCreateKeyPathSetter(*this,
              var, subs,
              needsGenericContext ? genericEnv : nullptr,
              expansion, {}, baseTy, componentTy);
@@ -3587,7 +3587,7 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
     }
 
     auto id = getIdForKeyPathComponentComputedProperty(*this, decl, strategy);
-    auto getter = getOrCreateKeyPathGetter(*this, loc,
+    auto getter = getOrCreateKeyPathGetter(*this,
              decl, subs,
              needsGenericContext ? genericEnv : nullptr,
              expansion,
@@ -3596,7 +3596,7 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
 
     auto indexPatternsCopy = getASTContext().AllocateCopy(indexPatterns);
     if (isSettableInComponent()) {
-      auto setter = getOrCreateKeyPathSetter(*this, loc,
+      auto setter = getOrCreateKeyPathSetter(*this,
              decl, subs,
              needsGenericContext ? genericEnv : nullptr,
              expansion,

test/SILGen/sil_locations.swift

@@ -417,3 +417,29 @@ func testWhile() {
 
 
 }
+
+// Check that the sil location of keypath getter/setter functions is
+// marked as autogenerated.
+struct Struct {
+  var structProperty: InnerStruct {
+    get { InnerStruct() }
+    set(newStruct) { }
+  }
+
+  struct InnerStruct {}
+}
+
+func testKeyPathGetterSetterAutogen() -> Struct.InnerStruct {
+  let kp = \Struct.structProperty
+  var s = Struct()
+  let innerS = Struct.InnerStruct()
+
+  s[keyPath: kp] = innerS
+  return s[keyPath: kp]
+  // Autogenerated keypath getter
+  // CHECK-LABEL: sil shared [thunk] [ossa] @$s13sil_locations6StructV14structProperty{{[_0-9a-zA-Z]*}}TK
+  // CHECK: load {{.*}} loc "<compiler-generated>":0:0{{.*}}<invalid loc>:auto_gen
+  // Autogenerated keypath setter
+  // CHECK-LABEL: sil shared [thunk] [ossa] @$s13sil_locations6StructV14structProperty{{[_0-9a-zA-Z]*}}Tk
+  // CHECK: load {{.*}} loc "<compiler-generated>":0:0{{.*}}<invalid loc>:auto_gen
+}

test/SILOptimizer/diagnose_unreachable.swift

@@ -470,3 +470,48 @@ extension Collection {
   }
 }
 
+// rdar://80415811
+// Incorrect unreachable code diagnostic for keypath to empty Enum caused by
+// the generated keypath getter function having an uninhabited return type.
+// The getter function was previously tied to the source location of the
+// corresponding keypath expression, which caused it to be diagnosed as
+// user code. The getter and setter functions now have an autogenerated
+// source location so we should not expect an unreachable code warning until
+// the keypath expression is actually used.
+struct StructWithNeverProp {
+  var property: Never {
+    fatalError()
+  }
+}
+
+func keypathToEmptyEnum() -> Never {
+  // Check that the generated keypath getter function for this property
+  // does not trigger an unreachable code warning here.
+  let kp = \StructWithNeverProp.property // no warning
+  let s = StructWithNeverProp()
+  // Emit a diagnostic here becase the keypath is actually used.
+  let prop = s[keyPath: kp]
+    // expected-warning@-1 {{will never be executed}} \
+    // expected-note {{a call to a never-returning function}} \
+    // expected-warning {{constant 'prop' inferred to have type 'Never', which is an enum with no cases}} \
+    // expected-note {{add an explicit type annotation to silence this warning}}
+  return prop
+}
+
+struct OuterStruct {
+  public let innerEnum: InnerEnum
+  public enum InnerEnum { }
+}
+
+@dynamicMemberLookup
+public enum DynamicLookupEnum {
+    subscript<T>(dynamicMember keyPath: KeyPath<OuterStruct, T>) -> T {
+        fatalError()
+    }
+}
+
+func keypathWithDynamicLookup() {
+  // Check that we still don't diagnose the keypath getter as unreachable
+  // when used in conjuction with a dynamicMemberLookup enum.
+  let _ = \DynamicLookupEnum.innerEnum // no warning
+}