Sema: Better support for nested generic functions

There was a weird corner case with nested generic functions that
would fail in the SIL verifier with some nonsense about archetypes
out of context.

Fix this the "right" way, by re-working Sema function declaration
validation to assign generic signatures in a more principled way.

Previously, nested functions did not get an interface type unless
they themselves had generic parameters.

This was inconsistent with methods nested inside generic types,
which did get an interface type even if they themselves did not
have a generic parameter list.

There's some spill-over in SILGen from this change. Mostly it
makes things more consistent and fixes some corner cases.

Author: slavapestov

include/swift/AST/DeclContext.h

@@ -367,10 +367,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
 
   /// Determine whether the innermost context is generic.
   bool isInnermostContextGeneric() const;
-  
-  /// Determine whether the innermost context is either a generic type context,
-  /// or a concrete type nested inside a generic type context.
-  bool isGenericTypeContext() const;
 
   /// Determine the maximum depth of the current generic type context's generic
   /// parameters. If the current context is not a generic type context, returns

lib/AST/Decl.cpp

@@ -4472,7 +4472,7 @@ bool EnumElementDecl::computeType() {
   if (getArgumentType())
     resultTy = FunctionType::get(getArgumentType(), resultTy);
 
-  if (ED->isGenericTypeContext())
+  if (ED->isGenericContext())
     resultTy = PolymorphicFunctionType::get(argTy, resultTy,
                                             ED->getGenericParamsOfContext());
   else

lib/AST/DeclContext.cpp

@@ -431,17 +431,6 @@ bool DeclContext::isGenericContext() const {
   llvm_unreachable("illegal declcontext hierarchy");
 }
 
-/// Determine whether the given context nested inside a generic type context
-/// with no local contexts in between.
-bool DeclContext::isGenericTypeContext() const {
-  for (const auto *dc = this; dc->isTypeContext(); dc = dc->getParent()) {
-    if (dc->isInnermostContextGeneric())
-      return true;
-  }
-  
-  return false;
-}
-
 /// Determine the maximum depth of the current generic type context's generic
 /// parameters. If the current context is not a generic type context, returns
 /// the maximum depth of any generic parameter in this context.

lib/AST/Module.cpp

@@ -726,6 +726,13 @@ TypeBase::gatherAllSubstitutions(Module *module,
     llvm_unreachable("Not a nominal or bound generic type");
   }
 
+  // Add forwarding substitutions from the outer context if we have
+  // a type nested inside a generic function.
+  if (auto *outerGenericParams = parentDC->getGenericParamsOfContext()) {
+    for (auto archetype : outerGenericParams->getAllNestedArchetypes())
+      substitutions[archetype] = archetype;
+  }
+
   // Collect all of the archetypes.
   SmallVector<ArchetypeType *, 2> allArchetypesList;
   ArrayRef<ArchetypeType *> allArchetypes = genericParams->getAllArchetypes();

lib/SIL/TypeLowering.cpp

@@ -1732,13 +1732,12 @@ static CanAnyFunctionType getIVarInitDestroyerInterfaceType(ClassDecl *cd,
 GenericParamList *
 TypeConverter::getEffectiveGenericParams(AnyFunctionRef fn,
                                          CaptureInfo captureInfo) {
-  auto dc = fn.getAsDeclContext()->getParent();
+  auto dc = fn.getAsDeclContext();
 
-  if (dc->isLocalContext() &&
-      !captureInfo.hasGenericParamCaptures()) {
+  if (dc->getParent()->isLocalContext() &&
+      !captureInfo.hasGenericParamCaptures())
     return nullptr;
-  }
-  
+
   return dc->getGenericParamsOfContext();
 }
 
@@ -1747,14 +1746,9 @@ TypeConverter::getEffectiveGenericSignature(AnyFunctionRef fn,
                                             CaptureInfo captureInfo) {
   auto dc = fn.getAsDeclContext();
 
-  // If this is a non-generic local function that does not capture any
-  // generic type parameters from the outer context, don't need a
-  // signature at all.
-  if (!dc->isInnermostContextGeneric() &&
-      dc->getParent()->isLocalContext() &&
-      !captureInfo.hasGenericParamCaptures()) {
+  if (dc->getParent()->isLocalContext() &&
+      !captureInfo.hasGenericParamCaptures())
     return nullptr;
-  }
 
   if (auto sig = dc->getGenericSignatureOfContext())
     return sig->getCanonicalSignature();
@@ -1832,8 +1826,7 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
   switch (c.kind) {
   case SILDeclRef::Kind::Func: {
     if (auto *ACE = c.loc.dyn_cast<AbstractClosureExpr *>()) {
-      // TODO: Substitute out archetypes from the enclosing context with generic
-      // parameters.
+      // FIXME: Closures could have an interface type computed by Sema.
       auto funcTy = cast<AnyFunctionType>(ACE->getType()->getCanonicalType());
       funcTy = cast<AnyFunctionType>(
           ArchetypeBuilder::mapTypeOutOfContext(ACE->getParent(), funcTy)
@@ -1844,10 +1837,6 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
     FuncDecl *func = cast<FuncDecl>(vd);
     auto funcTy = cast<AnyFunctionType>(
                                   func->getInterfaceType()->getCanonicalType());
-    if (func->getParent() && func->getParent()->isLocalContext())
-      funcTy = cast<AnyFunctionType>(
-          ArchetypeBuilder::mapTypeOutOfContext(func->getParent(), funcTy)
-              ->getCanonicalType());
     funcTy = cast<AnyFunctionType>(replaceDynamicSelfWithSelf(funcTy));
     return getFunctionInterfaceTypeWithCaptures(funcTy, func);
   }
@@ -1909,22 +1898,6 @@ TypeConverter::getConstantContextGenericParams(SILDeclRef c) {
     FuncDecl *func = cast<FuncDecl>(vd);
     auto captureInfo = getLoweredLocalCaptures(func);
 
-    // FIXME: This is really weird:
-    // 1) For generic functions, generic methods and generic
-    // local functions, we return the function's generic
-    // parameter list twice.
-    // 2) For non-generic methods inside generic types, we
-    // return the generic type's parameters and nullptr.
-    // 3) For non-generic local functions, we return the
-    // outer function's parameters and nullptr.
-    //
-    // Local generic functions could probably be modeled better
-    // at the SIL level.
-    if (func->isInnermostContextGeneric() ||
-        func->getDeclContext()->isGenericTypeContext()) {
-      if (auto GP = func->getGenericParamsOfContext())
-        return {GP, func->getGenericParams()};
-    }
     return {getEffectiveGenericParams(func, captureInfo),
             func->getGenericParams()};
   }

lib/SILGen/SILGenApply.cpp

@@ -1169,9 +1169,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     }
 
     ArrayRef<Substitution> subs;
-    if (e->getDeclRef().isSpecialized()) {
+    if (e->getDeclRef().isSpecialized())
       subs = e->getDeclRef().getSubstitutions();
-    }
 
     // Enum case constructor references are open-coded.
     if (isa<EnumElementDecl>(e->getDecl()))
@@ -1191,14 +1190,13 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                          captures);
         ApplyCallee->setCaptures(std::move(captures));
       }
-
-      if (subs.empty() && afd->getCaptureInfo().hasGenericParamCaptures()) {
-        subs = SGF.getForwardingSubstitutions();
-      }
     }
 
     // If there are substitutions, add them, always at depth 0.
-    if (!subs.empty())
+    if (!subs.empty() &&
+        (!afd ||
+         !afd->getDeclContext()->isLocalContext() ||
+         afd->getCaptureInfo().hasGenericParamCaptures()))
       ApplyCallee->setSubstitutions(SGF, e, subs, 0);
   }
 

lib/SILGen/SILGenFunction.cpp

@@ -337,6 +337,7 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
                                  ArrayRef<Substitution> subs) {
   auto closure = *constant.getAnyFunctionRef();
   auto captureInfo = closure.getCaptureInfo();
+  auto loweredCaptureInfo = SGM.Types.getLoweredLocalCaptures(closure);
 
   assert(((constant.uncurryLevel == 1 &&
            captureInfo.hasLocalCaptures()) ||
@@ -351,17 +352,21 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
   // Apply substitutions.
   auto pft = constantInfo.SILFnType;
 
+  auto *dc = closure.getAsDeclContext()->getParent();
+  if (dc->isLocalContext() && !loweredCaptureInfo.hasGenericParamCaptures()) {
+    // If the lowered function type is not polymorphic but we were given
+    // substitutions, we have a closure in a generic context which does not
+    // capture generic parameters. Just drop the substitutions.
+    subs = { };
+  } else if (closure.getAbstractClosureExpr()) {
+    // If we have a closure expression in generic context, Sema won't give
+    // us substitutions, so we just use the forwarding substitutions from
+    // context.
+    subs = getForwardingSubstitutions();
+  }
+
   bool wasSpecialized = false;
-  if (pft->isPolymorphic()) {
-    // If the lowered function type is generic but Sema did not hand us any
-    // substitutions, the function is a local function that appears in a
-    // generic context but does not have a generic parameter list of its own;
-    // just use our forwarding substitutions.
-    if (subs.empty()) {
-      assert(closure.getAsDeclContext()->isLocalContext() &&
-             "cannot reference generic global function without substitutions");
-      subs = getForwardingSubstitutions();
-    }
+  if (!subs.empty()) {
     auto specialized = pft->substGenericArgs(F.getModule(),
                                              F.getModule().getSwiftModule(),
                                              subs);

lib/Sema/CSApply.cpp

@@ -754,7 +754,8 @@ namespace {
       ConcreteDeclRef memberRef;
       Type refTy;
       Type dynamicSelfFnType;
-      if (openedFullType->hasTypeVariable()) {
+      if (member->getInterfaceType()->is<GenericFunctionType>() ||
+          openedFullType->hasTypeVariable()) {
         // We require substitutions. Figure out what they are.
 
         // Figure out the declaration context where we'll get the generic

lib/Sema/CSGen.cpp

@@ -3462,7 +3462,7 @@ void swift::collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
                                                     VD->getFullName());
     if (Result.OtherViables.empty())
       continue;
-    if (!Result.Favored->getDeclContext()->isGenericTypeContext())
+    if (!Result.Favored->getDeclContext()->isGenericContext())
       continue;
     for (ValueDecl *Default : Result.OtherViables) {
       if (Default->getDeclContext()->isExtensionContext()) {

lib/Sema/CodeSynthesis.cpp

@@ -1274,7 +1274,7 @@ void TypeChecker::completePropertyBehaviorStorage(VarDecl *VD,
 
   // Add the witnesses to the conformance.
   ArrayRef<Substitution> MemberSubs;
-  if (DC->isGenericTypeContext()) {
+  if (DC->isGenericContext()) {
     MemberSubs = DC->getGenericParamsOfContext()
                    ->getForwardingSubstitutions(Context);
   }
@@ -1448,7 +1448,7 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
 
   // Add the witnesses to the conformance.
   ArrayRef<Substitution> MemberSubs;
-  if (DC->isGenericTypeContext()) {
+  if (DC->isGenericContext()) {
     MemberSubs = DC->getGenericParamsOfContext()
     ->getForwardingSubstitutions(Context);
   }
@@ -2079,7 +2079,7 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
   //
   // We might have to apply substitutions, if for example we have a declaration
   // like 'class A : B<Int>'.
-  if (superclassDecl->isGenericTypeContext()) {
+  if (superclassDecl->isGenericContext()) {
     if (auto *superclassSig = superclassDecl->getGenericSignatureOfContext()) {
       auto *moduleDecl = classDecl->getParentModule();
       auto subs = superclassTy->gatherAllSubstitutions(
@@ -2127,7 +2127,7 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
   auto selfType = configureImplicitSelf(tc, ctor);
 
   // Set the interface type of the initializer.
-  if (classDecl->isGenericTypeContext()) {
+  if (classDecl->isGenericContext()) {
     ctor->setGenericSignature(classDecl->getGenericSignatureOfContext());
     tc.configureInterfaceType(ctor);
   }