Fix the SIL verifier to handle openings of multiple element archetypes

Author: rjmccall

lib/SIL/Verifier/SILVerifier.cpp

@@ -1640,27 +1640,30 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   void checkApplyTypeDependentArguments(ApplySite AS) {
     SILInstruction *AI = AS.getInstruction();
 
-    llvm::DenseSet<LocalArchetypeType *> FoundRootLocalArchetypes;
+    llvm::DenseSet<SILInstruction *> allOpeningInsts;
     unsigned hasDynamicSelf = 0;
 
-    // Function to collect local archetypes in FoundRootLocalArchetypes
-    // and set hasDynamicSelf.
-    auto HandleType = [&](CanType Ty) {
+    // Function to collect local archetypes in allOpeningInsts and set
+    // hasDynamicSelf.
+    auto handleType = [&](CanType Ty) {
       if (const auto A = dyn_cast<LocalArchetypeType>(Ty)) {
         require(isArchetypeValidInFunction(A, AI->getFunction()),
                 "Archetype to be substituted must be valid in function.");
 
         const auto root = A.getRoot();
 
-        // Collect all root local archetypes used in the substitutions list.
-        FoundRootLocalArchetypes.insert(root);
-        // Also check that they are properly tracked inside the current
-        // function.
+        // Check that opened archetypes are properly tracked inside
+        // the current function.
         auto *openingInst = F.getModule().getRootLocalArchetypeDefInst(
             root, AI->getFunction());
         require(openingInst == AI || properlyDominates(openingInst, AI),
                 "Use of a local archetype should be dominated by a "
                 "definition of this root opened archetype");
+
+        // Remember all the opening instructions.  We unique by instruction
+        // identity when building the list of type dependency operands, and
+        // some instructions can open multiple archetypes.
+        allOpeningInsts.insert(openingInst);
       }
       if (Ty->hasDynamicSelfType()) {
         hasDynamicSelf = 1;
@@ -1669,11 +1672,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     // Search for local archetypes and dynamic self.
     for (auto Replacement : AS.getSubstitutionMap().getReplacementTypes()) {
-      Replacement->getCanonicalType().visit(HandleType);
+      Replacement->getCanonicalType().visit(handleType);
     }
-    AS.getSubstCalleeType().visit(HandleType);
+    AS.getSubstCalleeType().visit(handleType);
 
-    require(FoundRootLocalArchetypes.size() + hasDynamicSelf ==
+    require(allOpeningInsts.size() + hasDynamicSelf ==
                 AI->getTypeDependentOperands().size(),
             "Number of local archetypes and dynamic self in the substitutions "
             "list should match the number of type dependent operands");
@@ -1691,19 +1694,19 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
         auto DI = V->getDefiningInstruction();
         require(DI,
                 "local archetype operand should refer to a SIL instruction");
-        bool definesFoundArchetype = false;
-        bool definesAnyArchetype = false;
+        require(allOpeningInsts.count(DI),
+                "local archetype operand does not correspond to any local "
+                "archetype from the substitutions list");
+
+        bool matchedDependencyResult = false;
         DI->forEachDefinedLocalArchetype(
             [&](CanLocalArchetypeType archetype, SILValue dependency) {
-          definesAnyArchetype = true;
-          if (FoundRootLocalArchetypes.count(archetype))
-            definesFoundArchetype = true;
+          if (dependency == V)
+            matchedDependencyResult = true;
         });
-        require(definesAnyArchetype,
-                "local archetype operand should define a local archetype");
-        require(definesFoundArchetype,
-                "local archetype operand does not correspond to any local "
-                "archetype from the substitutions list");
+        require(matchedDependencyResult,
+                "local archetype operand was not the dependency result "
+                "of the opening instruction");
       }
     }
   }

test/SILGen/variadic-generic-results.swift

@@ -269,3 +269,57 @@ func wrapTupleElements<each T>(_ value: repeat each T) -> (repeat Wrapper<each T
 // CHECK-NEXT:    return [[RET]] : $()
   return values
 }
+
+struct Pair<First, Second> {
+  init(_ first: First, _ second: Second) {}
+}
+
+// CHECK-LABEL: @$s4main9makePairs6firsts7secondsAA4PairVyxq_GxQp_txxQp_q_xQptq_RhzRvzRv_r0_lF
+// CHECK-SAME: $@convention(thin) <each First, each Second where (repeat (each First, each Second)) : Any> (@pack_guaranteed Pack{repeat each First}, @pack_guaranteed Pack{repeat each Second}) -> @pack_out Pack{repeat Pair<each First, each Second>}
+func makePairs<each First, each Second>(
+  firsts first: repeat each First,
+  seconds second: repeat each Second
+) -> (repeat Pair<each First, each Second>) {
+// CHECK:         [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
+// CHECK-NEXT:    [[ONE:%.*]] = integer_literal $Builtin.Word, 1
+// CHECK-NEXT:    [[LEN:%.*]] = pack_length $Pack{repeat each First}
+// CHECK-NEXT:    br bb1([[ZERO]] : $Builtin.Word)
+// CHECK:       bb1([[IDX:%.*]] : $Builtin.Word)
+// CHECK-NEXT:    [[IDX_EQ_LEN:%.*]] = builtin "cmp_eq_Word"([[IDX]] : $Builtin.Word, [[LEN]] : $Builtin.Word) : $Builtin.Int1
+// CHECK-NEXT:     cond_br [[IDX_EQ_LEN]], bb3, bb2
+// CHECK:       bb2:
+// CHECK-NEXT:    [[INDEX:%.*]] = dynamic_pack_index [[IDX]] of $Pack{repeat Pair<each First, each Second>}
+// CHECK-NEXT:    open_pack_element [[INDEX]] of <each First, each Second where (repeat (each First, each Second)) : Any> at <Pack{repeat each First}, Pack{repeat each Second}>, shape $First, uuid [[UUID:".*"]]
+// CHECK-NEXT:    [[OUT_ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %0 : $*Pack{repeat Pair<each First, each Second>} as $*Pair<@pack_element([[UUID]]) First, @pack_element([[UUID]]) Second>
+// CHECK-NEXT:    [[METATYPE:%.*]] = metatype $@thin Pair<@pack_element([[UUID]]) First, @pack_element([[UUID]]) Second>.Type
+// CHECK-NEXT:    [[FIRST_ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %1 : $*Pack{repeat each First} as $*@pack_element([[UUID]]) First
+// CHECK-NEXT:    [[FIRST_COPY:%.*]] = alloc_stack $@pack_element([[UUID]]) First
+// CHECK-NEXT:    copy_addr [[FIRST_ELT_ADDR]] to [init] [[FIRST_COPY]] : $*@pack_element([[UUID]]) First
+// CHECK-NEXT:    [[SECOND_ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %2 : $*Pack{repeat each Second} as $*@pack_element([[UUID]]) Second
+// CHECK-NEXT:    [[SECOND_COPY:%.*]] = alloc_stack $@pack_element([[UUID]]) Second
+// CHECK-NEXT:    copy_addr [[SECOND_ELT_ADDR]] to [init] [[SECOND_COPY]] : $*@pack_element([[UUID]]) Second
+// CHECK-NEXT:    // function_ref
+// CHECK-NEXT:    [[FN:%.*]] = function_ref
+// CHECK-NEXT:    [[PAIR:%.*]] = apply [[FN]]<@pack_element([[UUID]]) First, @pack_element([[UUID]]) Second>([[FIRST_COPY]], [[SECOND_COPY]], [[METATYPE]])
+// CHECK-NEXT:    dealloc_stack [[SECOND_COPY]] : $*@pack_element([[UUID]]) Second
+// CHECK-NEXT:    dealloc_stack [[FIRST_COPY]] : $*@pack_element([[UUID]]) First
+// CHECK-NEXT:    store [[PAIR]] to [trivial] [[OUT_ELT_ADDR]] : $*Pair<@pack_element([[UUID]]) First, @pack_element([[UUID]]) Second>
+// CHECK-NEXT:    [[NEXT_IDX:%.*]] = builtin "add_Word"([[IDX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
+// CHECK-NEXT:    br bb1([[NEXT_IDX]] : $Builtin.Word)
+// CHECK:       bb3:
+// CHECK-NEXT:    [[RET:%.*]] = tuple ()
+// CHECK-NEXT:    return [[RET]] : $()
+  return (repeat Pair(each first, each second))
+}
+
+protocol Container {
+  associatedtype Contents
+  var contents: Contents { get }
+}
+
+func makeContentsPairs<each First: Container, each Second: Container>(
+  firsts first: repeat each First,
+  seconds second: repeat each Second
+) -> (repeat Pair<(each First).Contents, (each Second).Contents>) {
+  return (repeat Pair((each first).contents, (each second).contents))
+}