Improve the mangling of typealiases.

- Allow them to use substitutions.
- Consistently use 'a' as a mangling operator.
- For generic typealiases, include the alias as context for any generic
  parameters.

Typealiases don't show up in symbol names, which always refer to
canonical types, but they are mangled for debug info and for USRs
(unique identifiers used by SourceKit), so it's good to get this
right.

Author: jrose-apple

docs/ABI.rst

@@ -889,7 +889,7 @@ Entities
   entity-spec ::= decl-name type 'i'                 // subscript ('i'ndex) itself (not the individual accessors)
   entity-spec ::= decl-name type 'v'                 // variable
   entity-spec ::= decl-name type 'f' ACCESSOR
-  entity-spec ::= decl-name type 'fp'                // generic type parameter (not used?)
+  entity-spec ::= decl-name type 'fp'                // generic type parameter
   entity-spec ::= decl-name type 'fo'                // enum element (currently not used)
 
   ACCESSOR ::= 'm'                           // materializeForSet
@@ -958,14 +958,15 @@ Types
 
 ::
 
-  nominal-type ::= substitution
-  nominal-type ::= context decl-name 'C'     // nominal class type
-  nominal-type ::= context decl-name 'O'     // nominal enum type
-  nominal-type ::= context decl-name 'V'     // nominal struct type
-  nominal-type ::= protocol 'P'              // nominal protocol type
+  any-generic-type ::= substitution
+  any-generic-type ::= context decl-name 'C'     // nominal class type
+  any-generic-type ::= context decl-name 'O'     // nominal enum type
+  any-generic-type ::= context decl-name 'V'     // nominal struct type
+  any-generic-type ::= protocol 'P'              // nominal protocol type
+  any-generic-type ::= context decl-name 'a'     // typealias type (used in DWARF and USRs)
 
-  nominal-type ::= 'S' KNOWN-TYPE-KIND       // known nominal type substitution
-  nominal-type ::= 'S' NATURAL KNOWN-TYPE-KIND    // repeated known type substitutions of the same kind
+  any-generic-type ::= 'S' KNOWN-TYPE-KIND       // known nominal type substitution
+  any-generic-type ::= 'S' NATURAL KNOWN-TYPE-KIND    // repeated known type substitutions of the same kind
 
   KNOWN-TYPE-KIND ::= 'a'                    // Swift.Array
   KNOWN-TYPE-KIND ::= 'b'                    // Swift.Bool
@@ -995,7 +996,6 @@ Types
   type ::= 'Bp'                              // Builtin.RawPointer
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
   type ::= 'Bw'                              // Builtin.Word
-  type ::= context decl-name 'a'             // Type alias (DWARF only)
   type ::= function-signature 'c'            // function type
   type ::= function-signature 'X' FUNCTION-KIND // special function type
   type ::= bound-generic-type
@@ -1042,7 +1042,7 @@ Types
 
   type ::= archetype
   type ::= associated-type
-  type ::= nominal-type
+  type ::= any-generic-type
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject

include/swift/AST/ASTMangler.h

