Merge remote-tracking branch 'slavapestov/misc-variadic-generic-fixes'

Author: rjmccall

lib/AST/ASTMangler.cpp

@@ -3164,9 +3164,13 @@ void ASTMangler::appendGenericSignatureParts(
 
 /// Determine whether an associated type reference into the given set of
 /// protocols is unambiguous.
-static bool associatedTypeRefIsUnambiguous(ArrayRef<ProtocolDecl *> protocols) {
+static bool associatedTypeRefIsUnambiguous(GenericSignature sig, Type t) {
+  // FIXME: This should be an assertion.
+  if (!sig->isValidTypeParameter(t))
+    return false;
+
   unsigned numProtocols = 0;
-  for (auto proto : protocols) {
+  for (auto proto : sig->getRequiredProtocols(t)) {
     // Skip marker protocols, which cannot have associated types.
     if (proto->isMarkerProtocol())
       continue;
@@ -3186,7 +3190,7 @@ ASTMangler::dropProtocolFromAssociatedType(DependentMemberType *dmt,
   auto baseTy = dmt->getBase();
   bool unambiguous =
       (!dmt->getAssocType() ||
-       associatedTypeRefIsUnambiguous(sig->getRequiredProtocols(baseTy)));
+       associatedTypeRefIsUnambiguous(sig, baseTy));
 
   if (auto *baseDMT = baseTy->getAs<DependentMemberType>())
     baseTy = dropProtocolFromAssociatedType(baseDMT, sig);
@@ -3223,7 +3227,7 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt,
     // associated type name by protocol.
     if (!OptimizeProtocolNames || !sig ||
         !associatedTypeRefIsUnambiguous(
-            sig->getRequiredProtocols(dmt->getBase()))) {
+            sig, dmt->getBase())) {
       appendAnyGenericType(assocTy->getProtocol());
     }
     return;

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -244,10 +244,19 @@ RequirementMachine::getLongestValidPrefix(const MutableTerm &term) const {
              "Protocol symbol can only appear at the start of a type term");
       break;
 
-    case Symbol::Kind::GenericParam:
+    case Symbol::Kind::GenericParam: {
       assert(prefix.empty() &&
              "Generic parameter symbol can only appear at the start of a type term");
+
+      if (std::find_if(Params.begin(), Params.end(),
+                       [&](Type otherParam) -> bool {
+                         return otherParam->isEqual(symbol.getGenericParam());
+                       }) == Params.end()) {
+        return prefix;
+      }
+
       break;
+    }
 
     case Symbol::Kind::AssociatedType: {
       const auto *props = Map.lookUpProperties(prefix);

lib/Demangling/Demangler.cpp

@@ -2392,7 +2392,6 @@ NodePointer Demangler::demangleArchetype() {
     NodePointer PatternTy = popTypeAndGetChild();
     NodePointer PackExpansionTy = createType(
           createWithChildren(Node::Kind::PackExpansion, PatternTy, CountTy));
-    addSubstitution(PackExpansionTy);
     return PackExpansionTy;
   }
   case 'P':

lib/SIL/IR/AbstractionPattern.cpp

@@ -79,7 +79,12 @@ TypeConverter::getAbstractionPattern(VarDecl *var, bool isNonObjC) {
   auto sig = var->getDeclContext()
                  ->getGenericSignatureOfContext()
                  .getCanonicalSignature();
-  auto swiftType = sig.getReducedType(var->getInterfaceType());
+
+  auto interfaceType = var->getInterfaceType();
+  if (auto *packExpansionType = interfaceType->getAs<PackExpansionType>())
+    interfaceType = packExpansionType->getPatternType();
+
+  auto swiftType = sig.getReducedType(interfaceType);
 
   if (isNonObjC)
     return AbstractionPattern(sig, swiftType);

test/SILGen/pack_expansion_type.swift

@@ -43,3 +43,9 @@ func variadicMetatypes<each T>(_: repeat each T) {
   _ = ((repeat each T) -> ()).self
   _ = ((Int, repeat Array<each T>) -> ()).self
 }
+
+// Mangling bugs with substitutions
+
+// CHECK-LABEL: sil [ossa] @$s19pack_expansion_type18sameExpansionTwice2us05more_G02vsyxxQp_xxQpq_q_QptRvzRv_r0_lF : $@convention(thin) <each U, each V> (@pack_guaranteed Pack{repeat each U}, @pack_guaranteed Pack{repeat each U}, @pack_guaranteed Pack{repeat each V}) -> () {
+public func sameExpansionTwice<each U, each V>(us: repeat each U, more_us: repeat each U, vs: repeat each V) {}
+

test/SILGen/parameterized_existentials_variadic.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-emit-silgen -module-name parameterized -disable-availability-checking %s -enable-experimental-feature VariadicGenerics | %FileCheck %s
+
+protocol P<A> {
+  associatedtype A
+}
+
+// The mangling for generalized existentials is buggy; we decide whether to
+// qualify the primary associated type requirement with a protocol or not
+// by looking at the first generic parameter of the outer generic context.
+
+struct S1 {
+  // CHECK-LABEL: sil hidden [ossa] @$s13parameterized2S1V1fAA1P_pSi1AAaEPRts_XPyF : $@convention(method) (S1) -> @out any P<Int> {
+  func f() -> any P<Int> {}
+}
+
+struct S2<T> {
+  // CHECK-LABEL: sil hidden [ossa] @$s13parameterized2S2V1fAA1P_pSi1ARts_XPyF : $@convention(method) <T> (S2<T>) -> @out any P<Int> {
+  func f() -> any P<Int> {}
+}
+
+struct S3<each T> {
+  // CHECK-LABEL: sil hidden [ossa] @$s13parameterized2S3V1fAA1P_pSi1AAaEPRts_XPyF : $@convention(method) <each T> (S3<repeat each T>) -> @out any P<Int> {
+  func f() -> any P<Int> {}
+}

test/SILGen/variadic-generic-tuples.swift

@@ -165,3 +165,40 @@ func wrapTupleElements<each T>(_ value: repeat each T) -> (repeat Wrapper<each T
   // CHECK-NEXT:    [[RET:%.*]] = tuple ()
   // CHECK-NEXT:    return [[RET]] : $()
 }
+
+// CHECK-LABEL: sil hidden [ossa] @$s4main20projectTupleElementsyyAA7WrapperVyxGxQpRvzlF : $@convention(thin) <each T> (@pack_guaranteed Pack{repeat Wrapper<each T>}) -> () {
+func projectTupleElements<each T>(_ value: repeat Wrapper<each T>) {
+  // CHECK: [[VAR:%.*]] = alloc_stack [lexical] $(repeat each T)
+
+  // CHECK-NEXT: [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
+  // CHECK-NEXT: [[ONE:%.*]] = integer_literal $Builtin.Word, 1
+  // CHECK-NEXT: [[PACK_LEN:%.*]] = pack_length $Pack{repeat each T}
+
+  // CHECK-NEXT: br bb1([[ZERO]] : $Builtin.Word)
+
+  // CHECK: bb1([[INDEX:%.*]] : $Builtin.Word):
+  // CHECK-NEXT: [[INDEX_EQ_LEN:%.*]] = builtin "cmp_eq_Word"([[INDEX]] : $Builtin.Word, [[PACK_LEN]] : $Builtin.Word)
+  // CHECK-NEXT: cond_br [[INDEX_EQ_LEN]], bb3, bb2
+
+  // CHECK: bb2:
+  // CHECK-NEXT: [[CUR_INDEX:%.*]] = dynamic_pack_index [[INDEX]] of $Pack{repeat each T}
+  // CHECK-NEXT: open_pack_element [[CUR_INDEX]] of <each T> at <Pack{repeat each T}>, shape $T, uuid "[[UUID:[0-9A-F-]*]]"
+  // CHECK-NEXT: [[TUPLE_ELT_ADDR:%.*]] = tuple_pack_element_addr [[CUR_INDEX]] of [[VAR]] : $*(repeat each T) as $*@pack_element("[[UUID]]") T
+  // CHECK-NEXT: [[VAL_ELT_ADDR:%.*]] = pack_element_get [[CUR_INDEX]] of %0 : $*Pack{repeat Wrapper<each T>} as $*Wrapper<@pack_element("[[UUID]]") T>
+  // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $Wrapper<@pack_element("[[UUID]]") T>
+  // CHECK-NEXT: copy_addr [[VAL_ELT_ADDR]] to [init] [[TEMP]] : $*Wrapper<@pack_element("[[UUID]]") T>
+  // CHECK-NEXT: [[MEMBER:%.*]] = struct_element_addr [[TEMP]] : $*Wrapper<@pack_element("[[UUID]]") T>, #Wrapper.value
+  // CHECK-NEXT: copy_addr [[MEMBER]] to [init] [[TUPLE_ELT_ADDR]] : $*@pack_element("[[UUID]]") T
+  // CHECK-NEXT: destroy_addr [[TEMP]] : $*Wrapper<@pack_element("[[UUID]]") T>
+  // CHECK-NEXT: dealloc_stack [[TEMP]] : $*Wrapper<@pack_element("[[UUID]]") T>
+  // CHECK-NEXT: [[NEXT_INDEX:%.*]] = builtin "add_Word"([[INDEX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
+  // CHECK-NEXT: br bb1([[NEXT_INDEX]] : $Builtin.Word)
+
+  // CHECK: bb3:
+  // CHECK-NEXT: destroy_addr [[VAR]] : $*(repeat each T)
+  // CHECK-NEXT: dealloc_stack [[VAR]] : $*(repeat each T)
+  // CHECK-NEXT: [[RET:%.*]] = tuple ()
+  // CHECK-NEXT: return [[RET]] : $()
+
+  let tuple = (repeat (each value).value)
+}