Add some helpers to the SILFunctionType component types.

Author: rjmccall

include/swift/AST/Types.h

@@ -3834,6 +3834,11 @@ class SILParameterInfo {
     return SILParameterInfo(type, getConvention(), getDifferentiability());
   }
 
+  /// Return a version of this parameter info with the convention replaced.
+  SILParameterInfo getWithConvention(ParameterConvention c) const {
+    return SILParameterInfo(getInterfaceType(), c, getDifferentiability());
+  }
+
   /// Transform this SILParameterInfo by applying the user-provided
   /// function to its type.
   ///
@@ -3849,6 +3854,15 @@ class SILParameterInfo {
                                                   ->getCanonicalType());
   }
 
+  /// Treating this parameter 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.
+  SILParameterInfo getUnsubstituted(SILModule &M,
+                                    const SILFunctionType *fnType) const {
+    return getWithInterfaceType(getArgumentType(M, fnType));
+  }
+
   void profile(llvm::FoldingSetNodeID &id) {
     id.AddPointer(getInterfaceType().getPointer());
     id.AddInteger((unsigned)getConvention());
@@ -3951,6 +3965,11 @@ class SILResultInfo {
     return SILResultInfo(type, getConvention());
   }
 
+  /// Return a version of this result info with the convention replaced.
+  SILResultInfo getWithConvention(ResultConvention c) const {
+    return SILResultInfo(getInterfaceType(), c);
+  }
+
   // Does this result convention require indirect storage? This reflects a
   // SILFunctionType's formal (immutable) conventions, as opposed to the
   // transient SIL conventions that dictate SILValue types.
@@ -3976,6 +3995,15 @@ class SILResultInfo {
                                                   ->getCanonicalType());
   }
 
+  /// Treating this result 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.
+  SILResultInfo getUnsubstituted(SILModule &M,
+                                 const SILFunctionType *fnType) const {
+    return getWithInterfaceType(getReturnValueType(M, fnType));
+  }
+
   void profile(llvm::FoldingSetNodeID &id) {
     id.AddPointer(TypeAndConvention.getOpaqueValue());
   }
@@ -4016,6 +4044,11 @@ class SILYieldInfo : public SILParameterInfo {
     return SILYieldInfo(type, getConvention());
   }
 
+  /// Return a version of this yield info with the convention replaced.
+  SILYieldInfo getWithConvention(YieldConvention c) const {
+    return SILYieldInfo(getInterfaceType(), c);
+  }
+
   template<typename F>
   SILYieldInfo map(const F &fn) const {
     return getWithInterfaceType(fn(getInterfaceType()));
@@ -4025,6 +4058,20 @@ class SILYieldInfo : public SILParameterInfo {
     return getWithInterfaceType(getInterfaceType()->mapTypeOutOfContext()
                                                   ->getCanonicalType());
   }
+
+  CanType getYieldValueType(SILModule &M,
+                            const SILFunctionType *fnType) const {
+    return getArgumentType(M, fnType);
+  }
+
+  /// 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));
+  }
 };
 
 /// SILCoroutineKind - What kind of coroutine is this SILFunction?