demangling: Drop the support of "unmangled suffix"

Either the demangling completely succeeds or it fails. Don't demangle to something like: [...] with unmangled suffix "..."

This avoids getting really stupid demangled names for symbols which are actually not swift symbols.

Author: eeckstein

include/swift/Demangling/Demangler.h

@@ -286,16 +286,11 @@ class CharVector : public Vector<char> {
 /// It de-mangles a string and it also owns the returned node-tree. This means
 /// The nodes of the tree only live as long as the Demangler itself.
 class Demangler : public NodeFactory {
-private:
+protected:
   StringRef Text;
   size_t Pos = 0;
 
-  struct NodeWithPos {
-    NodePointer Node;
-    size_t Pos;
-  };
-
-  Vector<NodeWithPos> NodeStack;
+  Vector<NodePointer> NodeStack;
   Vector<NodePointer> Substitutions;
   Vector<unsigned> PendingSubstitutions;
 
@@ -334,18 +329,18 @@ class Demangler : public NodeFactory {
   }
 
   void pushNode(NodePointer Nd) {
-    NodeStack.push_back({ Nd, Pos }, *this);
+    NodeStack.push_back(Nd, *this);
   }
 
   NodePointer popNode() {
-    return NodeStack.pop_back_val().Node;
+    return NodeStack.pop_back_val();
   }
 
   NodePointer popNode(Node::Kind kind) {
     if (NodeStack.empty())
       return nullptr;
 
-    Node::Kind NdKind = NodeStack.back().Node->getKind();
+    Node::Kind NdKind = NodeStack.back()->getKind();
     if (NdKind != kind)
       return nullptr;
 
@@ -356,7 +351,7 @@ class Demangler : public NodeFactory {
     if (NodeStack.empty())
       return nullptr;
 
-    Node::Kind NdKind = NodeStack.back().Node->getKind();
+    Node::Kind NdKind = NodeStack.back()->getKind();
     if (!pred(NdKind))
       return nullptr;
 
@@ -381,7 +376,7 @@ class Demangler : public NodeFactory {
     return createWithChild(kind, popNode(Node::Kind::Type));
   }
 
-  void parseAndPushNodes();
+  bool parseAndPushNodes();
 
   NodePointer changeKind(NodePointer Node, Node::Kind NewKind);
 

lib/Demangling/Demangler.cpp

@@ -234,14 +234,10 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName) {
 
   // If any other prefixes are accepted, please update Mangler::verify.
 
-  NodePointer topLevel = createNode(Node::Kind::Global);
-
-  parseAndPushNodes();
-
-  // Let a trailing '_' be part of the not demangled suffix.
-  popNode(Node::Kind::FirstElementMarker);
+  if (!parseAndPushNodes())
+    return nullptr;
 
-  size_t EndPos = (NodeStack.empty() ? 0 : NodeStack.back().Pos);
+  NodePointer topLevel = createNode(Node::Kind::Global);
 
   NodePointer Parent = topLevel;
   while (NodePointer FuncAttr = popNode(isFunctionAttr)) {
@@ -250,8 +246,7 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName) {
         FuncAttr->getKind() == Node::Kind::PartialApplyObjCForwarder)
       Parent = FuncAttr;
   }
-  for (const NodeWithPos &NWP : NodeStack) {
-    NodePointer Nd = NWP.Node;
+  for (Node *Nd : NodeStack) {
     switch (Nd->getKind()) {
       case Node::Kind::Type:
         Parent->addChild(Nd->getFirstChild(), *this);
@@ -264,10 +259,6 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName) {
   if (topLevel->getNumChildren() == 0)
     return nullptr;
 
-  if (EndPos < Text.size()) {
-    topLevel->addChild(createNode(Node::Kind::Suffix, Text.substr(EndPos)), *this);
-  }
-
   return topLevel;
 }
 
@@ -282,15 +273,16 @@ NodePointer Demangler::demangleType(StringRef MangledName) {
   return createNode(Node::Kind::Suffix, Text);
 }
 
-void Demangler::parseAndPushNodes() {
+bool Demangler::parseAndPushNodes() {
   int Idx = 0;
-  while (!Text.empty()) {
+  while (Pos < Text.size()) {
     NodePointer Node = demangleOperator();
     if (!Node)
-      break;
+      return false;
     pushNode(Node);
     Idx++;
   }
+  return true;
 }
 
 NodePointer Demangler::addChild(NodePointer Parent, NodePointer Child) {

lib/Demangling/NodeDumper.cpp

@@ -62,8 +62,8 @@ void swift::Demangle::Node::dump() {
 
 void Demangler::dump() {
   for (unsigned Idx = 0; Idx < NodeStack.size(); ++Idx) {
-    fprintf(stderr, "NodeStack[%u] at position %zd:\n", Idx, NodeStack[Idx].Pos);
-    NodeStack[Idx].Node->dump();
+    fprintf(stderr, "NodeStack[%u]:\n", Idx);
+    NodeStack[Idx]->dump();
     fprintf(stderr, "\n");
   }
   fprintf(stderr, "Position = %zd:\n%.*s\n%*s\n", Pos,

lib/SILOptimizer/Utils/SpecializationMangler.cpp

@@ -19,16 +19,37 @@ using namespace swift;
 using namespace Mangle;
 
 void SpecializationMangler::beginMangling() {
-  ASTMangler::beginMangling();
+  ASTMangler::beginManglingWithoutPrefix();
   if (Serialized)
     ArgOpBuffer << 'q';
   ArgOpBuffer << char(uint8_t(Pass) + '0');
 }
 
+namespace {
+
+/// Utility class for demangling specialization attributes.
+class AttributeDemangler : public Demangle::Demangler {
+public:
+  void demangleAndAddAsChildren(StringRef MangledSpecialization,
+                                NodePointer Parent) {
+    init(MangledSpecialization);
+    if (!parseAndPushNodes()) {
+      llvm::errs() << "Can't demangle: " << MangledSpecialization << '\n';
+      abort();
+    }
+    for (Node *Nd : NodeStack) {
+      addChild(Parent, Nd);
+    }
+  }
+};
+
+} // namespace
+
 std::string SpecializationMangler::finalize() {
   StringRef MangledSpecialization(Storage.data(), Storage.size());
-  Demangle::Demangler D;
-  NodePointer TopLevel = D.demangleSymbol(MangledSpecialization);
+  AttributeDemangler D;
+  NodePointer TopLevel = D.createNode(Node::Kind::Global);
+  D.demangleAndAddAsChildren(MangledSpecialization, TopLevel);
 
   StringRef FuncName = Function->getName();
   NodePointer FuncTopLevel = nullptr;
@@ -41,8 +62,6 @@ std::string SpecializationMangler::finalize() {
     FuncTopLevel->addChild(D.createNode(Node::Kind::Identifier, FuncName), D);
   }
   for (NodePointer FuncChild : *FuncTopLevel) {
-    assert(FuncChild->getKind() != Node::Kind::Suffix ||
-           FuncChild->getText() == "merged");
     TopLevel->addChild(FuncChild, D);
   }
   std::string mangledName = Demangle::mangleNode(TopLevel);