[TypeLowering] Record packs used in signatures.

To determine whether an instruction may require pack metadata, the types
of its operands are examined.

Previously, the top level type was checked for having a pack in its
signature, and the whole type was checked for having a type anywhere in
its layout (via TypeLowering).  This didn't account for the case where
the metadata was required for a resilient type which uses a pack in its
signature.

Here, during type lowering, a type having a pack in its signature is
counted towards the type having a pack.

Fixes a compiler crash.

rdar://147207926

Author: nate-chandler

lib/SIL/IR/SILInstruction.cpp

@@ -1353,7 +1353,7 @@ bool SILInstruction::isDeallocatingStack() const {
 }
 
 static bool typeOrLayoutInvolvesPack(SILType ty, SILFunction const &F) {
-  return ty.hasAnyPack() || ty.isOrContainsPack(F);
+  return ty.isOrContainsPack(F);
 }
 
 bool SILInstruction::mayRequirePackMetadata(SILFunction const &F) const {

lib/SIL/IR/TypeLowering.cpp

@@ -2490,6 +2490,7 @@ namespace {
                                     IsTypeExpansionSensitive_t isSensitive) {
       RecursiveProperties properties =
           getReferenceRecursiveProperties(isSensitive);
+      properties = mergeHasPack(HasPack_t(classType->hasAnyPack()), properties);
 
       if (C->getLifetimeAnnotation() == LifetimeAnnotation::EagerMove)
         properties.setLexical(IsNotLexical);
@@ -2506,6 +2507,7 @@ namespace {
       RecursiveProperties properties;
 
       properties = mergeIsTypeExpansionSensitive(isSensitive, properties);
+      properties = mergeHasPack(HasPack_t(structType->hasAnyPack()), properties);
 
       // Bail out if the struct layout relies on itself.
       TypeConverter::LowerAggregateTypeRAII loweringStruct(TC, structType);
@@ -2624,6 +2626,7 @@ namespace {
       RecursiveProperties properties;
 
       properties = mergeIsTypeExpansionSensitive(isSensitive, properties);
+      properties = mergeHasPack(HasPack_t(enumType->hasAnyPack()), properties);
 
       // Bail out if the enum layout relies on itself.
       TypeConverter::LowerAggregateTypeRAII loweringEnum(TC, enumType);

validation-test/IRGen/rdar147207926.swift

@@ -0,0 +1,65 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend                              \
+// RUN:     %t/Library.swift                                \
+// RUN:     -emit-module                                    \
+// RUN:     -target %target-swift-5.9-abi-triple            \
+// RUN:     -enable-library-evolution                       \
+// RUN:     -module-name Library                            \
+// RUN:     -emit-module-path %t/Library.swiftmodule
+
+// RUN: %target-build-swift                                 \
+// RUN:     %t/Downstream.swift                             \
+// RUN:     -c                                              \
+// RUN:     -target %target-swift-5.9-abi-triple            \
+// RUN:     -parse-as-library                               \
+// RUN:     -module-name main                               \
+// RUN:     -lLibrary                                       \
+// RUN:     -I %t                                           \
+// RUN:     -o %t/Executable.o
+
+//--- Library.swift
+
+public struct Paq<each T> {
+  public var uette: (repeat each T)
+}
+
+public class Loq<each T> {
+}
+
+// Enums don't take packs yet.
+
+// public enum Orq<each T> {
+//   case uette(repeat each T)
+//   case uettette(repeat each T, repeat each T)
+// }
+
+//--- Downstream.swift
+
+import Library
+
+struct Sleeve<T> {
+  var impl: Paq<T>
+}
+
+func bin<Moribund>(_ s: consuming Sleeve<Moribund>) {
+}
+
+struct Laq<T> {
+  var impl: Loq<T>
+  var t: T
+}
+
+@_silgen_name("bun")
+func bun<T>(_ l: consuming Laq<T>) {
+}
+
+// Enums don't take packs yet.
+
+// struct Etiq<T> {
+//   var impl: Orq<T>
+// }
+// 
+// func bon<Moribund>(_ i: consuming Etiq<Moribund>) {
+// }