@@ -172,7 +172,7 @@ class ASTMangler : public Mangler {
 
   void appendProtocolName(const ProtocolDecl *protocol);
 
-  void appendNominalType(const NominalTypeDecl *decl);
+  void appendAnyGenericType(const GenericTypeDecl *decl);
 
   void appendFunctionType(AnyFunctionType *fn, bool forceSingleParam);
 
@@ -212,7 +212,7 @@ class ASTMangler : public Mangler {
 
   void appendDeclType(const ValueDecl *decl, bool isFunctionMangling = false);
 
-  bool tryAppendStandardSubstitution(const NominalTypeDecl *type);
+  bool tryAppendStandardSubstitution(const GenericTypeDecl *type);
 
   void appendConstructorEntity(const ConstructorDecl *ctor, bool isAllocating);
 

include/swift/Demangling/DemangleNodes.def

@@ -149,7 +149,7 @@ NODE(Tuple)
 NODE(TupleElement)
 NODE(TupleElementName)
 NODE(Type)
-NODE(TypeAlias)
+CONTEXT_NODE(TypeAlias)
 NODE(TypeList)
 NODE(TypeMangling)
 NODE(TypeMetadata)

include/swift/Demangling/Demangler.h

@@ -405,8 +405,7 @@ class Demangler : public NodeFactory {
   NodePointer popTypeAndGetChild();
   NodePointer popTypeAndGetNominal();
   NodePointer demangleBuiltinType();
-  NodePointer demangleNominalType(Node::Kind kind);
-  NodePointer demangleTypeAlias();
+  NodePointer demangleAnyGenericType(Node::Kind kind);
   NodePointer demangleExtensionContext();
   NodePointer demanglePlainFunction();
   NodePointer popFunctionType(Node::Kind kind);

lib/AST/ASTMangler.cpp

@@ -127,7 +127,7 @@ std::string ASTMangler::mangleInitializerEntity(const VarDecl *var,
 
 std::string ASTMangler::mangleNominalType(const NominalTypeDecl *decl) {
   beginMangling();
-  appendNominalType(decl);
+  appendAnyGenericType(decl);
   return finalize();
 }
 
@@ -322,7 +322,7 @@ std::string ASTMangler::mangleObjCRuntimeName(const NominalTypeDecl *Nominal) {
   }
   // For all other cases, we can use the new mangling.
   beginMangling();
-  appendNominalType(Nominal);
+  appendAnyGenericType(Nominal);
   return finalize();
 }
 
@@ -342,9 +342,9 @@ std::string ASTMangler::mangleDeclAsUSR(const ValueDecl *Decl,
     appendConstructorEntity(Ctor, /*isAllocating=*/false);
   } else if (auto Dtor = dyn_cast<DestructorDecl>(Decl)) {
     appendDestructorEntity(Dtor, /*isDeallocating=*/false);
-  } else if (auto NTD = dyn_cast<NominalTypeDecl>(Decl)) {
-    appendNominalType(NTD);
-  } else if (isa<TypeAliasDecl>(Decl) || isa<AssociatedTypeDecl>(Decl)) {
+  } else if (auto GTD = dyn_cast<GenericTypeDecl>(Decl)) {
+    appendAnyGenericType(GTD);
+  } else if (isa<AssociatedTypeDecl>(Decl)) {
     appendContextOf(Decl);
     appendDeclName(Decl);
   } else {
@@ -510,7 +510,7 @@ static const char *getMetatypeRepresentationOp(MetatypeRepresentation Rep) {
   llvm_unreachable("Unhandled MetatypeRepresentation in switch.");
 }
 
-static bool isStdlibType(const NominalTypeDecl *decl) {
+static bool isStdlibType(const TypeDecl *decl) {
   DeclContext *dc = decl->getDeclContext();
   return dc->isModuleScopeContext() && dc->getParentModule()->isStdlibModule();
 }
@@ -580,9 +580,7 @@ void ASTMangler::appendType(Type type) {
 
       // For the DWARF output we want to mangle the type alias + context,
       // unless the type alias references a builtin type.
-      appendContextOf(decl);
-      appendDeclName(decl);
-      return appendOperator("a");
+      return appendAnyGenericType(decl);
     }
 
     case TypeKind::Paren:
@@ -693,15 +691,15 @@ void ASTMangler::appendType(Type type) {
           appendType(GenArgs[0]);
           appendOperator("Sg");
         } else {
-          appendNominalType(NDecl);
+          appendAnyGenericType(NDecl);
           bool isFirstArgList = true;
           appendBoundGenericArgs(type, isFirstArgList);
           appendOperator("G");
         }
         addSubstitution(type.getPointer());
         return;
       }
-      appendNominalType(tybase->getAnyNominal());
+      appendAnyGenericType(tybase->getAnyNominal());
       return;
 
     case TypeKind::SILFunction:
@@ -1143,10 +1141,7 @@ void ASTMangler::appendContext(const DeclContext *ctx) {
   }
 
   case DeclContextKind::GenericTypeDecl:
-    if (auto nomctx = dyn_cast<NominalTypeDecl>(ctx))
-      appendNominalType(nomctx);
-    else
-      appendContext(ctx->getParent());
+    appendAnyGenericType(cast<GenericTypeDecl>(ctx));
     return;
 
   case DeclContextKind::ExtensionDecl: {
@@ -1173,15 +1168,15 @@ void ASTMangler::appendContext(const DeclContext *ctx) {
       auto sig = ExtD->getGenericSignature();
       // If the extension is constrained, mangle the generic signature that
       // constrains it.
-      appendNominalType(decl);
+      appendAnyGenericType(decl);
       appendModule(ExtD->getParentModule());
       if (sig && ExtD->isConstrainedExtension()) {
         Mod = ExtD->getModuleContext();
         appendGenericSignature(sig);
       }
       return appendOperator("E");
     }
-    return appendNominalType(decl);
+    return appendAnyGenericType(decl);
   }
 
   case DeclContextKind::AbstractClosureExpr:
@@ -1258,42 +1253,50 @@ void ASTMangler::appendProtocolName(const ProtocolDecl *protocol) {
   appendDeclName(protocol);
 }
 
-void ASTMangler::appendNominalType(const NominalTypeDecl *decl) {
+void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
   // Check for certain standard types.
   if (tryAppendStandardSubstitution(decl))
     return;
 
   // For generic types, this uses the unbound type.
-  TypeBase *key = decl->getDeclaredType().getPointer();
+  Type key;
+  if (auto *alias = dyn_cast<TypeAliasDecl>(decl)) {
+    if (alias->isGeneric())
+      key = alias->getUnboundGenericType();
+    else
+      key = alias->getDeclaredInterfaceType();
+  } else {
+    key = cast<NominalTypeDecl>(decl)->getDeclaredType();
+  }
 
   // Try to mangle the entire name as a substitution.
-  if (tryMangleSubstitution(key))
+  if (tryMangleSubstitution(key.getPointer()))
     return;
 
   appendContextOf(decl);
   appendDeclName(decl);
 
   switch (decl->getKind()) {
-#define NOMINAL_TYPE_DECL(id, parent)
-#define DECL(id, parent) \
-    case DeclKind::id:
-#include "swift/AST/DeclNodes.def"
-      llvm_unreachable("not a nominal type");
-
-    case DeclKind::Protocol:
-      appendOperator("P");
-      break;
-    case DeclKind::Class:
-      appendOperator("C");
-      break;
-    case DeclKind::Enum:
-      appendOperator("O");
-      break;
-    case DeclKind::Struct:
-      appendOperator("V");
-      break;
+  default:
+    llvm_unreachable("not a nominal type");
+
+  case DeclKind::TypeAlias:
+    appendOperator("a");
+    break;
+  case DeclKind::Protocol:
+    appendOperator("P");
+    break;
+  case DeclKind::Class:
+    appendOperator("C");
+    break;
+  case DeclKind::Enum:
+    appendOperator("O");
+    break;
+  case DeclKind::Struct:
+    appendOperator("V");
+    break;
   }
-  addSubstitution(key);
+  addSubstitution(key.getPointer());
 }
 
 void ASTMangler::appendFunctionType(AnyFunctionType *fn,
@@ -1522,7 +1525,7 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt) {
   appendIdentifier(assocTy->getName().str());
   if (!OptimizeProtocolNames || !CurGenericSignature || !Mod
       || CurGenericSignature->getConformsTo(dmt->getBase(), *Mod).size() > 1) {
-    appendNominalType(assocTy->getProtocol());
+    appendAnyGenericType(assocTy->getProtocol());
   }
 }
 
@@ -1708,7 +1711,7 @@ void ASTMangler::appendDeclType(const ValueDecl *decl, bool isFunctionMangling)
   }
 }
 
-bool ASTMangler::tryAppendStandardSubstitution(const NominalTypeDecl *decl) {
+bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {
   // Bail out if our parent isn't the swift standard library.
   if (!isStdlibType(decl))
     return false;

lib/Demangling/Demangler.cpp

@@ -362,7 +362,7 @@ NodePointer Demangler::demangleOperator() {
   switch (char c = nextChar()) {
     case 'A': return demangleMultiSubstitutions();
     case 'B': return demangleBuiltinType();
-    case 'C': return demangleNominalType(Node::Kind::Class);
+    case 'C': return demangleAnyGenericType(Node::Kind::Class);
     case 'D': return createWithChild(Node::Kind::TypeMangling,
                                      popNode(Node::Kind::Type));
     case 'E': return demangleExtensionContext();
@@ -374,17 +374,17 @@ NodePointer Demangler::demangleOperator() {
     case 'M': return demangleMetatype();
     case 'N': return createWithChild(Node::Kind::TypeMetadata,
                                      popNode(Node::Kind::Type));
-    case 'O': return demangleNominalType(Node::Kind::Enum);
-    case 'P': return demangleNominalType(Node::Kind::Protocol);
+    case 'O': return demangleAnyGenericType(Node::Kind::Enum);
+    case 'P': return demangleAnyGenericType(Node::Kind::Protocol);
     case 'Q': return demangleArchetype();
     case 'R': return demangleGenericRequirement();
     case 'S': return demangleStandardSubstitution();
     case 'T': return demangleThunkOrSpecialization();
-    case 'V': return demangleNominalType(Node::Kind::Structure);
+    case 'V': return demangleAnyGenericType(Node::Kind::Structure);
     case 'W': return demangleWitness();
     case 'X': return demangleSpecialType();
     case 'Z': return createWithChild(Node::Kind::Static, popNode(isEntity));
-    case 'a': return demangleTypeAlias();
+    case 'a': return demangleAnyGenericType(Node::Kind::TypeAlias);
     case 'c': return popFunctionType(Node::Kind::FunctionType);
     case 'd': return createNode(Node::Kind::VariadicMarker);
     case 'f': return demangleFunctionEntity();
@@ -759,20 +759,14 @@ NodePointer Demangler::demangleBuiltinType() {
   return createType(Ty);
 }
 
-NodePointer Demangler::demangleNominalType(Node::Kind kind) {
+NodePointer Demangler::demangleAnyGenericType(Node::Kind kind) {
   NodePointer Name = popNode(isDeclName);
   NodePointer Ctx = popContext();
   NodePointer NTy = createType(createWithChildren(kind, Ctx, Name));
   addSubstitution(NTy);
   return NTy;
 }
 
-NodePointer Demangler::demangleTypeAlias() {
-  NodePointer Name = popNode(isDeclName);
-  NodePointer Ctx = popContext();
-  return createType(createWithChildren(Node::Kind::TypeAlias, Ctx, Name));
-}
-
 NodePointer Demangler::demangleExtensionContext() {
   NodePointer GenSig = popNode(Node::Kind::DependentGenericSignature);
   NodePointer Module = popModule();

lib/Demangling/Remangler.cpp

@@ -271,7 +271,7 @@ class Remangler {
   }
 
   void mangleAnyNominalType(Node *node);
-  void mangleNominalType(Node *node, char TypeOp);
+  void mangleAnyGenericType(Node *node, char TypeOp);
   void mangleGenericArgs(Node *node, char &Separator);
 
 #define NODE(ID)                                                        \
@@ -413,7 +413,7 @@ std::pair<int, Node *> Remangler::mangleConstrainedType(Node *node) {
   return {(int)Chain.size(), node};
 }
 
-void Remangler::mangleNominalType(Node *node, char TypeOp) {
+void Remangler::mangleAnyGenericType(Node *node, char TypeOp) {
   SubstitutionEntry entry;
   if (trySubstitution(node, entry)) return;
   mangleChildNodes(node);
@@ -436,9 +436,9 @@ void Remangler::mangleAnyNominalType(Node *node) {
     return;
   }
   switch (node->getKind()) {
-    case Node::Kind::Structure: return mangleNominalType(node, 'V');
-    case Node::Kind::Enum: return mangleNominalType(node, 'O');
-    case Node::Kind::Class: return mangleNominalType(node, 'C');
+    case Node::Kind::Structure: return mangleAnyGenericType(node, 'V');
+    case Node::Kind::Enum: return mangleAnyGenericType(node, 'O');
+    case Node::Kind::Class: return mangleAnyGenericType(node, 'C');
     default:
       unreachable("bad nominal type kind");
   }
@@ -1380,7 +1380,7 @@ void Remangler::manglePrivateDeclName(Node *node) {
 }
 
 void Remangler::mangleProtocol(Node *node) {
-  mangleNominalType(node, 'P');
+  mangleAnyGenericType(node, 'P');
 }
 
 void Remangler::mangleProtocolConformance(Node *node) {
@@ -1540,8 +1540,7 @@ void Remangler::mangleType(Node *node) {
 }
 
 void Remangler::mangleTypeAlias(Node *node) {
-  mangleChildNodes(node);
-  Buffer << 'a';
+  mangleAnyGenericType(node, 'a');
 }
 
 void Remangler::mangleTypeList(Node *node) {