Fix printing and implement parsing of opened element archetypes in SIL

Also, fix a couple places that were checking for opened existentials
to check for any local archetype.

Author: rjmccall

include/swift/AST/Attr.def.gyb

@@ -84,6 +84,7 @@ TYPE_ATTR(callee_owned)
 TYPE_ATTR(callee_guaranteed)
 TYPE_ATTR(objc_metatype)
 TYPE_ATTR(opened)
+TYPE_ATTR(pack_element)
 TYPE_ATTR(pseudogeneric)
 TYPE_ATTR(yields)
 TYPE_ATTR(yield_once)

include/swift/AST/DiagnosticsParse.def

@@ -677,6 +677,7 @@ ERROR(expected_generic_signature,none,
       "expected a generic signature", ())
 ERROR(sil_expected_uuid,none,
       "expected a UUID string literal", ())
+NOTE(sil_previous_instruction,none, "previous instruction", ())
 
 // SIL Basic Blocks
 ERROR(expected_sil_block_name,none,
@@ -1656,6 +1657,14 @@ ERROR(opened_attribute_id_value,none,
 ERROR(opened_attribute_expected_rparen,none,
       "expected ')' after id value for 'opened' attribute", ())
 
+// pack_element
+ERROR(pack_element_attribute_expected_lparen,none,
+      "expected '(' after 'pack_element' attribute", ())
+ERROR(pack_element_attribute_expected_rparen,none,
+      "expected ')' after id value for 'pack_element' attribute", ())
+ERROR(multiple_open_pack_element,none,
+      "multiple 'open_pack_element' instructions with same UUID", ())
+
 // unowned
 ERROR(attr_unowned_invalid_specifier,none,
       "expected 'safe' or 'unsafe'", ())

include/swift/AST/DiagnosticsSema.def

@@ -5385,6 +5385,9 @@ ERROR(illegal_sil_type,none,
       "type %0 is not a legal SIL value type", (Type))
 ERROR(sil_box_arg_mismatch,none,
       "SIL box type has wrong number of generic arguments for layout", ())
+ERROR(sil_pack_element_uuid_not_found,none,
+      "open_pack_element instruction not found for @pack_element type UUID; "
+      "possible forward reference?", ())
 // SIL Metatypes
 ERROR(sil_metatype_without_repr,none,
       "metatypes in SIL must have @thin, @thick, or @objc_metatype attribute",

include/swift/AST/GenericEnvironment.h

@@ -35,7 +35,9 @@ class ArchetypeType;
 class ASTContext;
 class GenericTypeParamType;
 class OpaqueTypeDecl;
+class ElementArchetypeType;
 class OpenedArchetypeType;
+class PackArchetypeType;
 class SILModule;
 class SILType;
 

include/swift/Sema/SILTypeResolutionContext.h

@@ -13,20 +13,37 @@
 #ifndef SWIFT_SEMA_SILTYPERESOLUTIONCONTEXT_H
 #define SWIFT_SEMA_SILTYPERESOLUTIONCONTEXT_H
 
+#include "llvm/ADT/DenseMap.h"
+#include "swift/Basic/UUID.h"
+
 namespace swift {
 class GenericParamList;
+class GenericEnvironment;
 
 class SILTypeResolutionContext {
 public:
+  struct OpenedPackElement {
+    SourceLoc DefinitionPoint;
+    GenericParamList *Params;
+    GenericEnvironment *Environment;
+  };
+  using OpenedPackElementsMap = llvm::DenseMap<UUID, OpenedPackElement>;
+
   /// Are we requesting a SIL type?
   bool IsSILType;
 
   /// Look up types in the given parameter list.
   GenericParamList *GenericParams;
 
+  /// Look up @pack_element environments in this map.
+  OpenedPackElementsMap *OpenedPackElements;
+
   SILTypeResolutionContext(bool isSILType,
-                           GenericParamList *genericParams)
-    : IsSILType(isSILType), GenericParams(genericParams) {}
+                           GenericParamList *genericParams,
+                           OpenedPackElementsMap *openedPackElements)
+    : IsSILType(isSILType),
+      GenericParams(genericParams),
+      OpenedPackElements(openedPackElements) {}
 };
 
 }

lib/AST/ASTPrinter.cpp

@@ -5439,6 +5439,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     } else if (auto archetype = dyn_cast<ArchetypeType>(T.getPointer())) {
       if (archetype->isParameterPack() && Options.PrintExplicitEach)
         return false;
+      if (Options.PrintForSIL && isa<LocalArchetypeType>(archetype))
+        return false;
     }
     return T->hasSimpleTypeRepr();
   }
