Mangling: add a few utility functions in the new mangler and demangler which will be used by reflection mangling

Author: eeckstein

include/swift/AST/ASTMangler.h

@@ -39,7 +39,7 @@ class ASTMangler : public Mangler {
   const DeclContext *DeclCtx = nullptr;
 
   /// Optimize out protocol names if a type only conforms to one protocol.
-  bool OptimizeProtocolNames;
+  bool OptimizeProtocolNames = true;
 
   /// If enabled, Arche- and Alias types are mangled with context.
   bool DWARFMangling;
@@ -55,10 +55,8 @@ class ASTMangler : public Mangler {
   };
 
   ASTMangler(bool DWARFMangling = false,
-          bool usePunycode = true,
-          bool OptimizeProtocolNames = true)
+          bool usePunycode = true)
     : Mangler(usePunycode),
-      OptimizeProtocolNames(OptimizeProtocolNames),
       DWARFMangling(DWARFMangling) {}
 
   std::string mangleClosureEntity(const AbstractClosureExpr *closure,
@@ -115,7 +113,9 @@ class ASTMangler : public Mangler {
 
   std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
 
-  std::string mangleTypeAsUSR(Type type);
+  std::string mangleTypeAsUSR(Type type) {
+    return mangleTypeWithoutPrefix(type);
+  }
 
   std::string mangleTypeAsContextUSR(const NominalTypeDecl *type);
 
@@ -225,6 +225,11 @@ class ASTMangler : public Mangler {
 
   void appendOpParamForLayoutConstraint(LayoutConstraint Layout);
 
+  std::string mangleTypeWithoutPrefix(Type type) {
+    appendType(type);
+    return finalize();
+  }
+
   static bool checkGenericParamsOrder(ArrayRef<GenericTypeParamType *> params);
 };
 

include/swift/Basic/Demangler.h

@@ -114,6 +114,8 @@ class Demangler {
 
   NodePointer demangleTopLevel();
 
+  NodePointer demangleType();
+
 private:
 
   void addSubstitution(NodePointer Nd) {
@@ -166,6 +168,8 @@ class Demangler {
     return createWithChild(kind, popNode(Node::Kind::Type));
   }
 
+  void parseAndPushNodes();
+
   NodePointer changeKind(NodePointer Node, Node::Kind NewKind);
 
   NodePointer demangleOperator();

lib/AST/ASTMangler.cpp

@@ -272,11 +272,6 @@ std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC) {
   return finalize();
 }
 
-std::string ASTMangler::mangleTypeAsUSR(Type type) {
-  appendType(type);
-  return finalize();
-}
-
 std::string ASTMangler::mangleTypeAsContextUSR(const NominalTypeDecl *type) {
   appendContext(type);
   return finalize();

lib/Basic/Demangler.cpp

@@ -116,16 +116,9 @@ NodePointer Demangler::demangleTopLevel() {
 
   NodePointer topLevel = NodeFactory::create(Node::Kind::Global);
 
-  int Idx = 0;
-  while (!Text.empty()) {
-    NodePointer Node = demangleOperator();
-    if (!Node)
-      break;
-    pushNode(Node);
-    Idx++;
-  }
+  parseAndPushNodes();
 
-  // Let a trailing '_' be part of the not demangled suffix. 
+  // Let a trailing '_' be part of the not demangled suffix.
   popNode(Node::Kind::FirstElementMarker);
 
   size_t EndPos = (NodeStack.empty() ? 0 : NodeStack.back().Pos);
@@ -167,6 +160,26 @@ NodePointer Demangler::demangleTopLevel() {
   return topLevel;
 }
 
+NodePointer Demangler::demangleType() {
+  parseAndPushNodes();
+
+  if (NodePointer Result = popNode())
+    return Result;
+
+  return NodeFactory::create(Node::Kind::Suffix, Text);
+}
+
+void Demangler::parseAndPushNodes() {
+  int Idx = 0;
+  while (!Text.empty()) {
+    NodePointer Node = demangleOperator();
+    if (!Node)
+      break;
+    pushNode(Node);
+    Idx++;
+  }
+}
+
 NodePointer Demangler::changeKind(NodePointer Node, Node::Kind NewKind) {
   if (!Node)
     return nullptr;

lib/IRGen/IRGenMangler.cpp

@@ -49,3 +49,14 @@ std::string IRGenMangler::manglePartialApplyForwarder(StringRef FuncName) {
   appendOperator("TA");
   return finalize();
 }
+
+std::string IRGenMangler::mangleTypeForReflection(Type Ty,
+                                                  ModuleDecl *Module,
+                                                  bool isSingleFieldOfBox) {
+  Mod = Module;
+  OptimizeProtocolNames = false;
+  appendType(Ty);
+  if (isSingleFieldOfBox)
+    appendOperator("Xb");
+  return finalize();
+}

lib/IRGen/IRGenMangler.h

@@ -162,6 +162,13 @@ class IRGenMangler : public NewMangling::ASTMangler {
 
   std::string manglePartialApplyForwarder(StringRef FuncName);
 
+  std::string mangleTypeForMetadata(Type type) {
+    return mangleTypeWithoutPrefix(type);
+  }
+
+  std::string mangleTypeForReflection(Type Ty, ModuleDecl *Module,
+                                      bool isSingleFieldOfBox);
+
 protected:
 
   std::string mangleTypeSymbol(Type type, const char *Op) {