AST: Don't link together GenericParamLists of nested generic types

GenericParamList::OuterParameters would mirror the nesting structure
of generic DeclContexts. This resulted in redundant code and caused
unnecessary complications for extensions and protocols, whose
GenericParamLists are constructed after parse time.

Instead, lets only use OuterParameters to link together the multiple
parameter lists of a single extension, or parameter lists in SIL
functions.

Author: slavapestov

include/swift/AST/Decl.h

@@ -1377,22 +1377,11 @@ class GenericParamList final :
   void addTrailingWhereClause(ASTContext &ctx, SourceLoc trailingWhereLoc,
                               ArrayRef<RequirementRepr> trailingRequirements);
 
-  /// Retrieve the outer generic parameter list, which provides the
-  /// generic parameters of the context in which this generic parameter list
-  /// exists.
+  /// Retrieve the outer generic parameter list.
   ///
-  /// Consider the following generic class:
-  ///
-  /// \code
-  /// class Vector<T> {
-  ///   init<R : Range where R.Element == T>(range : R) { }
-  /// }
-  /// \endcode
-  ///
-  /// The generic parameter list <T> has no outer parameters, because it is
-  /// the outermost generic parameter list. The generic parameter list
-  /// <R : Range...> for the constructor has the generic parameter list <T> as
-  /// its outer generic parameter list.
+  /// This is used for extensions of nested types, and in SIL mode, where a
+  /// single lexical context can have multiple logical generic parameter
+  /// lists.
   GenericParamList *getOuterParameters() const { return OuterParameters; }
 
   /// Set the outer generic parameter list. See \c getOuterParameters
@@ -1422,10 +1411,8 @@ class GenericParamList final :
                        Requirements.back().getSourceRange().End);
   }
 
-  unsigned getDepth() const;
-
   /// Configure the depth of the generic parameters in this list.
-  void configureGenericParamDepth();
+  void setDepth(unsigned depth);
 
   /// Create a copy of the generic parameter list and all of its generic
   /// parameter declarations. The copied generic parameters are re-parented

include/swift/AST/DeclContext.h

@@ -336,6 +336,16 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// - Everything else falls back on getDeclaredInterfaceType().
   Type getSelfInterfaceType() const;
 
+  /// Visit the generic parameter list of every outer context, innermost first.
+  void forEachGenericContext(
+    llvm::function_ref<void (GenericParamList *)> fn) const;
+
+  /// Returns the depth of this generic context, or in other words,
+  /// the number of nested generic contexts minus one.
+  ///
+  /// This is (unsigned)-1 if none of the outer contexts are generic.
+  unsigned getGenericContextDepth() const;
+
   /// Retrieve the innermost generic parameters of this context or any
   /// of its parents.
   ///

include/swift/Serialization/ModuleFile.h

@@ -562,8 +562,7 @@ class ModuleFile
   ///
   /// If the record at the cursor is not a generic param list, returns null
   /// without moving the cursor.
