Add a SIL instruction to open a pack as an element archetype

IRGen not yet done.

Author: rjmccall

include/swift/AST/DiagnosticsParse.def

@@ -673,6 +673,10 @@ ERROR(sil_moveonlytocopyable_invalid_attribute,none,
       "Attribute '[%0]' can not be applied to moveonlywrapper_to_copyable", (StringRef))
 ERROR(sil_moveonlytocopyable_requires_attribute,none,
       "moveonlywrapper_to_copyable requires either a [guaranteed] or [owned] attribute", ())
+ERROR(expected_generic_signature,none,
+      "expected a generic signature", ())
+ERROR(sil_expected_uuid,none,
+      "expected a UUID string literal", ())
 
 // SIL Basic Blocks
 ERROR(expected_sil_block_name,none,

include/swift/SIL/SILBuilder.h

@@ -1936,6 +1936,14 @@ class SILBuilder {
         getSILDebugLocation(Loc), Existential));
   }
 
+  OpenPackElementInst *
+  createOpenPackElement(SILLocation loc, SILValue packIndex,
+                        GenericEnvironment *openedElementEnvironment) {
+    return insert(OpenPackElementInst::create(getFunction(),
+                              getSILDebugLocation(loc),
+                              packIndex, openedElementEnvironment));
+  }
+
   ProjectBlockStorageInst *createProjectBlockStorage(SILLocation Loc,
                                                      SILValue Storage) {
     auto CaptureTy = Storage->getType()

include/swift/SIL/SILCloner.h

@@ -2392,6 +2392,52 @@ void SILCloner<ImplClass>::visitDeinitExistentialValueInst(
                 getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitOpenPackElementInst(
+    OpenPackElementInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+
+  auto newIndexValue = getOpValue(Inst->getIndexOperand());
+  auto loc = getOpLocation(Inst->getLoc());
+
+  // We need to make a new opened-element environment.  This is *not*
+  // a refinement of the contextual environment of the new insertion
+  // site; we just substitute the contextual substitutions in the
+  // opened environment and build a new one.
+  auto origEnv = Inst->getOpenedGenericEnvironment();
+
+  // Substitute the contextual substitutions.
+  auto newContextSubs =
+    getOpSubstitutionMap(origEnv->getPackElementContextSubstitutions());
+
+  // Substitute the shape class.
+  auto newShapeClass = getOpASTType(origEnv->getOpenedElementShapeClass());
+
+  // Build the new environment.
+  auto newEnv =
+    GenericEnvironment::forOpenedElement(origEnv->getGenericSignature(),
+                                         UUID::fromTime(), newShapeClass,
+                                         newContextSubs);
+
+  // Associate the old opened archetypes with the new ones.
+  SmallVector<ArchetypeType*, 4> oldOpenedArchetypes;
+  origEnv->forEachPackElementArchetype([&](ElementArchetypeType *oldType) {
+    oldOpenedArchetypes.push_back(oldType);
+  });
+  {
+    size_t nextOldIndex = 0;
+    newEnv->forEachPackElementArchetype([&](ElementArchetypeType *newType) {
+      ArchetypeType *oldType = oldOpenedArchetypes[nextOldIndex++];
+      registerLocalArchetypeRemapping(oldType, newType);
+    });
+    assert(nextOldIndex == oldOpenedArchetypes.size() &&
+           "different opened archetype count");
+  }
+
+  recordClonedInstruction(
+      Inst, getBuilder().createOpenPackElement(loc, newIndexValue, newEnv));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitCopyBlockInst(CopyBlockInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -7403,6 +7403,94 @@ class DeinitExistentialValueInst
       : UnaryInstructionBase(DebugLoc, Existential) {}
 };
 
+/// Bind archetypes to the given element of one or more type packs.
+///
+/// The result of this instruction is just for use in recording type
+/// dependencies on the bound archetypes.
+///
+///   %0 = open_pack_element %index
+///          of <t_1_0... as $@opened t_10101 from {T...}>
+///          where t_1_0: Equatable
+///
+/// %index is always a $Builtin.Word.
+///
+/// In the printed representation, only the relevant portions of the
+/// opened generic environment are given: the pack type parameters,
+/// the opened element archetypes, the contextual substitutions of
+/// the pack type parameters, and the requirements on the pack type
+/// parameters.
+class OpenPackElementInst final
+    : public InstructionBaseWithTrailingOperands<
+                                        SILInstructionKind::OpenPackElementInst,
+                                        OpenPackElementInst,
+                                        SingleValueInstruction> {
+  friend SILBuilder;
+
+  /// The opened-element generic environment for this operation.
+  ///
+  /// In the AST, the opened element generic environment of a
+  /// PackExpansionExpr extends the contextual generic environment with
+  /// a new, innermost level of parameters representing the opened
+  /// elements.  These parameters are not pack parameters, but they are
+  /// 1-1 with the expanded pack parameters, and the requirements laid
+  /// on them are copied from the requirements on those parameters.
+  /// The substitutions in the environment map the contextual generic
+  /// parameters to their current archetypes, and only the new element
+  /// parameters acquire new archetypes within the environment.
+  ///
+  /// Parts of this correspondence break down for open_pack_element.
+  /// In particular, SIL instructions can be cloned into new contexts,
+  /// applying a substitution that can change or even erase the pack
+  /// parameters in the contextual environment.  Rather than require
+  /// the opened element environment to continue to be an extension
+  /// of the contextual environment, SIL allows the two to diverge:
+  /// there is no presumed relationship between the generic signature
+  /// of the opened environment and that of the contextual environment.
+  /// The generic environment should be treated as a source of
+  /// information about the expanded packs, the contextual pack
+  /// substitutions, and the opened archetype for each pack.
+  ///
+  /// An alternative representation would be to remove the non-pack
+  /// parameters from the opened generic environment, replacing them
+  /// in the requirements with references to the contextual archetypes.
+  /// However, this would require various algorithms working with
+  /// generic signatures and environments to work with a mixture of
+  /// archetypes and type parameters, which can introduce problems
+  /// when reasoning about certain kinds of generic signatures.
+  GenericEnvironment *Env;
+
+  OpenPackElementInst(SILDebugLocation debugLoc,
+                      ArrayRef<SILValue> allOperands,
+                      SILType type,
+                      GenericEnvironment *env);
+
+  static OpenPackElementInst *
+  create(SILFunction &F, SILDebugLocation debugLoc, SILValue index,
+         GenericEnvironment *env);
+
+public:
+  /// Call the given function for each element archetype that this
+  /// instruction opens.
+  void forEachDefinedLocalArchetype(
+      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const;
+
+  GenericEnvironment *getOpenedGenericEnvironment() const {
+    return Env;
+  }
+
+  SILValue getIndexOperand() const {
+    return getAllOperands()[0].get();
+  }
+
+  ArrayRef<Operand> getTypeDependentOperands() const {
+    return getAllOperands().slice(1);
+  }
+
+  MutableArrayRef<Operand> getTypeDependentOperands() {
+    return getAllOperands().slice(1);
+  }
+};
+
 /// Projects the capture storage address from a @block_storage address.
 class ProjectBlockStorageInst
   : public UnaryInstructionBase<SILInstructionKind::ProjectBlockStorageInst,

include/swift/SIL/SILNodes.def

@@ -597,6 +597,10 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(OpenExistentialBoxValueInst, open_existential_box_value,
                             SingleValueInstruction, MayRead, DoesNotRelease)
 
+  // Variadic generics
+  SINGLE_VALUE_INST(OpenPackElementInst, open_pack_element,
+                    SingleValueInstruction, None, DoesNotRelease)
+
   // Blocks
   SINGLE_VALUE_INST(ProjectBlockStorageInst, project_block_storage,
                     SingleValueInstruction, None, DoesNotRelease)

include/swift/SIL/SILType.h

@@ -737,6 +737,9 @@ class SILType {
   /// Get the SIL token type.
   static SILType getSILTokenType(const ASTContext &C);
 
+  /// Get the type for pack indexes.
+  static SILType getPackIndexType(const ASTContext &C);
+
   /// Return '()'
   static SILType getEmptyTupleType(const ASTContext &C);
 

lib/IRGen/IRGenSIL.cpp

@@ -1259,6 +1259,8 @@ class IRGenSILFunction :
   void visitProjectExistentialBoxInst(ProjectExistentialBoxInst *i);
   void visitDeallocExistentialBoxInst(DeallocExistentialBoxInst *i);
 
+  void visitOpenPackElementInst(swift::OpenPackElementInst *i);
+
   void visitProjectBlockStorageInst(ProjectBlockStorageInst *i);
   void visitInitBlockStorageHeaderInst(InitBlockStorageHeaderInst *i);
 
@@ -6741,6 +6743,15 @@ void IRGenSILFunction::visitOpenExistentialValueInst(
   llvm_unreachable("unsupported instruction during IRGen");
 }
 
+void IRGenSILFunction::visitOpenPackElementInst(swift::OpenPackElementInst *i) {
+  llvm::Value *index = getLoweredSingletonExplosion(i->getIndexOperand());
+
+  // FIXME: bind the archetypes
+  (void) index;
+
+  // The result is just used for type dependencies.
+}
+
 void IRGenSILFunction::visitProjectBlockStorageInst(ProjectBlockStorageInst *i){
   // TODO
   Address block = getLoweredAddress(i->getOperand());

lib/SIL/IR/OperandOwnership.cpp

@@ -174,6 +174,7 @@ OPERAND_OWNERSHIP(TrivialUse, ObjCMetatypeToObject)
 OPERAND_OWNERSHIP(TrivialUse, ObjCToThickMetatype)
 OPERAND_OWNERSHIP(TrivialUse, OpenExistentialAddr)
 OPERAND_OWNERSHIP(TrivialUse, OpenExistentialMetatype)
+OPERAND_OWNERSHIP(TrivialUse, OpenPackElement)
 OPERAND_OWNERSHIP(TrivialUse, PointerToAddress)
 OPERAND_OWNERSHIP(TrivialUse, ProjectBlockStorage)
 OPERAND_OWNERSHIP(TrivialUse, RawPointerToRef)

lib/SIL/IR/SILInstruction.cpp

@@ -1557,11 +1557,22 @@ void SILInstruction::forEachDefinedLocalArchetype(
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialMetatypeInst)
   SINGLE_VALUE_SINGLE_OPEN(OpenExistentialValueInst)
 #undef SINGLE_VALUE_SINGLE_OPEN
+  case SILInstructionKind::OpenPackElementInst:
+    return cast<OpenPackElementInst>(this)->forEachDefinedLocalArchetype(fn);
   default:
     return;
   }
 }
 
+void OpenPackElementInst::forEachDefinedLocalArchetype(
+      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const {
+  getOpenedGenericEnvironment()->forEachPackElementBinding(
+                                  [&](ElementArchetypeType *elementType,
+                                      PackType *packSubstitution) {
+    fn(CanElementArchetypeType(elementType), this);
+  });
+}
+
 //===----------------------------------------------------------------------===//
 //                         Multiple Value Instruction
 //===----------------------------------------------------------------------===//

lib/SIL/IR/SILInstructions.cpp

@@ -2244,6 +2244,36 @@ OpenExistentialValueInst::OpenExistentialValueInst(
     : UnaryInstructionBase(debugLoc, operand, selfTy, forwardingOwnershipKind) {
 }
 
+OpenPackElementInst::OpenPackElementInst(
+    SILDebugLocation debugLoc, ArrayRef<SILValue> allOperands,
+    SILType type, GenericEnvironment *env)
+    : InstructionBaseWithTrailingOperands(allOperands, debugLoc, type),
+      Env(env) {
+}
+
+OpenPackElementInst *OpenPackElementInst::create(
+    SILFunction &F, SILDebugLocation debugLoc, SILValue indexOperand,
+    GenericEnvironment *env) {
+  SmallVector<SILValue, 8> allOperands;
+  allOperands.push_back(indexOperand);
+
+  // open_pack_element references the pack substitutions and
+  // the types used in the shape class.
+  TypeDependentOperandCollector typeDependentOperands;
+  env->forEachPackElementBinding([&](ElementArchetypeType *elementType,
+                                     PackType *packSubstitution) {
+    typeDependentOperands.collect(packSubstitution->getCanonicalType());
+  });
+  typeDependentOperands.collect(env->getOpenedElementShapeClass());
+  typeDependentOperands.addTo(allOperands, F);
+
+  SILType type = SILType::getSILTokenType(F.getASTContext());
+
+  auto size = totalSizeToAlloc<swift::Operand>(allOperands.size());
+  auto buffer = F.getModule().allocateInst(size, alignof(OpenPackElementInst));
+  return ::new (buffer) OpenPackElementInst(debugLoc, allOperands, type, env);
+}
+
 BeginCOWMutationInst::BeginCOWMutationInst(SILDebugLocation loc,
                                SILValue operand,
                                ArrayRef<SILType> resultTypes,

lib/SIL/IR/SILPrinter.cpp

@@ -645,6 +645,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   SIMPLE_PRINTER(SILDeclRef)
   SIMPLE_PRINTER(APInt)
   SIMPLE_PRINTER(ValueOwnershipKind)
+  SIMPLE_PRINTER(UUID)
+  SIMPLE_PRINTER(GenericSignature)
 #undef SIMPLE_PRINTER
 
   SILPrinter &operator<<(SILValuePrinterInfo i) {
@@ -2277,6 +2279,16 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   void visitDeallocExistentialBoxInst(DeallocExistentialBoxInst *DEI) {
     *this << getIDAndType(DEI->getOperand()) << ", $" << DEI->getConcreteType();
   }
+  void visitOpenPackElementInst(OpenPackElementInst *OPEI) {
+    auto env = OPEI->getOpenedGenericEnvironment();
+    auto subs = env->getPackElementContextSubstitutions();
+    *this << Ctx.getID(OPEI->getIndexOperand())
+          << " of " << subs.getGenericSignature()
+          << " at ";
+    printSubstitutions(subs);
+    *this << ", shape $" << env->getOpenedElementShapeClass()
+          << ", uuid \"" << env->getOpenedElementUUID() << "\"";
+  }
   void visitProjectBlockStorageInst(ProjectBlockStorageInst *PBSI) {
     *this << getIDAndType(PBSI->getOperand());
   }

lib/SIL/IR/SILType.cpp

@@ -103,6 +103,10 @@ SILType SILType::getSILTokenType(const ASTContext &C) {
   return getPrimitiveObjectType(C.TheSILTokenType);
 }
 
+SILType SILType::getPackIndexType(const ASTContext &C) {
+  return getPrimitiveObjectType(CanType(BuiltinIntegerType::getWordType(C)));
+}
+
 bool SILType::isTrivial(const SILFunction &F) const {
   auto contextType = hasTypeParameter() ? F.mapTypeIntoContext(*this) : *this;
 

lib/SIL/IR/ValueOwnership.cpp

@@ -154,6 +154,7 @@ CONSTANT_OWNERSHIP_INST(None, GetAsyncContinuation)
 CONSTANT_OWNERSHIP_INST(None, GetAsyncContinuationAddr)
 CONSTANT_OWNERSHIP_INST(None, ThinToThickFunction)
 CONSTANT_OWNERSHIP_INST(None, ExtractExecutor)
+CONSTANT_OWNERSHIP_INST(None, OpenPackElement)
 
 #undef CONSTANT_OWNERSHIP_INST