SILOptimizer: handle copies in LetPropertiesOpt.

When the initializer of a property is analyzed we now don't bail if such a property is copied from another instance of a struct/class.

This fixes a strange performance regression with constant let properties in structs which conform to an unrelated protocol.

SR-7713
rdar://problem/40332203

Author: eeckstein

lib/SILOptimizer/IPO/LetPropertiesOpts.cpp

@@ -388,6 +388,16 @@ bool LetPropertiesOpt::isConstantLetProperty(VarDecl *Property) {
   return true;
 }
 
+static bool isProjectionOfProperty(SILValue addr, VarDecl *Property) {
+  if (auto *REA = dyn_cast<RefElementAddrInst>(addr)) {
+    return REA->getField() == Property;
+  }
+  if (auto *SEA = dyn_cast<StructElementAddrInst>(addr)) {
+    return SEA->getField() == Property;
+  }
+  return false;
+}
+
 // Analyze the init value being stored by the instruction into a property.
 bool
 LetPropertiesOpt::analyzeInitValue(SILInstruction *I, VarDecl *Property) {
@@ -398,15 +408,19 @@ LetPropertiesOpt::analyzeInitValue(SILInstruction *I, VarDecl *Property) {
   } else if (auto SI = dyn_cast<StoreInst>(I)) {
     auto Dest = stripAddressAccess(SI->getDest());
 
-    assert(((isa<RefElementAddrInst>(Dest) &&
-             cast<RefElementAddrInst>(Dest)->getField() == Property) ||
-            (isa<StructElementAddrInst>(Dest) &&
-             cast<StructElementAddrInst>(Dest)->getField() == Property)) &&
-           "Store instruction should store into a proper let property");
+    assert(isProjectionOfProperty(stripAddressAccess(SI->getDest()), Property)
+           && "Store instruction should store into a proper let property");
     (void) Dest;
     value = SI->getSrc();
   }
 
+  // Check if it's just a copy from another instance of the struct.
+  if (auto *LI = dyn_cast<LoadInst>(value)) {
+    SILValue addr = LI->getOperand();
+    if (isProjectionOfProperty(addr, Property))
+      return true;
+  }
+
   // Bail if a value of a property is not a statically known constant init.
   if (!analyzeStaticInitializer(value, ReverseInsns))
     return false;

test/SILOptimizer/let_properties_opts.swift

@@ -354,3 +354,25 @@ public func useInitializers() -> StructWithPublicAndInternalLetProperties {
 public func useInitializers() -> StructWithPublicAndInternalAndPrivateLetProperties {
   return StructWithPublicAndInternalAndPrivateLetProperties(1, 1)
 }
+
+struct RACStruct {
+    private let end = 27
+    
+    var startIndex: Int { return 0 }
+
+
+    // CHECK-LABEL: RACStruct.endIndex.getter
+    // CHECK-NEXT: sil hidden @{{.*}}endIndexSivg
+    // CHECK-NEXT: bb0
+    // CHECK-NEXT:   %1 = integer_literal $Builtin.Int{{.*}}, 27
+    // CHECK-NEXT:   %2 = struct $Int (%1 : $Builtin.Int{{.*}})
+    // CHECK-NEXT:   return %2 : $Int
+    var endIndex: Int { return end }
+    
+    subscript(_ bitIndex: Int) -> Bool {
+        get { return false }
+        set { }
+    }
+}
+
+extension RACStruct : RandomAccessCollection {}