AST: Fix mangling for nested generic types

Change the 'G' mangling to include generic parameters from
all levels of nested nominal types, and not just the innermost.

Note that the raw mangling syntax is something like this for
a nested type 'A<Int>.B<String>':

- bound_generic
  - struct 'B'
    - struct 'A'
      - module 'M'
  - args
    - Int
  - args
    - String

However, the actual mangling tree is more along the lines of:

- bound_generic_struct 'B'
  - bound_generic_struct 'A'
    - module 'M'
    - args
      - Int
  - args
    - String

This arrangement improves the quality of substitutions (we are
more likely to have a substitution for the entire unbound
generic type name 'A.B' around), and simplifies a few other
details.

Unfortunately, the remangling logic becomes slightly grotesque.

A simple SILGen test for nested generics exercises the mangling,
and ensures that Sema and SILGen do not crash with nested generics.

More detailed SILGen tests, as well as IRGen support for nested
generics is next.

Author: slavapestov

include/swift/AST/Mangle.h

@@ -92,6 +92,7 @@ class Mangler {
   void mangleClosureEntity(const AbstractClosureExpr *closure,
                            unsigned uncurryingLevel);
   void mangleNominalType(const NominalTypeDecl *decl);
+  void mangleBoundGenericType(Type type);
   void mangleProtocolDecl(const ProtocolDecl *protocol);
   void mangleType(Type type, unsigned uncurryingLevel);
   void mangleDirectness(bool isIndirect);

lib/AST/Mangle.cpp

@@ -940,32 +940,17 @@ void Mangler::mangleType(Type type, unsigned uncurryLevel) {
     Buffer << '_';
     return;
 
-  case TypeKind::UnboundGeneric: {
-    // We normally reject unbound types in IR-generation, but there
-    // are several occasions in which we'd like to mangle them in the
-    // abstract.
-    auto decl = cast<UnboundGenericType>(tybase)->getDecl();
-    mangleNominalType(cast<NominalTypeDecl>(decl));
-    return;
-  }
-
+  case TypeKind::UnboundGeneric:
   case TypeKind::Class:
   case TypeKind::Enum:
-  case TypeKind::Struct: {
-    return mangleNominalType(cast<NominalType>(tybase)->getDecl());
-  }
-
+  case TypeKind::Struct:
   case TypeKind::BoundGenericClass:
   case TypeKind::BoundGenericEnum:
   case TypeKind::BoundGenericStruct: {
-    // type ::= 'G' <type> <type>+ '_'
-    auto *boundType = cast<BoundGenericType>(tybase);
-    Buffer << 'G';
-    mangleNominalType(boundType->getDecl());
-    for (auto arg : boundType->getGenericArgs()) {
-      mangleType(arg, /*uncurry*/ 0);
-    }
-    Buffer << '_';
+    if (type->isSpecialized())
+      mangleBoundGenericType(type);
+    else
+      mangleNominalType(tybase->getAnyNominal());
     return;
   }
 
@@ -1332,6 +1317,46 @@ void Mangler::mangleNominalType(const NominalTypeDecl *decl) {
   addSubstitution(key);
 }
 
+static void
+collectBoundGenericArgs(Type type,
+                        SmallVectorImpl<SmallVector<Type, 2>> &genericArgs) {
+  if (auto *unboundType = type->getAs<UnboundGenericType>()) {
+    if (auto parent = unboundType->getParent())
+      collectBoundGenericArgs(parent, genericArgs);
+    genericArgs.push_back({});
+  } else if (auto *nominalType = type->getAs<NominalType>()) {
+    if (auto parent = nominalType->getParent())
+      collectBoundGenericArgs(parent, genericArgs);
+    genericArgs.push_back({});
+  } else {
+    auto *boundType = type->castTo<BoundGenericType>();
+    if (auto parent = boundType->getParent())
+      collectBoundGenericArgs(parent, genericArgs);
+
+    SmallVector<Type, 2> args;
+    for (auto arg : boundType->getGenericArgs())
+      args.push_back(arg);
+    genericArgs.push_back(args);
+  }
+}
+
+void Mangler::mangleBoundGenericType(Type type) {
+  // type ::= 'G' <type> (<type>+ '_')+
+  Buffer << 'G';
+  auto *nominal = type->getAnyNominal();
+  mangleNominalType(nominal);
+
+  SmallVector<SmallVector<Type, 2>, 2> genericArgs;
+  collectBoundGenericArgs(type, genericArgs);
+  assert(!genericArgs.empty());
+
+  for (auto args : genericArgs) {
+    for (auto arg : args)
+      mangleType(arg, /*uncurry*/ 0);
+    Buffer << '_';
+  }
+}
+
 void Mangler::mangleProtocolDecl(const ProtocolDecl *protocol) {
   Buffer << 'P';
   mangleContextOf(protocol);

lib/Basic/Demangle.cpp

@@ -1154,6 +1154,73 @@ class Demangler {
     return nullptr;
   }
 
+  NodePointer demangleBoundGenericArgs(NodePointer nominalType) {
+    // Generic arguments for the outermost type come first.
+    NodePointer parentOrModule = nominalType->getChild(0);
+    if (parentOrModule->getKind() != Node::Kind::Module) {
+      parentOrModule = demangleBoundGenericArgs(parentOrModule);
+
+      // Rebuild this type with the new parent type, which may have
+      // had its generic arguments applied.
+      NodePointer result = NodeFactory::create(nominalType->getKind());
+      result->addChild(parentOrModule);
+      result->addChild(nominalType->getChild(1));
+
+      nominalType = result;
+    }
+
+    NodePointer args = NodeFactory::create(Node::Kind::TypeList);
+    while (!Mangled.nextIf('_')) {
+      NodePointer type = demangleType();
+      if (!type)
+        return nullptr;
+      args->addChild(type);
+      if (Mangled.isEmpty())
+        return nullptr;
+    }
+
+    // If there were no arguments at this level there is nothing left
+    // to do.
+    if (args->getNumChildren() == 0)
+      return nominalType;
+
+    // Otherwise, build a bound generic type node from the unbound
+    // type and arguments.
+    NodePointer unboundType = NodeFactory::create(Node::Kind::Type);
+    unboundType->addChild(nominalType);
+
+    Node::Kind kind;
+    switch (nominalType->getKind()) { // look through Type node
+      case Node::Kind::Class:
+        kind = Node::Kind::BoundGenericClass;
+        break;
+      case Node::Kind::Structure:
+        kind = Node::Kind::BoundGenericStructure;
+        break;
+      case Node::Kind::Enum:
+        kind = Node::Kind::BoundGenericEnum;
+        break;
+      default:
+        return nullptr;
+    }
+    NodePointer result = NodeFactory::create(kind);
+    result->addChild(unboundType);
+    result->addChild(args);
+    return result;
+  }
+
+  NodePointer demangleBoundGenericType() {
+    // bound-generic-type ::= 'G' nominal-type (args+ '_')+
+    //
+    // Each level of nominal type nesting has its own list of arguments.
+
+    NodePointer nominalType = demangleNominalType();
+    if (!nominalType)
+      return nullptr;
+
+    return demangleBoundGenericArgs(nominalType);
+  }
+
   NodePointer demangleContext() {
     // context ::= module
     // context ::= entity
@@ -1191,6 +1258,8 @@ class Demangler {
       return demangleSubstitutionIndex();
     if (Mangled.nextIf('s'))
       return NodeFactory::create(Node::Kind::Module, STDLIB_NAME);
+    if (Mangled.nextIf('G'))
+      return demangleBoundGenericType();
     if (isStartOfEntity(Mangled.peek()))
       return demangleEntity();
     return demangleModule();
@@ -1872,37 +1941,7 @@ class Demangler {
       return demangleFunctionType(Node::Kind::UncurriedFunctionType);
     }
     if (c == 'G') {
-      NodePointer unboundType = demangleType();
-      if (!unboundType)
-        return nullptr;
-      NodePointer type_list = NodeFactory::create(Node::Kind::TypeList);
-      while (!Mangled.nextIf('_')) {
-        NodePointer type = demangleType();
-        if (!type)
-          return nullptr;
-        type_list->addChild(type);
-        if (Mangled.isEmpty())
-          return nullptr;
-      }
-      Node::Kind bound_type_kind;
-      switch (unboundType->getChild(0)->getKind()) { // look through Type node
-        case Node::Kind::Class:
-          bound_type_kind = Node::Kind::BoundGenericClass;
-          break;
-        case Node::Kind::Structure:
-          bound_type_kind = Node::Kind::BoundGenericStructure;
-          break;
-        case Node::Kind::Enum:
-          bound_type_kind = Node::Kind::BoundGenericEnum;
-          break;
-        default:
-          return nullptr;
-      }
-      NodePointer type_application =
-          NodeFactory::create(bound_type_kind);
-      type_application->addChild(unboundType);
-      type_application->addChild(type_list);
-      return type_application;
+      return demangleBoundGenericType();
     }
     if (c == 'X') {
       if (Mangled.nextIf('b')) {
@@ -2049,10 +2088,8 @@ class Demangler {
 
       return nullptr;
     }
-    if (isStartOfNominalType(c)) {
-      NodePointer nominal_type = demangleDeclarationName(nominalTypeMarkerToNodeKind(c));
-      return nominal_type;
-    }
+    if (isStartOfNominalType(c))
+      return demangleDeclarationName(nominalTypeMarkerToNodeKind(c));
     return nullptr;
   }