IRGen: Don't attempt to outline value operations on existentials that contain local archetypes

Fixes rdar://problem/118437883.

Author: slavapestov

lib/IRGen/GenExistential.cpp

@@ -247,7 +247,7 @@ namespace {
 
     void assignWithCopy(IRGenFunction &IGF, Address dest, Address src, SILType T,
                         bool isOutlined) const override {
-      if (isOutlined) {
+      if (isOutlined || T.hasLocalArchetype()) {
         Address destValue = projectValue(IGF, dest);
         Address srcValue = projectValue(IGF, src);
         asDerived().emitValueAssignWithCopy(IGF, destValue, srcValue);
@@ -262,7 +262,7 @@ namespace {
 
     void initializeWithCopy(IRGenFunction &IGF, Address dest, Address src,
                             SILType T, bool isOutlined) const override {
-      if (isOutlined) {
+      if (isOutlined || T.hasLocalArchetype()) {
         Address destValue = projectValue(IGF, dest);
         Address srcValue = projectValue(IGF, src);
         asDerived().emitValueInitializeWithCopy(IGF, destValue, srcValue);
@@ -277,7 +277,7 @@ namespace {
 
     void assignWithTake(IRGenFunction &IGF, Address dest, Address src, SILType T,
                         bool isOutlined) const override {
-      if (isOutlined) {
+      if (isOutlined || T.hasLocalArchetype()) {
         Address destValue = projectValue(IGF, dest);
         Address srcValue = projectValue(IGF, src);
         asDerived().emitValueAssignWithTake(IGF, destValue, srcValue);
@@ -292,7 +292,7 @@ namespace {
 
     void initializeWithTake(IRGenFunction &IGF, Address dest, Address src,
                             SILType T, bool isOutlined) const override {
-      if (isOutlined) {
+      if (isOutlined || T.hasLocalArchetype()) {
         Address destValue = projectValue(IGF, dest);
         Address srcValue = projectValue(IGF, src);
         asDerived().emitValueInitializeWithTake(IGF, destValue, srcValue);
@@ -307,7 +307,7 @@ namespace {
 
     void destroy(IRGenFunction &IGF, Address existential, SILType T,
                  bool isOutlined) const override {
-      if (isOutlined) {
+      if (isOutlined || T.hasLocalArchetype()) {
         Address valueAddr = projectValue(IGF, existential);
         asDerived().emitValueDestroy(IGF, valueAddr);
       } else {
@@ -955,7 +955,7 @@ class OpaqueExistentialTypeInfo final :
 
   void initializeWithCopy(IRGenFunction &IGF, Address dest, Address src,
                           SILType T, bool isOutlined) const override {
-    if (isOutlined) {
+    if (isOutlined || T.hasLocalArchetype()) {
       llvm::Value *metadata = copyType(IGF, dest, src);
 
       auto layout = getLayout();
@@ -977,7 +977,7 @@ class OpaqueExistentialTypeInfo final :
 
   void initializeWithTake(IRGenFunction &IGF, Address dest, Address src,
                           SILType T, bool isOutlined) const override {
-    if (isOutlined) {
+    if (isOutlined || T.hasLocalArchetype()) {
       // memcpy the existential container. This is safe because: either the
       // value is stored inline and is therefore by convention bitwise takable
       // or the value is stored in a reference counted heap buffer, in which

test/IRGen/parameterized_existential_with_element_archetype.swift

@@ -0,0 +1,17 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+public protocol P1<A> {
+    associatedtype A
+}
+
+public protocol P2<A>: class {
+    associatedtype A
+}
+
+public func f1<each T>(p: repeat any P1<each T>) {
+  let _ = (repeat each p)
+}
+
+public func f2<each T>(p: repeat any P2<each T>) {
+  let _ = (repeat each p)
+}

test/IRGen/parameterized_existential_with_opened_archetype.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+public protocol P {}
+
+extension P {
+  @_transparent
+  public func f() {
+    let x: any Q<Self> = S<Self>()
+
+    // force a copy
+    g(x, x)
+  }
+}
+
+@_optimize(none)
+public func g<T>(_: consuming T, _: consuming T) {}
+
+public enum G<T> {
+  case ok(String)
+  case bar
+}
+
+public func h(e: any P) {
+  // We inline P.f(), because it is transparent, so we end
+  // up working with an `any Q<@opened ...>`.
+  e.f()
+}
+
+public protocol Q<A> {
+  associatedtype A
+}
+
+public struct S<A>: Q {
+  public init() {}
+}