Fix issues with the AddressLowering pass

Override the current SILModuleConvention of the SILModule when we perform the address lowering.

Author: swiftix

include/swift/SIL/SILBuilder.h

@@ -316,10 +316,14 @@ class SILBuilder {
         &F, OpenedArchetypes));
   }
 
-  ApplyInst *createApply(SILLocation Loc, SILValue Fn, SubstitutionList Subs,
-                         ArrayRef<SILValue> Args, bool isNonThrowing) {
+  ApplyInst *
+  createApply(SILLocation Loc, SILValue Fn, SubstitutionList Subs,
+              ArrayRef<SILValue> Args, bool isNonThrowing,
+              Optional<SILModuleConventions> ModuleConventions = None) {
     return insert(ApplyInst::create(getSILDebugLocation(Loc), Fn,
-                                    Subs, Args, isNonThrowing, F,
+                                    Subs, Args, isNonThrowing,
+                                    ModuleConventions,
+                                    F,
                                     OpenedArchetypes));
   }
 

include/swift/SIL/SILInstruction.h

@@ -1300,6 +1300,7 @@ class ApplyInst : public ApplyInstBase<ApplyInst, SILInstruction> {
   static ApplyInst *create(SILDebugLocation DebugLoc, SILValue Callee,
                            SubstitutionList Substitutions,
                            ArrayRef<SILValue> Args, bool isNonThrowing,
+                           Optional<SILModuleConventions> ModuleConventions,
                            SILFunction &F,
                            SILOpenedArchetypesState &OpenedArchetypes);
 

lib/SIL/SILInstructions.cpp

@@ -408,19 +408,24 @@ ApplyInst::ApplyInst(SILDebugLocation Loc, SILValue Callee,
 
 ApplyInst *ApplyInst::create(SILDebugLocation Loc, SILValue Callee,
                              SubstitutionList Subs, ArrayRef<SILValue> Args,
-                             bool isNonThrowing, SILFunction &F,
+                             bool isNonThrowing,
+                             Optional<SILModuleConventions> ModuleConventions,
+                             SILFunction &F,
                              SILOpenedArchetypesState &OpenedArchetypes) {
-  SILType SubstCalleeTy =
+  SILType SubstCalleeSILTy =
       Callee->getType().substGenericArgs(F.getModule(), Subs);
-  SILFunctionConventions Conv(SubstCalleeTy.getAs<SILFunctionType>(),
-                              F.getModule());
+  auto SubstCalleeTy = SubstCalleeSILTy.getAs<SILFunctionType>();
+  SILFunctionConventions Conv(SubstCalleeTy,
+                              ModuleConventions.hasValue()
+                                  ? ModuleConventions.getValue()
+                                  : SILModuleConventions(F.getModule()));
   SILType Result = Conv.getSILResultType();
 
   SmallVector<SILValue, 32> TypeDependentOperands;
   collectTypeDependentOperands(TypeDependentOperands, OpenedArchetypes, F,
-                               SubstCalleeTy.getSwiftRValueType(), Subs);
+                               SubstCalleeSILTy.getSwiftRValueType(), Subs);
   void *Buffer = allocate(F, Subs, TypeDependentOperands, Args);
-  return ::new(Buffer) ApplyInst(Loc, Callee, SubstCalleeTy,
+  return ::new(Buffer) ApplyInst(Loc, Callee, SubstCalleeSILTy,
                                  Result, Subs, Args,
                                  TypeDependentOperands, isNonThrowing);
 }

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -966,7 +966,8 @@ void ApplyRewriter::convertApplyWithIndirectResults() {
   case ValueKind::ApplyInst:
     newCallInst = callBuilder.createApply(
         loc, apply.getCallee(), apply.getSubstitutions(), newCallArgs,
-        cast<ApplyInst>(origCallInst)->isNonThrowing());
+        cast<ApplyInst>(origCallInst)->isNonThrowing(),
+        SILModuleConventions::getLoweredAddressConventions());
     break;
   case ValueKind::TryApplyInst:
     // TODO: insert dealloc in the catch block.