AST: Stub out ASTContext::getOpenedElementSignature()

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1346,6 +1346,13 @@ class ASTContext final {
   CanGenericSignature getOpenedExistentialSignature(Type type,
                                                     GenericSignature parentSig);
 
+  /// Get a generic signature where the generic parameter τ_d_i represents
+  /// the element of the pack generic parameter τ_d_i… in \p baseGenericSig.
+  ///
+  /// This drops the @_typeSequence attribute from each generic parameter,
+  /// and converts same-element requirements to same-type requirements.
+  CanGenericSignature getOpenedElementSignature(CanGenericSignature baseGenericSig);
+
   GenericSignature getOverrideGenericSignature(const ValueDecl *base,
                                                const ValueDecl *derived);
 

lib/AST/ASTContext.cpp

@@ -342,6 +342,11 @@ struct ASTContext::Implementation {
   llvm::DenseMap<std::pair<CanType, const GenericSignatureImpl *>, CanGenericSignature>
       ExistentialSignatures;
 
+  /// The element signature for a generic signature, constructed by dropping
+  /// @_typeSequence attributes from generic parameters.
+  llvm::DenseMap<const GenericSignatureImpl *,
+                 CanGenericSignature> ElementSignatures;
+
   /// Overridden declarations.
   llvm::DenseMap<const ValueDecl *, ArrayRef<ValueDecl *>> Overrides;
 
@@ -5256,6 +5261,76 @@ ASTContext::getOpenedExistentialSignature(Type type, GenericSignature parentSig)
   return canGenericSig;
 }
 
+CanGenericSignature
+ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig) {
+  auto &sigs = getImpl().ElementSignatures;
+  auto found = sigs.find(baseGenericSig.getPointer());
+  if (found != sigs.end())
+    return found->second;
+
+  // This operation doesn't make sense if the input signature does not contain`
+  // any pack generic parameters.
+#ifndef NDEBUG
+  {
+    auto found = std::find_if(baseGenericSig.getGenericParams().begin(),
+                              baseGenericSig.getGenericParams().end(),
+                              [](GenericTypeParamType *paramType) {
+                                return paramType->isTypeSequence();
+                              });
+    assert(found != baseGenericSig.getGenericParams().end());
+  }
+#endif
+
+  SmallVector<GenericTypeParamType *, 2> genericParams;
+  SmallVector<Requirement, 2> requirements;
+
+  auto eraseTypeSequence = [&](GenericTypeParamType *paramType) {
+    return GenericTypeParamType::get(
+        paramType->getDepth(), paramType->getIndex(),
+        /*isTypeSequence=*/false, *this);
+  };
+
+  for (auto paramType : baseGenericSig.getGenericParams()) {
+    genericParams.push_back(eraseTypeSequence(paramType));
+  }
+
+  auto eraseTypeSequenceRec = [&](Type type) -> Type {
+    return type.transformRec([&](Type t) -> Optional<Type> {
+      if (auto *paramType = t->getAs<GenericTypeParamType>())
+        return Type(eraseTypeSequence(paramType));
+      return None;
+    });
+  };
+
+  for (auto requirement : baseGenericSig.getRequirements()) {
+    switch (requirement.getKind()) {
+    case RequirementKind::SameCount:
+      // Drop same-length requirements from the element signature.
+      break;
+    case RequirementKind::Conformance:
+    case RequirementKind::Superclass:
+    case RequirementKind::SameType:
+      requirements.emplace_back(
+          requirement.getKind(),
+          eraseTypeSequenceRec(requirement.getFirstType()),
+          eraseTypeSequenceRec(requirement.getSecondType()));
+      break;
+    case RequirementKind::Layout:
+      requirements.emplace_back(
+          requirement.getKind(),
+          eraseTypeSequenceRec(requirement.getFirstType()),
+          requirement.getLayoutConstraint());
+      break;
+    }
+  }
+
+  auto elementSig = buildGenericSignature(
+      *this, GenericSignature(), genericParams, requirements)
+          .getCanonicalSignature();
+  sigs[baseGenericSig.getPointer()] = elementSig;
+  return elementSig;
+}
+
 GenericSignature 
 ASTContext::getOverrideGenericSignature(const ValueDecl *base,
                                         const ValueDecl *derived) {