SIL: Thread type expansion context through to function convention apis

This became necessary after recent function type changes that keep
substituted generic function types abstract even after substitution to
correctly handle automatic opaque result type substitution.

Instead of performing the opaque result type substitution as part of
substituting the generic args the underlying type will now be reified as
part of looking at the parameter/return types which happens as part of
the function convention apis.

rdar://62560867

Author: aschwaighofer

include/swift/AST/Types.h

@@ -3776,8 +3776,7 @@ class SILParameterInfo {
   /// Return the type of a call argument matching this parameter.
   ///
   /// \c t must refer back to the function type this is a parameter for.
-  CanType getArgumentType(SILModule &M,
-                          const SILFunctionType *t) const;
+  CanType getArgumentType(SILModule &M, const SILFunctionType *t, TypeExpansionContext context) const;
   ParameterConvention getConvention() const {
     return TypeAndConvention.getInt();
   }
@@ -3832,8 +3831,9 @@ class SILParameterInfo {
   /// storage. Therefore they will be passed using an indirect formal
   /// convention, and this method will return an address type. However, in
   /// canonical SIL the opaque arguments might not have an address type.
-  SILType getSILStorageType(SILModule &M,
-                            const SILFunctionType *t) const; // in SILFunctionConventions.h
+  SILType getSILStorageType(
+      SILModule &M, const SILFunctionType *t,
+      TypeExpansionContext context) const; // in SILFunctionConventions.h
   SILType getSILStorageInterfaceType() const;
 
   /// Return a version of this parameter info with the type replaced.
@@ -3865,9 +3865,9 @@ class SILParameterInfo {
   /// type, apply any substitutions from the function type to it to
   /// get a substituted version of it, as you would get from
   /// SILFunctionType::getUnsubstitutedType.
-  SILParameterInfo getUnsubstituted(SILModule &M,
-                                    const SILFunctionType *fnType) const {
-    return getWithInterfaceType(getArgumentType(M, fnType));
+  SILParameterInfo getUnsubstituted(SILModule &M, const SILFunctionType *fnType,
+                                    TypeExpansionContext context) const {
+    return getWithInterfaceType(getArgumentType(M, fnType, context));
   }
 
   void profile(llvm::FoldingSetNodeID &id) {
@@ -3952,9 +3952,9 @@ class SILResultInfo {
   /// The type of a return value corresponding to this result.
   ///
   /// \c t must refer back to the function type this is a parameter for.
-  CanType getReturnValueType(SILModule &M,
-                             const SILFunctionType *t) const;
-  
+  CanType getReturnValueType(SILModule &M, const SILFunctionType *t,
+                             TypeExpansionContext context) const;
+
   ResultConvention getConvention() const {
     return TypeAndConvention.getInt();
   }
@@ -3964,8 +3964,9 @@ class SILResultInfo {
   /// storage. Therefore they will be returned using an indirect formal
   /// convention, and this method will return an address type. However, in
   /// canonical SIL the opaque results might not have an address type.
-  SILType getSILStorageType(SILModule &M,
-                            const SILFunctionType *t) const; // in SILFunctionConventions.h
+  SILType getSILStorageType(
+      SILModule &M, const SILFunctionType *t,
+      TypeExpansionContext context) const; // in SILFunctionConventions.h
   SILType getSILStorageInterfaceType() const;
   /// Return a version of this result info with the type replaced.
   SILResultInfo getWithInterfaceType(CanType type) const {
@@ -4006,9 +4007,9 @@ class SILResultInfo {
   /// type, apply any substitutions from the function type to it to
   /// get a substituted version of it, as you would get from
   /// SILFunctionType::getUnsubstitutedType.
-  SILResultInfo getUnsubstituted(SILModule &M,
-                                 const SILFunctionType *fnType) const {
-    return getWithInterfaceType(getReturnValueType(M, fnType));
+  SILResultInfo getUnsubstituted(SILModule &M, const SILFunctionType *fnType,
+                                 TypeExpansionContext context) const {
+    return getWithInterfaceType(getReturnValueType(M, fnType, context));
   }
 
   void profile(llvm::FoldingSetNodeID &id) {
@@ -4066,18 +4067,18 @@ class SILYieldInfo : public SILParameterInfo {
                                                   ->getCanonicalType());
   }
 
-  CanType getYieldValueType(SILModule &M,
-                            const SILFunctionType *fnType) const {
-    return getArgumentType(M, fnType);
+  CanType getYieldValueType(SILModule &M, const SILFunctionType *fnType,
+                            TypeExpansionContext context) const {
+    return getArgumentType(M, fnType, context);
   }
 
   /// Treating this yield info as a component of the given function
   /// type, apply any substitutions from the function type to it to
   /// get a substituted version of it, as you would get from
   /// SILFunctionType::getUnsubstitutedType.
-  SILYieldInfo getUnsubstituted(SILModule &M,
-                                const SILFunctionType *fnType) const {
-    return getWithInterfaceType(getYieldValueType(M, fnType));
+  SILYieldInfo getUnsubstituted(SILModule &M, const SILFunctionType *fnType,
+                                TypeExpansionContext context) const {
+    return getWithInterfaceType(getYieldValueType(M, fnType, context));
   }
 };
 
@@ -4528,14 +4529,15 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
   /// this function depends on the current SIL stage and is known by
   /// SILFunctionConventions. It may be a wider tuple that includes formally
   /// indirect results.
-  SILType getDirectFormalResultsType(SILModule &M);
+  SILType getDirectFormalResultsType(SILModule &M,
+                                     TypeExpansionContext expansion);
 
   /// Get a single non-address SILType for all SIL results regardless of whether
   /// they are formally indirect. The actual SIL result type of an apply
   /// instruction that calls this function depends on the current SIL stage and
   /// is known by SILFunctionConventions. It may be a narrower tuple that omits
   /// formally indirect results.
-  SILType getAllResultsSubstType(SILModule &M);
+  SILType getAllResultsSubstType(SILModule &M, TypeExpansionContext expansion);
   SILType getAllResultsInterfaceType();
 
   /// Does this function have a blessed Swift-native error result?
@@ -4678,12 +4680,13 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return getInvocationGenericSignature() && !getInvocationSubstitutions();
   }
 
-  CanType getSelfInstanceType(SILModule &M) const;
+  CanType getSelfInstanceType(SILModule &M, TypeExpansionContext context) const;
 
   /// If this is a @convention(witness_method) function with a class
   /// constrained self parameter, return the class constraint for the
   /// Self type.
-  ClassDecl *getWitnessMethodClass(SILModule &M) const;
+  ClassDecl *getWitnessMethodClass(SILModule &M,
+                                   TypeExpansionContext context) const;
 
   /// If this is a @convention(witness_method) function, return the conformance
   /// for which the method is a witness. If it isn't that convention, return
@@ -4875,8 +4878,9 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return getExtInfo().getDifferentiabilityKind();
   }
 
-  bool isNoReturnFunction(SILModule &M) const; // Defined in SILType.cpp
-                                    
+  bool isNoReturnFunction(SILModule &M, TypeExpansionContext context)
+      const; // Defined in SILType.cpp
+
   /// Create a SILFunctionType with the same structure as this one,
   /// but with a different (or new) set of invocation substitutions.
   /// The substitutions must have the same generic signature as this.
@@ -4956,7 +4960,8 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
                                                 TypeExpansionContext context);
 
   SILType substInterfaceType(SILModule &M,
-                             SILType interfaceType) const;
+                             SILType interfaceType,
+                             TypeExpansionContext context) const;
 
   /// Return the unsubstituted function type equivalent to this type; that is, the type that has the same
   /// argument and result types as `this` type after substitutions, if any.

include/swift/SIL/ApplySite.h

@@ -23,6 +23,7 @@
 
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILFunction.h"
 
 namespace swift {
 
@@ -180,7 +181,10 @@ class ApplySite {
   }
 
   /// Return the type.
-  SILType getType() const { return getSubstCalleeConv().getSILResultType(); }
+  SILType getType() const {
+    return getSubstCalleeConv().getSILResultType(
+        getFunction()->getTypeExpansionContext());
+  }
 
   /// Get the type of the callee without the applied substitutions.
   CanSILFunctionType getOrigCalleeType() const {

include/swift/SIL/SILFunction.h

@@ -416,7 +416,7 @@ class SILFunction
 
   void setEntryCount(ProfileCounter Count) { EntryCount = Count; }
 
-  bool isNoReturnFunction() const;
+  bool isNoReturnFunction(TypeExpansionContext context) const;
 
   /// Unsafely rewrite the lowered type of this function.
   ///