When we are performing SIL substitution, and we reach a type that

needs to be lowered, use an opaque abstraction pattern.

As I argue in the comment, we know that the orig type is now either
an opaque type or a type with high-level structure that is invariant
to lowering.  Substitution will not change the latter property, and
an opaque abstraction pattern is correct for the former.  Attempting
to create a "truer" abstraction pattern that preserves more structure
from the orig type is both pointless and problematic.  The
substitutions we just did may have replaced pack references with
non-pack types if there are active expansions in progress; this cannot
be easily explained in terms of substitutions.  (In theory, we could
pass a more opaque concept of substitutions through AbstractionPattern,
which might help with this.  That would also make it harder to catch
bugs with signature mismatches, though.)

Author: rjmccall

lib/SIL/IR/SILFunctionType.cpp

@@ -4748,7 +4748,17 @@ class SILTypeSubstituter :
       return origType;
     }
 
-    AbstractionPattern abstraction(Sig, origType);
+    // We've looked through all the top-level structure in the orig
+    // type that's affected by type lowering.  If substitution has
+    // given us a type with top-level structure that's affected by
+    // type lowering, it must be because the orig type was a type
+    // variable of some sort, and we should lower using an opaque
+    // abstraction pattern.  If substitution hasn't given us such a
+    // type, it doesn't matter what abstraction pattern we use,
+    // lowering will just come back with substType.  So we can just
+    // use an opaque abstraction pattern here and not put any effort
+    // into computing a more "honest" abstraction pattern.
+    AbstractionPattern abstraction = AbstractionPattern::getOpaque();
     return TC.getLoweredRValueType(typeExpansionContext, abstraction,
                                    substType);
   }