SILGen: Introduce OpenClassExistentialComponent

This is an LValue component whose value is the class
reference inside of a class existential.

Unlike OpenOpaqueExistentialComponent, this is a logical
component, with a "writeback" consisting of wrapping the
new class reference in a class existential having the
same conformances as the original.

This is slightly awkward, but adding "by-address" operations
on class existentials, and projecting the payload out is
a big change and might not make sense for other reasons.

Author: slavapestov

lib/SILGen/LValue.h

@@ -97,7 +97,7 @@ class PathComponent {
     TupleElementKind,           // tuple_element_addr
     StructElementKind,          // struct_element_addr
     OptionalObjectKind,         // optional projection
-    OpenedExistentialKind,      // opened opaque existential
+    OpenOpaqueExistentialKind,  // opened opaque existential
     AddressorKind,              // var/subscript addressor
     ValueKind,                  // random base pointer as an lvalue
     KeyPathApplicationKind,     // applying a key path
@@ -107,6 +107,7 @@ class PathComponent {
     OwnershipKind,              // weak pointer remapping
     AutoreleasingWritebackKind, // autorelease pointer on set
     WritebackPseudoKind,        // a fake component to customize writeback
+    OpenClassExistentialKind,   // opened class existential
     // Translation LValue kinds (a subtype of logical)
     OrigToSubstKind,            // generic type substitution
     SubstToOrigKind,            // generic type substitution

lib/SILGen/SILGenFunction.h

@@ -1284,6 +1284,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ManagedValue emitAddressOfLValue(SILLocation loc, LValue &&src,
                                    AccessKind accessKind,
                                    TSanKind tsanKind = TSanKind::None);
+  LValue emitOpenExistentialLValue(SILLocation loc,
+                                   LValue &&existentialLV,
+                                   CanArchetypeType openedArchetype,
+                                   AccessKind accessKind);
 
   RValue emitLoadOfLValue(SILLocation loc, LValue &&src, SGFContext C,
                           bool isGuaranteedValid = false);

lib/SILGen/SILGenLValue.cpp

@@ -579,7 +579,7 @@ namespace {
   public:
     OpenOpaqueExistentialComponent(CanArchetypeType openedArchetype)
       : PhysicalPathComponent(getOpenedArchetypeTypeData(openedArchetype),
-                              OpenedExistentialKind) {}
+                              OpenOpaqueExistentialKind) {}
 
     ManagedValue offset(SILGenFunction &SGF, SILLocation loc, ManagedValue base,
                         AccessKind accessKind) && override {
@@ -604,6 +604,89 @@ namespace {
     }
   };
 
+  /// A local path component for the payload of a class existential.
+  ///
+  /// TODO: Could be physical if we had a way to project out the
+  /// payload.
+  class OpenClassExistentialComponent : public LogicalPathComponent {
+    static LValueTypeData getOpenedArchetypeTypeData(CanArchetypeType type) {
+      return {
+        AbstractionPattern::getOpaque(), type,
+        SILType::getPrimitiveObjectType(type)
+      };
+    }
+  public:
+    OpenClassExistentialComponent(CanArchetypeType openedArchetype)
+      : LogicalPathComponent(getOpenedArchetypeTypeData(openedArchetype),
+                             OpenClassExistentialKind) {}
+
+    AccessKind getBaseAccessKind(SILGenFunction &SGF,
+                                 AccessKind kind) const override {
+      // Always use the same access kind for the base.
+      return kind;
+    }
+
+    void diagnoseWritebackConflict(LogicalPathComponent *RHS,
+                                   SILLocation loc1, SILLocation loc2,
+                                   SILGenFunction &SGF) override {
+      // no useful writeback diagnostics at this point
+    }
+
+    RValue get(SILGenFunction &SGF, SILLocation loc,
+               ManagedValue base, SGFContext c) && override {
+      auto refType = base.getType().getObjectType();
+      auto &TL = SGF.getTypeLowering(refType);
+
+      // Load the original value.
+      auto result = SGF.emitLoad(loc, base.getValue(), TL,
+                                 SGFContext(), IsNotTake);
+
+      assert(refType.isExistentialType() &&
+             "base for open existential component must be an existential");
+      assert(refType.getPreferredExistentialRepresentation(SGF.SGM.M)
+             == ExistentialRepresentation::Class);
+      auto ref = SGF.B.createOpenExistentialRef(
+        loc, result, getTypeOfRValue());
+
+      SGF.setArchetypeOpeningSite(cast<ArchetypeType>(getSubstFormalType()),
+                                  ref.getValue());
+
+      return RValue(SGF, loc, getSubstFormalType(), ref);
+    }
+
+    void set(SILGenFunction &SGF, SILLocation loc,
+             RValue &&value, ManagedValue base) && override {
+      auto payload = std::move(value).forwardAsSingleValue(SGF, loc);
+
+      SmallVector<ProtocolConformanceRef, 2> conformances;
+      for (auto proto : cast<ArchetypeType>(getSubstFormalType())->getConformsTo())
+        conformances.push_back(ProtocolConformanceRef(proto));
+
+      auto ref = SGF.B.createInitExistentialRef(
+        loc,
+        base.getType().getObjectType(),
+        getSubstFormalType(),
+        payload,
+        SGF.getASTContext().AllocateCopy(conformances));
+
+      auto &TL = SGF.getTypeLowering(base.getType());
+      SGF.emitSemanticStore(loc, ref,
+                            base.getValue(), TL, IsNotInitialization);
+    }
+
+    std::unique_ptr<LogicalPathComponent>
+    clone(SILGenFunction &SGF, SILLocation loc) const override {
+      LogicalPathComponent *clone =
+        new OpenClassExistentialComponent(
+          cast<ArchetypeType>(getSubstFormalType()));
+      return std::unique_ptr<LogicalPathComponent>(clone);
+    }
+
+    void print(raw_ostream &OS) const override {
+      OS << "OpenClassExistentialComponent(...)\n";
+    }
+  };
+
   /// A physical path component which returns a literal address.
   class ValueComponent : public PhysicalPathComponent {
     ManagedValue Value;
@@ -2817,6 +2900,31 @@ ManagedValue SILGenFunction::emitAddressOfLValue(SILLocation loc,
   return ManagedValue::forLValue(addr.getValue());
 }
 
+LValue
+SILGenFunction::emitOpenExistentialLValue(SILLocation loc,
+                                          LValue &&lv,
+                                          CanArchetypeType openedArchetype,
+                                          AccessKind accessKind) {
+  // Open up the existential.
+  auto rep = lv.getTypeOfRValue()
+    .getPreferredExistentialRepresentation(SGM.M);
+  switch (rep) {
+  case ExistentialRepresentation::Opaque: {
+    lv.add<OpenOpaqueExistentialComponent>(openedArchetype);
+    break;
+  }
+  case ExistentialRepresentation::Class: {
+    lv.add<OpenClassExistentialComponent>(openedArchetype);
+    break;
+  }
+  default:
+    llvm_unreachable("Cannot perform lvalue access of "
+                     "non-opaque, non-class existential");
+  }
+
+  return std::move(lv);
+}
+
 void SILGenFunction::emitAssignToLValue(SILLocation loc, RValue &&src,
                                         LValue &&dest) {
   FormalEvaluationScope scope(*this);