Re-apply "SILGen: Move even more abstraction patterns over to interface types, NFC"

Now with a fix for a crash with rvalue references to local functions
that had generic types in their signature.

This reverts commit 31b97bc.

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -159,7 +159,6 @@ class Callee {
   };
   SILValue SelfValue;
   ArrayRef<Substitution> Substitutions;
-  CanType OrigFormalOldType;
   CanType OrigFormalInterfaceType;
   CanAnyFunctionType SubstFormalType;
   Optional<SILLocation> SpecializeLoc;
@@ -177,18 +176,11 @@ class Callee {
          SILLocation L)
     : kind(Kind::IndirectValue),
       IndirectValue(indirectValue),
-      OrigFormalOldType(origFormalType),
       OrigFormalInterfaceType(origFormalType),
       SubstFormalType(substFormalType),
       Loc(L)
   {}
 
-  static CanAnyFunctionType getConstantFormalType(SILGenFunction &gen,
-                                                  SILDeclRef fn)
-  SIL_FUNCTION_TYPE_DEPRECATED {
-    return gen.SGM.Types.getConstantInfo(fn.atUncurryLevel(0)).FormalType;
-  }
-
   static CanAnyFunctionType getConstantFormalInterfaceType(SILGenFunction &gen,
                                                   SILDeclRef fn) {
     return gen.SGM.Types.getConstantInfo(fn.atUncurryLevel(0))
@@ -199,7 +191,6 @@ class Callee {
          CanAnyFunctionType substFormalType,
          SILLocation l)
     : kind(Kind::StandaloneFunction), Constant(standaloneFunction),
-      OrigFormalOldType(getConstantFormalType(gen, standaloneFunction)),
       OrigFormalInterfaceType(getConstantFormalInterfaceType(gen,
                                                            standaloneFunction)),
       SubstFormalType(substFormalType),
@@ -214,7 +205,6 @@ class Callee {
          CanAnyFunctionType substFormalType,
          SILLocation l)
     : kind(methodKind), Constant(methodName), SelfValue(selfValue),
-      OrigFormalOldType(getConstantFormalType(gen, methodName)),
       OrigFormalInterfaceType(getConstantFormalInterfaceType(gen, methodName)),
       SubstFormalType(substFormalType),
       Loc(l)
@@ -247,11 +237,18 @@ class Callee {
       return CanType(TupleType::get(field, ctx));
     }
 
-    // These first two asserts will crash before they return if
-    // they're actually wrong.
-    assert(getArchetypeForSelf(origParamType));
-    assert(getArchetypeForSelf(selfType));
     assert(isa<MetatypeType>(origParamType) == isa<MetatypeType>(selfType));
+
+    if (auto mt = dyn_cast<MetatypeType>(origParamType))
+      assert(mt.getInstanceType()->isTypeParameter());
+    else
+      assert(origParamType->isTypeParameter());
+
+    if (auto mt = dyn_cast<MetatypeType>(selfType))
+      assert(isa<ArchetypeType>(mt.getInstanceType()));
+    else
+      assert(isa<ArchetypeType>(selfType));
+
     return selfType;
   }
 
@@ -290,13 +287,13 @@ class Callee {
 
     // Add the 'self' parameter back.  We want it to look like a
     // substitution of the appropriate clause from the original type.
-    auto polyFormalType = cast<PolymorphicFunctionType>(OrigFormalOldType);
+    auto origFormalType = cast<AnyFunctionType>(OrigFormalInterfaceType);
     auto substSelfType =
-      buildSubstSelfType(polyFormalType.getInput(), protocolSelfType, ctx);
+      buildSubstSelfType(origFormalType.getInput(), protocolSelfType, ctx);
 
     auto extInfo = FunctionType::ExtInfo(FunctionType::Representation::Thin,
                                          /*noreturn*/ false,
-                                         /*throws*/ polyFormalType->throws());
+                                         /*throws*/ origFormalType->throws());
 
     SubstFormalType = CanFunctionType::get(substSelfType, SubstFormalType,
                                            extInfo);