-  GenericParamList *maybeReadGenericParams(DeclContext *DC,
-                                     GenericParamList *outerParams = nullptr);
+  GenericParamList *maybeReadGenericParams(DeclContext *DC);
 
   /// Reads a set of requirements from \c DeclTypeCursor.
   void readGenericRequirements(SmallVectorImpl<Requirement> &requirements,

lib/AST/ASTMangler.cpp

@@ -1053,8 +1053,6 @@ unsigned ASTMangler::appendBoundGenericArgs(DeclContext *dc,
     if (genericContext->isGeneric()) {
       auto genericParams = subs.getGenericSignature()->getGenericParams();
       unsigned depth = genericParams[currentGenericParamIdx]->getDepth();
-      assert(genericContext->getGenericParams()->getDepth() == depth &&
-             "Depth mismatch mangling substitution map");
       auto replacements = subs.getReplacementTypes();
       for (unsigned lastGenericParamIdx = genericParams.size();
            (currentGenericParamIdx != lastGenericParamIdx &&

lib/AST/ASTVerifier.cpp

@@ -2762,7 +2762,14 @@ class Verifier : public ASTWalker {
         abort();
       }
 
-      unsigned currentDepth = paramList->getDepth();
+      if (paramList->getOuterParameters() &&
+          !isa<ExtensionDecl>(DC)) {
+        Out << "GenericParamList can only have outer parameters in an "
+               "extension\n";
+        abort();
+      }
+
+      unsigned currentDepth = DC->getGenericContextDepth();
       if (currentDepth < GTPD->getDepth()) {
         Out << "GenericTypeParamDecl has incorrect depth\n";
         abort();

lib/AST/Decl.cpp

@@ -687,17 +687,7 @@ void GenericParamList::addTrailingWhereClause(
   Requirements = newRequirements;
 }
 
-unsigned GenericParamList::getDepth() const {
-  unsigned depth = 0;
-  for (auto gpList = getOuterParameters();
-       gpList != nullptr;
-       gpList = gpList->getOuterParameters())
-    ++depth;
-  return depth;
-}
-
-void GenericParamList::configureGenericParamDepth() {
-  unsigned depth = getDepth();
+void GenericParamList::setDepth(unsigned depth) {
   for (auto param : *this)
     param->setDepth(depth);
 }
@@ -1059,13 +1049,13 @@ AccessLevel ExtensionDecl::getMaxAccessLevel() const {
 /// Clone the given generic parameters in the given list. We don't need any
 /// of the requirements, because they will be inferred.
 static GenericParamList *cloneGenericParams(ASTContext &ctx,
-                                            DeclContext *dc,
+                                            ExtensionDecl *ext,
                                             GenericParamList *fromParams) {
   // Clone generic parameters.
   SmallVector<GenericTypeParamDecl *, 2> toGenericParams;
   for (auto fromGP : *fromParams) {
     // Create the new generic parameter.
-    auto toGP = new (ctx) GenericTypeParamDecl(dc, fromGP->getName(),
+    auto toGP = new (ctx) GenericTypeParamDecl(ext, fromGP->getName(),
                                                SourceLoc(),
                                                fromGP->getDepth(),
                                                fromGP->getIndex());
@@ -1075,40 +1065,28 @@ static GenericParamList *cloneGenericParams(ASTContext &ctx,
     toGenericParams.push_back(toGP);
   }
 
-  auto toParams = GenericParamList::create(ctx, SourceLoc(), toGenericParams,
-                                           SourceLoc());
-
-  auto outerParams = fromParams->getOuterParameters();
-  if (outerParams != nullptr)
-    outerParams = cloneGenericParams(ctx, dc, outerParams);
-  toParams->setOuterParameters(outerParams);
-
-  return toParams;
+  return GenericParamList::create(ctx, SourceLoc(), toGenericParams,
+                                  SourceLoc());
 }
 
-/// Ensure that the outer generic parameters of the given generic
-/// context have been configured.
-static void configureOuterGenericParams(const GenericContext *dc) {
-  auto genericParams = dc->getGenericParams();
-
-  // If we already configured the outer parameters, we're done.
-  if (genericParams && genericParams->getOuterParameters())
-    return;
-
-  DeclContext *outerDC = dc->getParent();
-  while (!outerDC->isModuleScopeContext()) {
-    if (auto outerDecl = outerDC->getAsDecl()) {
-      if (auto outerGenericDC = outerDecl->getAsGenericContext()) {
-        if (genericParams)
-          genericParams->setOuterParameters(outerGenericDC->getGenericParams());
-
-        configureOuterGenericParams(outerGenericDC);
-        return;
-      }
-    }
+static GenericParamList *
+createExtensionGenericParams(ASTContext &ctx,
+                             ExtensionDecl *ext,
+                             NominalTypeDecl *nominal) {
+  // Collect generic parameters from all outer contexts.
+  SmallVector<GenericParamList *, 2> allGenericParams;
+  nominal->forEachGenericContext([&](GenericParamList *gpList) {
+    allGenericParams.push_back(
+      cloneGenericParams(ctx, ext, gpList));
+  });
 
-    outerDC = outerDC->getParent();
+  GenericParamList *toParams = nullptr;
+  for (auto *gpList : reversed(allGenericParams)) {
+    gpList->setOuterParameters(toParams);
+    toParams = gpList;
   }
+
+  return toParams;
 }
 
 void ExtensionDecl::createGenericParamsIfMissing(NominalTypeDecl *nominal) {
@@ -1125,14 +1103,10 @@ void ExtensionDecl::createGenericParamsIfMissing(NominalTypeDecl *nominal) {
     outerDC = outerDC->getParent();
   }
 
-  configureOuterGenericParams(nominal);
-
   // Create the generic parameter list for the extension by cloning the
   // generic parameter lists of the nominal and any of its parent types.
   auto &ctx = getASTContext();
-  auto *genericParams = nominal->getGenericParamsOfContext();
-  if (genericParams != nullptr)
-    genericParams = cloneGenericParams(ctx, this, genericParams);
+  auto *genericParams = createExtensionGenericParams(ctx, this, nominal);
   setGenericParams(genericParams);
 
   // Protocol extensions need an inheritance clause due to how name lookup
@@ -1145,10 +1119,11 @@ void ExtensionDecl::createGenericParamsIfMissing(NominalTypeDecl *nominal) {
   }
 
   // Set the depth of every generic parameter.
+  unsigned depth = nominal->getGenericContextDepth();
   for (auto *outerParams = genericParams;
        outerParams != nullptr;
        outerParams = outerParams->getOuterParameters())
-    outerParams->configureGenericParamDepth();
+    outerParams->setDepth(depth--);
 
   // If we have a trailing where clause, deal with it now.
   // For now, trailing where clauses are only permitted on protocol extensions.
@@ -4301,8 +4276,6 @@ void ProtocolDecl::createGenericParamsIfMissing() {
   if (getGenericParams())
     return;
 
-  auto *outerGenericParams = getParent()->getGenericParamsOfContext();
-
   // The generic parameter 'Self'.
   auto &ctx = getASTContext();
   auto selfId = ctx.Id_Self;
@@ -4318,7 +4291,6 @@ void ProtocolDecl::createGenericParamsIfMissing() {
   // The generic parameter list itself.
   auto result = GenericParamList::create(ctx, SourceLoc(), selfDecl,
                                          SourceLoc());
-  result->setOuterParameters(outerGenericParams);
   setGenericParams(result);
 }
 

lib/AST/DeclContext.cpp

@@ -123,12 +123,42 @@ Type DeclContext::getDeclaredInterfaceType() const {
   return Type();
 }
 
+void DeclContext::forEachGenericContext(
+    llvm::function_ref<void (GenericParamList *)> fn) const {
+  auto dc = this;
+  do {
+    if (auto decl = dc->getAsDecl()) {
+      // Extensions do not capture outer generic parameters.
+      if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
+        for (auto *gpList = ext->getGenericParams();
+             gpList != nullptr;
+             gpList = gpList->getOuterParameters()) {
+          fn(gpList);
+        }
+
+        return;
+      }
+
+      if (auto genericCtx = decl->getAsGenericContext())
+        if (auto *gpList = genericCtx->getGenericParams())
+          fn(gpList);
+    }
+  } while ((dc = dc->getParent()));
+}
+
+unsigned DeclContext::getGenericContextDepth() const {
+  unsigned depth = -1;
+  forEachGenericContext([&](GenericParamList *) { ++depth; });
+  return depth;
+}
+
 GenericParamList *DeclContext::getGenericParamsOfContext() const {
   auto dc = this;
   do {
     if (auto decl = dc->getAsDecl()) {
       if (auto GC = decl->getAsGenericContext()) {
         auto GP = GC->getGenericParams();
+
         // Extensions do not capture outer generic parameters.
         if (GP != nullptr || isa<ExtensionDecl>(decl))
           return GP;

lib/AST/NameLookup.cpp

@@ -1077,11 +1077,6 @@ UnqualifiedLookup::UnqualifiedLookup(DeclName Name, DeclContext *DC,
           if (shouldReturnBasedOnResults())
             return;
 
-          // Extensions of nested types have multiple levels of
-          // generic parameters, so we have to visit them explicitly.
-          if (!isa<ExtensionDecl>(DC))
-            break;
-
           dcGenericParams = dcGenericParams->getOuterParameters();
         }
 

lib/Sema/CodeSynthesis.cpp

@@ -1811,7 +1811,6 @@ configureGenericDesignatedInitOverride(ASTContext &ctx,
                                              SourceLoc(),
                                              ArrayRef<RequirementRepr>(),
                                              SourceLoc());
-    genericParams->setOuterParameters(classDecl->getGenericParamsOfContext());
 
     // Build a generic signature for the derived class initializer.
     GenericSignatureBuilder builder(ctx);

lib/Sema/TypeCheckDecl.cpp

@@ -640,14 +640,16 @@ TypeChecker::handleSILGenericParams(GenericParamList *genericParams,
     nestedList.push_back(genericParams);
   }
 
+  std::reverse(nestedList.begin(), nestedList.end());
+
   // Since the innermost GenericParamList is in the beginning of the vector,
   // we process in reverse order to handle the outermost list first.
   GenericSignature *parentSig = nullptr;
   GenericEnvironment *parentEnv = nullptr;
 
-  for (unsigned i = 0, e = nestedList.size(); i < e; i++) {
-    auto genericParams = nestedList.rbegin()[i];
-    genericParams->configureGenericParamDepth();
+  for (unsigned i = 0, e = nestedList.size(); i < e; ++i) {
+    auto genericParams = nestedList[i];
+    genericParams->setDepth(i);
 
     parentEnv = checkGenericEnvironment(genericParams, DC, parentSig,
                                         /*allowConcreteGenericParams=*/true,
@@ -4172,9 +4174,7 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
     proto->computeType();
 
     auto *gp = proto->getGenericParams();
-    unsigned depth = gp->getDepth();
-    for (auto paramDecl : *gp)
-      paramDecl->setDepth(depth);
+    gp->setDepth(proto->getGenericContextDepth());
 
     for (auto ATD : proto->getAssociatedTypeMembers()) {
       validateDeclForNameLookup(ATD);