@@ -6600,12 +6602,58 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  static Type findPackForElementArchetype(ElementArchetypeType *T) {
+    // The type in @pack_element is looked up in the generic params
+    // of the identified open_pack_element instruction.  The param list
+    // is long gone, but the sugar survives in the type parameters of
+    // the generic signature of the contextual substitution map in the
+    // opened element environment.
+    auto env = T->getGenericEnvironment();
+    auto subs = env->getPackElementContextSubstitutions();
+    auto sig = subs.getGenericSignature();
+    auto params = sig.getGenericParams();
+
+    auto elementShapeClass =
+      env->getOpenedElementShapeClass()->mapTypeOutOfContext();
+
+    // The element archetypes are at a depth one past the max depth
+    // of the base signature.
+    unsigned elementDepth = params.back()->getDepth() + 1;
+
+    // Transform the archetype's interface type to be based on the
+    // corresponding non-canonical type parameter.
+    auto interfaceType = T->getInterfaceType();
+    return interfaceType.subst([&](SubstitutableType *type) -> Type {
+      // Don't transform types that aren't element type parameters.
+      auto *elementParam = type->getAs<GenericTypeParamType>();
+      if (!elementParam || elementParam->getDepth() != elementDepth)
+        return Type();
+
+      // Loop through the type parameters looking for the type parameter
+      // pack at the appropriate index.  We only expect to actually do
+      // this once for each type, so it's fine to do it in the callback.
+      unsigned nextIndex = 0;
+      for (auto *genericParam : params) {
+        if (!genericParam->isParameterPack())
+          continue;
+
+        if (!sig->haveSameShape(genericParam, elementShapeClass))
+          continue;
+
+        if (nextIndex == elementParam->getIndex())
+          return genericParam;
+        nextIndex++;
+      }
+      llvm_unreachable("ran out of type parameters");
+      return Type();
+    }, LookUpConformanceInSignature(sig.getPointer()));
+  }
+
   void visitElementArchetypeType(ElementArchetypeType *T) {
     if (Options.PrintForSIL) {
-      Printer << "@element(\"" << T->getOpenedElementID() << ") ";
-
-      auto interfaceTy = T->getInterfaceType();
-      visit(interfaceTy);
+      Printer << "@pack_element(\"" << T->getOpenedElementID() << "\") ";
+      auto packTy = findPackForElementArchetype(T);
+      visit(packTy);
     } else {
       visit(T->getInterfaceType());
     }

lib/AST/GenericEnvironment.cpp

@@ -547,7 +547,7 @@ Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
 Type GenericEnvironment::mapTypeIntoContext(
                                 Type type,
                                 LookupConformanceFn lookupConformance) const {
-  assert((!type->hasArchetype() || type->hasOpenedExistential()) &&
+  assert((!type->hasArchetype() || type->hasLocalArchetype()) &&
          "already have a contextual type");
 
   type = maybeApplyOuterContextSubstitutions(type);

lib/AST/Type.cpp

@@ -4710,7 +4710,7 @@ static Type substType(Type derivedType,
     if (origArchetype->isRoot()) {
       // Root opened archetypes are not required to be substituted. Other root
       // archetypes must already have been substituted above.
-      if (isa<OpenedArchetypeType>(origArchetype)) {
+      if (isa<LocalArchetypeType>(origArchetype)) {
         return Type(type);
       } else {
         return ErrorType::get(type);

lib/Parse/ParseDecl.cpp

@@ -4164,6 +4164,33 @@ ParserStatus Parser::parseTypeAttribute(TypeAttributes &Attributes,
     break;
   }
 
+  case TAK_pack_element: {
+    if (!isInSILMode()) {
+      diagnose(AtLoc, diag::only_allowed_in_sil, "pack_element");
+      return makeParserSuccess();
+    }
+
+    // Parse the opened ID string in parens
+    SourceLoc beginLoc = Tok.getLoc(), idLoc, endLoc;
+    if (consumeIfNotAtStartOfLine(tok::l_paren)) {
+      idLoc = Tok.getLoc();
+      UUID id;
+      if (!parseUUIDString(id, diag::opened_attribute_id_value))
+        Attributes.OpenedID = id;
+
+      // TODO: allow more information so that these can be parsed
+      // prior to the open instruction.
+
+      parseMatchingToken(tok::r_paren, endLoc,
+                         diag::opened_attribute_expected_rparen,
+                         beginLoc);
+    } else {
+      diagnose(Tok, diag::pack_element_attribute_expected_lparen);
+    }
+
+    break;
+  }
+
   case TAK_differentiable: {
     Attributes.differentiabilityKind = DifferentiabilityKind::Normal;
     if (parseDifferentiableTypeAttributeArgument(

lib/SIL/Parser/ParseSIL.cpp

@@ -157,13 +157,20 @@ namespace swift {
     llvm::DenseMap<SILBasicBlock*,
                    Located<Identifier>> UndefinedBlocks;
 
+    /// The set of opened packs in the function, indexed by UUID.
+    /// Note that we don't currently support parsing references to
+    /// opened packs prior to their instruction, although this is
+    /// theoretically possible if basic blocks are not sorted in
+    /// dominance order.
+    SILTypeResolutionContext::OpenedPackElementsMap OpenedPackElements;
+
     /// Data structures used to perform name lookup for local values.
     llvm::StringMap<ValueBase*> LocalValues;
     llvm::StringMap<SourceLoc> ForwardRefLocalValues;
 
     Type performTypeResolution(TypeRepr *TyR, bool IsSILType,
                                GenericSignature GenericSig,
-                               GenericParamList *GenericParams) const;
+                               GenericParamList *GenericParams);
 
     void convertRequirements(ArrayRef<RequirementRepr> From,
                              SmallVectorImpl<Requirement> &To,
@@ -1253,11 +1260,12 @@ static bool parseDeclSILOptional(bool *isTransparent,
 
 Type SILParser::performTypeResolution(TypeRepr *TyR, bool IsSILType,
                                       GenericSignature GenericSig,
-                                      GenericParamList *GenericParams) const {
+                                      GenericParamList *GenericParams) {
   if (!GenericSig)
     GenericSig = ContextGenericSig;
 
-  SILTypeResolutionContext SILContext(IsSILType, GenericParams);
+  SILTypeResolutionContext SILContext(IsSILType, GenericParams,
+                                      &OpenedPackElements);
 
   return swift::performTypeResolution(TyR, P.Context, GenericSig,
                                       &SILContext, &P.SF);
@@ -3408,7 +3416,18 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     auto openedEnv = GenericEnvironment::forOpenedElement(openedElementSig,
                          uuid, shapeClass, openedSubMap);
 
-    ResultVal = B.createOpenPackElement(InstLoc, Val, openedEnv);
+    auto openInst = B.createOpenPackElement(InstLoc, Val, openedEnv);
+    ResultVal = openInst;
+
+    auto &entry = OpenedPackElements[uuid];
+    if (entry.DefinitionPoint.isValid()) {
+      P.diagnose(OpcodeLoc, diag::multiple_open_pack_element);
+      P.diagnose(entry.DefinitionPoint, diag::sil_previous_instruction);
+    } else {
+      entry.DefinitionPoint = OpcodeLoc;
+      entry.Params = openedGenerics;
+      entry.Environment = openedEnv;
+    }
     break;
   }
 
@@ -7593,7 +7612,8 @@ static bool parseSILWitnessTableEntry(
         return true;
 
       SILTypeResolutionContext silContext(/*isSILType=*/false,
-                                          witnessParams);
+                                          witnessParams,
+                                          /*openedPacks=*/nullptr);
       auto Ty =
           swift::performTypeResolution(TyR.get(), P.Context,
                                        witnessSig, &silContext,
@@ -7657,7 +7677,8 @@ static bool parseSILWitnessTableEntry(
       return true;
 
     SILTypeResolutionContext silContext(/*isSILType=*/false,
-                                        witnessParams);
+                                        witnessParams,
+                                        /*openedPacks=*/nullptr);
     auto Ty =
         swift::performTypeResolution(TyR.get(), P.Context,
                                      witnessSig, &silContext,

lib/Sema/TypeCheckType.cpp

@@ -1975,6 +1975,10 @@ namespace {
         TypeAttributes &attrs, TypeRepr *repr,
         TypeResolutionOptions options);
 
+    NeverNullType resolvePackElementArchetype(
+        TypeAttributes &attrs, TypeRepr *repr,
+        TypeResolutionOptions options);
+
     NeverNullType resolveAttributedType(AttributedTypeRepr *repr,
                                         TypeResolutionOptions options);
     NeverNullType resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
@@ -2507,6 +2511,71 @@ TypeResolver::resolveOpenedExistentialArchetype(
   return archetypeType;
 }
 
+/// In SIL, handle '@pack_element(UUID) interfaceType',
+/// which creates an opened archetype.
+NeverNullType
+TypeResolver::resolvePackElementArchetype(
+    TypeAttributes &attrs, TypeRepr *repr,
+    TypeResolutionOptions options) {
+  assert(silContext);
+  assert(attrs.has(TAK_pack_element));
+  assert(attrs.OpenedID.hasValue());
+
+  attrs.clearAttribute(TAK_pack_element);
+
+  auto dc = getDeclContext();
+  auto &ctx = dc->getASTContext();
+
+  const SILTypeResolutionContext::OpenedPackElement *entry = nullptr;
+  if (const auto *openedPacksMap = silContext->OpenedPackElements) {
+    auto it = openedPacksMap->find(*attrs.OpenedID);
+    if (it != openedPacksMap->end()) {
+      entry = &it->second;
+    }
+  }
+  if (!entry) {
+    diagnoseInvalid(repr, attrs.getLoc(TAK_pack_element),
+                    diag::sil_pack_element_uuid_not_found);
+    return ErrorType::get(ctx);
+  }
+
+  options.setContext(None);
+
+  // The interface type is the type wrapped by the attribute. Resolve it
+  // within the generic parameter list for the opened generic environment.
+  // Use structural resolution to avoid querying the DeclContext's
+  // generic signature, which is not the right signature for this.
+  auto structuralResolution = TypeResolution::forStructural(
+      dc, options,
+      /*unboundTyOpener*/ nullptr,
+      /*placeholderHandler*/ nullptr,
+      /*packElementOpener*/ nullptr);
+  auto interfaceType = [&] {
+    SILInnerGenericContextRAII scope(silContext, entry->Params);
+
+    TypeResolver interfaceTypeResolver(structuralResolution, silContext);
+    return interfaceTypeResolver.resolveType(repr, options);
+  }();
+
+  if (!interfaceType->isTypeParameter()) {
+    diagnoseInvalid(repr, attrs.getLoc(TAK_pack_element),
+                    diag::opened_bad_interface_type,
+                    interfaceType);
+
+    return ErrorType::get(ctx);
+  }
+
+  // Map the interface type into the element context.
+  auto archetypeType =
+    entry->Environment->mapPackTypeIntoElementContext(interfaceType);
+  if (archetypeType->hasError()) {
+    diagnoseInvalid(repr, attrs.getLoc(TAK_pack_element),
+                    diag::opened_bad_interface_type,
+                    interfaceType);
+  }
+  return archetypeType;
+}
+
 /// \returns true iff the # of isolated params is > \c lowerBound
 static bool hasMoreIsolatedParamsThan(FunctionTypeRepr* fnTy, unsigned lowerBound) {
   unsigned count = 0;
@@ -2953,6 +3022,8 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
 
   if (attrs.has(TAK_opened)) {
     ty = resolveOpenedExistentialArchetype(attrs, repr, options);
+  } else if (attrs.has(TAK_pack_element)) {
+    ty = resolvePackElementArchetype(attrs, repr, options);
   }
 
   auto instanceOptions = options;

test/SIL/Parser/variadic_generics.sil

@@ -30,12 +30,14 @@ bb0:
 // CHECK: [[INNER_INDEX:%.*]] = dynamic_pack_index {{%.*}} of $Pack{repeat each T}
 // CHECK: [[INDEX:%.*]] = pack_pack_index 1, [[INNER_INDEX]] of $Pack{Int, repeat each T}
 // CHECK: {{%.*}} = open_pack_element [[INDEX]] of <U...> at <Pack{Int, repeat each T}>, shape $U, uuid "01234567-89AB-CDEF-0123-000000000002"
+// CHECK: metatype $@thick (@pack_element("01234567-89AB-CDEF-0123-000000000002") U).Type
 sil @test3 : $<T...> () -> () {
 bb0:
   %intIndex = integer_literal $Builtin.Word, 0
   %innerIndex = dynamic_pack_index %intIndex of $Pack{repeat each T}
   %index = pack_pack_index 1, %innerIndex of $Pack{Int, repeat each T}
   %0 = open_pack_element %index of <U...> at <Pack{Int, repeat each T}>, shape $U, uuid "01234567-89AB-CDEF-0123-000000000002"
+  %metatype = metatype $@thick (@pack_element("01234567-89AB-CDEF-0123-000000000002") U).Type
   %ret = tuple ()
   return %ret : $()
 }