@@ -308,17 +305,18 @@ class Callee {
     assert(kind == Kind::DynamicMethod);
 
     // Drop the original self clause.
-    CanType methodType = OrigFormalOldType;
+    CanType methodType = OrigFormalInterfaceType;
     methodType = cast<AnyFunctionType>(methodType).getResult();
 
     // Replace it with the dynamic self type.
-    OrigFormalOldType = OrigFormalInterfaceType
+    OrigFormalInterfaceType
       = getDynamicMethodFormalType(SGM, SelfValue,
                                    Constant.getDecl(),
                                    Constant, methodType);
+    assert(!OrigFormalInterfaceType->hasTypeParameter());
 
     // Add a self clause to the substituted type.
-    auto origFormalType = cast<AnyFunctionType>(OrigFormalOldType);
+    auto origFormalType = cast<AnyFunctionType>(OrigFormalInterfaceType);
     auto selfType = origFormalType.getInput();
     SubstFormalType
       = CanFunctionType::get(selfType, SubstFormalType,
@@ -417,7 +415,7 @@ class Callee {
   }
 
   CanType getOrigFormalType() const {
-    return OrigFormalOldType;
+    return OrigFormalInterfaceType;
   }
 
   CanAnyFunctionType getSubstFormalType() const {
@@ -3648,11 +3646,11 @@ SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
                                             ArrayRef<ManagedValue> args,
                                             SGFContext ctx) {
   auto origFormalType =
-    cast<AnyFunctionType>(fn->getType()->getCanonicalType());
+    cast<AnyFunctionType>(fn->getInterfaceType()->getCanonicalType());
   auto substFormalType = origFormalType;
   if (!subs.empty()) {
-    auto polyFnType = cast<PolymorphicFunctionType>(substFormalType);
-    auto applied = polyFnType->substGenericArgs(SGM.SwiftModule, subs);
+    auto genericFnType = cast<GenericFunctionType>(substFormalType);
+    auto applied = genericFnType->substGenericArgs(SGM.SwiftModule, subs);
     substFormalType = cast<FunctionType>(applied->getCanonicalType());
   }
 
@@ -3671,7 +3669,7 @@ SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
            == SILFunctionLanguage::Swift);
 
   return emitApply(loc, mv, subs, args, substFnType,
-                   AbstractionPattern(origFormalType.getResult()),
+                   AbstractionPattern(origFormalType).getFunctionResultType(),
                    substFormalType.getResult(),
                    options, None, None, ctx);
 }
@@ -3807,10 +3805,10 @@ emitSpecializedAccessorFunctionRef(SILGenFunction &gen,
   SILConstantInfo constantInfo = gen.getConstantInfo(constant);
 
   // Apply substitutions to the callee type.
-  CanAnyFunctionType substAccessorType = constantInfo.FormalType;
+  CanAnyFunctionType substAccessorType = constantInfo.FormalInterfaceType;
   if (!substitutions.empty()) {
-    auto polyFn = cast<PolymorphicFunctionType>(substAccessorType);
-    auto substFn = polyFn->substGenericArgs(gen.SGM.SwiftModule, substitutions);
+    auto genericFn = cast<GenericFunctionType>(substAccessorType);
+    auto substFn = genericFn->substGenericArgs(gen.SGM.SwiftModule, substitutions);
     substAccessorType = cast<FunctionType>(substFn->getCanonicalType());
   }
 

lib/SILGen/SILGenConvert.cpp

@@ -149,18 +149,18 @@ getOptionalSomeValue(SILLocation loc, ManagedValue value,
   return emitManagedRValueWithCleanup(result, optTL);
 }
 
-static Substitution getSimpleSubstitution(GenericParamList &generics,
+static Substitution getSimpleSubstitution(GenericSignature *genericSig,
                                           CanType typeArg) {
-  assert(generics.getParams().size() == 1);
+  assert(genericSig->getGenericParams().size() == 1);
   return Substitution{typeArg, {}};
 }
 
 /// Create the correct substitution for calling the given function at
 /// the given type.
 static Substitution getSimpleSubstitution(FuncDecl *fn, CanType typeArg) {
-  auto polyFnType =
-    cast<PolymorphicFunctionType>(fn->getType()->getCanonicalType());
-  return getSimpleSubstitution(polyFnType->getGenericParams(), typeArg);
+  auto genericFnType =
+    cast<GenericFunctionType>(fn->getInterfaceType()->getCanonicalType());
+  return getSimpleSubstitution(genericFnType->getGenericSignature(), typeArg);
 }
 
 static CanType getOptionalValueType(SILType optType,

lib/SILGen/SILGenExpr.cpp

@@ -442,14 +442,22 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
 
   // Get the lowered AST types:
   //  - the original type
-  auto origLoweredFormalType = AbstractionPattern(constantInfo.LoweredType);
+  auto origLoweredFormalType =
+      AbstractionPattern(constantInfo.LoweredInterfaceType);
   if (hasLocalCaptures) {
-    auto formalTypeWithoutCaptures =
-      cast<AnyFunctionType>(constantInfo.FormalType.getResult());
+    // Get the unlowered formal type of the constant, stripping off
+    // the first level of function application, which applies captures.
+    origLoweredFormalType =
+      AbstractionPattern(constantInfo.FormalInterfaceType)
+          .getFunctionResultType();
+
+    // Lower it, being careful to use the right generic signature.
     origLoweredFormalType =
       AbstractionPattern(
-              SGM.Types.getLoweredASTFunctionType(formalTypeWithoutCaptures,0,
-                                                  silDeclRef));
+          origLoweredFormalType.getGenericSignature(),
+          SGM.Types.getLoweredASTFunctionType(
+              cast<FunctionType>(origLoweredFormalType.getType()),
+              0, silDeclRef));
   }
 
   // - the substituted type

test/SILGen/closures.swift

@@ -16,6 +16,14 @@ func return_local_generic_function_without_captures<A, R>() -> A -> R {
   return f
 }
 
+func return_local_generic_function_with_captures<A, R>(a: A) -> A -> R {
+  func f(_: A) -> R {
+    _ = a
+  }
+
+  return f
+}
+
 // CHECK-LABEL: sil hidden @_TF8closures17read_only_capture
 func read_only_capture(x: Int) -> Int {
   var x = x