Stop passing NodePointer by reference

(cherry picked from commit 2c01516)

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -60,10 +60,10 @@ class ASTBuilder {
 
   GenericTypeDecl *createTypeDecl(StringRef mangledName, bool &typeAlias);
 
-  GenericTypeDecl *createTypeDecl(const Demangle::NodePointer &node,
+  GenericTypeDecl *createTypeDecl(NodePointer node,
                                   bool &typeAlias);
 
-  ProtocolDecl *createProtocolDecl(const Demangle::NodePointer &node);
+  ProtocolDecl *createProtocolDecl(NodePointer node);
 
   Type createNominalType(GenericTypeDecl *decl);
 
@@ -138,18 +138,18 @@ class ASTBuilder {
   bool validateParentType(TypeDecl *decl, Type parent);
   CanGenericSignature demangleGenericSignature(
       NominalTypeDecl *nominalDecl,
-      const Demangle::NodePointer &node);
-  DeclContext *findDeclContext(const Demangle::NodePointer &node);
-  ModuleDecl *findModule(const Demangle::NodePointer &node);
-  Demangle::NodePointer findModuleNode(const Demangle::NodePointer &node);
+      NodePointer node);
+  DeclContext *findDeclContext(NodePointer node);
+  ModuleDecl *findModule(NodePointer node);
+  Demangle::NodePointer findModuleNode(NodePointer node);
 
   enum class ForeignModuleKind {
     Imported,
     SynthesizedByImporter
   };
 
   Optional<ForeignModuleKind>
-  getForeignModuleKind(const Demangle::NodePointer &node);
+  getForeignModuleKind(NodePointer node);
 
   GenericTypeDecl *findTypeDecl(DeclContext *dc,
                                 Identifier name,

include/swift/Demangling/Demangle.h

@@ -473,7 +473,7 @@ void mangleIdentifier(const char *data, size_t length,
 /// Remangle a demangled parse tree.
 ///
 /// This should always round-trip perfectly with demangleSymbolAsNode.
-std::string mangleNode(const NodePointer &root);
+std::string mangleNode(NodePointer root);
 
 using SymbolicResolver =
   llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
@@ -483,13 +483,13 @@ using SymbolicResolver =
 /// symbolic references.
 ///
 /// This should always round-trip perfectly with demangleSymbolAsNode.
-std::string mangleNode(const NodePointer &root, SymbolicResolver resolver);
+std::string mangleNode(NodePointer root, SymbolicResolver resolver);
 
 /// Remangle in the old mangling scheme.
 ///
 /// This is only used for objc-runtime names and should be removed as soon as
 /// we switch to the new mangling for those names as well.
-std::string mangleNodeOld(const NodePointer &root);
+std::string mangleNodeOld(NodePointer root);
 
 /// Transform the node structure to a string.
 ///

include/swift/Demangling/TypeDecoder.h

@@ -223,7 +223,7 @@ class ImplFunctionTypeFlags {
 /// For a mangled node that refers to an Objective-C class or protocol,
 /// return the class or protocol name.
 static inline Optional<StringRef> getObjCClassOrProtocolName(
-    const Demangle::NodePointer &node) {
+    NodePointer node) {
   if (node->getKind() != Demangle::Node::Kind::Class &&
       node->getKind() != Demangle::Node::Kind::Protocol)
     return None;
@@ -262,7 +262,7 @@ class TypeDecoder {
     : Builder(Builder) {}
 
   /// Given a demangle tree, attempt to turn it into a type.
-  BuiltType decodeMangledType(const Demangle::NodePointer &Node) {
+  BuiltType decodeMangledType(NodePointer Node) {
     if (!Node) return BuiltType();
 
     using NodeKind = Demangle::Node::Kind;
@@ -922,7 +922,7 @@ class TypeDecoder {
       return true;
     };
 
-    auto decodeParam = [&](const Demangle::NodePointer &paramNode)
+    auto decodeParam = [&](NodePointer paramNode)
         -> Optional<FunctionParam<BuiltType>> {
       if (paramNode->getKind() != NodeKind::TupleElement)
         return None;
@@ -979,7 +979,7 @@ class TypeDecoder {
 template<typename BuilderType>
 inline typename BuilderType::BuiltType
 decodeMangledType(BuilderType &Builder,
-                  const Demangle::NodePointer &Node) {
+                  NodePointer Node) {
   return TypeDecoder<BuilderType>(Builder).decodeMangledType(Node);
 }
 

include/swift/Reflection/TypeRefBuilder.h

@@ -29,8 +29,6 @@
 #include <vector>
 #include <unordered_map>
 
-class NodePointer;
-
 namespace swift {
 namespace reflection {
 
@@ -211,12 +209,12 @@ class TypeRefBuilder {
   }
 
   Optional<std::string>
-  createTypeDecl(const Demangle::NodePointer &node, bool &typeAlias) {
+  createTypeDecl(Node *node, bool &typeAlias) {
     return Demangle::mangleNode(node);
   }
 
   BuiltProtocolDecl
-  createProtocolDecl(const Demangle::NodePointer &node) {
+  createProtocolDecl(Node *node) {
     return std::make_pair(Demangle::mangleNode(node), false);
   }
 
@@ -460,7 +458,7 @@ class TypeRefBuilder {
     Dem.setSymbolicReferenceResolver(
     [this, &reader](SymbolicReferenceKind kind,
                     Directness directness,
-                    int32_t offset, const void *base) -> Demangle::NodePointer {
+                    int32_t offset, const void *base) -> Demangle::Node * {
       // Resolve the reference to a remote address.
       auto remoteAddress = getRemoteAddrOfTypeRefPointer(base);
       if (remoteAddress == 0)

include/swift/Remote/MetadataReader.h

@@ -255,7 +255,7 @@ class MetadataReader {
   }
 
   /// Given a demangle tree, attempt to turn it into a type.
-  BuiltType decodeMangledType(const Demangle::NodePointer &Node) {
+  BuiltType decodeMangledType(NodePointer Node) {
     return swift::Demangle::decodeMangledType(Builder, Node);
   }
 

lib/AST/ASTDemangler.cpp

@@ -77,7 +77,7 @@ GenericTypeDecl *ASTBuilder::createTypeDecl(StringRef mangledName,
 }
 
 ProtocolDecl *
-ASTBuilder::createProtocolDecl(const Demangle::NodePointer &node) {
+ASTBuilder::createProtocolDecl(NodePointer node) {
   bool typeAlias;
   return dyn_cast_or_null<ProtocolDecl>(
     createTypeDecl(node, typeAlias));
@@ -645,7 +645,7 @@ DeclContext *ASTBuilder::getNotionalDC() {
 }
 
 GenericTypeDecl *
-ASTBuilder::createTypeDecl(const Demangle::NodePointer &node,
+ASTBuilder::createTypeDecl(NodePointer node,
                            bool &typeAlias) {
   auto DC = findDeclContext(node);
   if (!DC)
@@ -656,14 +656,14 @@ ASTBuilder::createTypeDecl(const Demangle::NodePointer &node,
 }
 
 ModuleDecl *
-ASTBuilder::findModule(const Demangle::NodePointer &node) {
+ASTBuilder::findModule(NodePointer node) {
   assert(node->getKind() == Demangle::Node::Kind::Module);
   const auto &moduleName = node->getText();
   return Ctx.getModuleByName(moduleName);
 }
 
 Demangle::NodePointer
-ASTBuilder::findModuleNode(const Demangle::NodePointer &node) {
+ASTBuilder::findModuleNode(NodePointer node) {
   auto child = node;
   while (child->hasChildren() &&
          child->getKind() != Demangle::Node::Kind::Module) {
@@ -677,7 +677,7 @@ ASTBuilder::findModuleNode(const Demangle::NodePointer &node) {
 }
 
 Optional<ASTBuilder::ForeignModuleKind>
-ASTBuilder::getForeignModuleKind(const Demangle::NodePointer &node) {
+ASTBuilder::getForeignModuleKind(NodePointer node) {
   if (node->getKind() == Demangle::Node::Kind::DeclContext)
     return getForeignModuleKind(node->getFirstChild());
 
@@ -693,7 +693,7 @@ ASTBuilder::getForeignModuleKind(const Demangle::NodePointer &node) {
 
 CanGenericSignature ASTBuilder::demangleGenericSignature(
     NominalTypeDecl *nominalDecl,
-    const Demangle::NodePointer &node) {
+    NodePointer node) {
   GenericSignatureBuilder builder(Ctx);
   builder.addGenericSignature(nominalDecl->getGenericSignature());
 
@@ -768,7 +768,7 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
 }
 
 DeclContext *
-ASTBuilder::findDeclContext(const Demangle::NodePointer &node) {
+ASTBuilder::findDeclContext(NodePointer node) {
   switch (node->getKind()) {
   case Demangle::Node::Kind::DeclContext:
   case Demangle::Node::Kind::Type:

lib/Demangling/NodePrinter.cpp

@@ -212,7 +212,7 @@ class NodePrinter {
   NodePointer getFirstChildOfKind(NodePointer Node, Node::Kind kind) {
     if (!Node)
       return nullptr;
-    for (NodePointer &child : *Node) {
+    for (NodePointer child : *Node) {
       if (child && child->getKind() == kind)
         return child;
     }

lib/Demangling/OldRemangler.cpp

@@ -2277,7 +2277,7 @@ void Remangler::mangleSugaredParen(Node *node) {
 }
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNodeOld(const NodePointer &node) {
+std::string Demangle::mangleNodeOld(NodePointer node) {
   if (!node) return "";
 
   DemanglerPrinter printer;

lib/Demangling/Remangler.cpp

@@ -2331,15 +2331,15 @@ void Remangler::mangleSugaredParen(Node *node) {
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNode(const NodePointer &node) {
+std::string Demangle::mangleNode(NodePointer node) {
   return mangleNode(node, [](SymbolicReferenceKind, const void *) -> NodePointer {
     unreachable("should not try to mangle a symbolic reference; "
                 "resolve it to a non-symbolic demangling tree instead");
   });
 }
 
 std::string
-Demangle::mangleNode(const NodePointer &node, SymbolicResolver resolver) {
+Demangle::mangleNode(NodePointer node, SymbolicResolver resolver) {
   if (!node) return "";
 
   DemanglerPrinter printer;

stdlib/public/runtime/MetadataLookup.cpp

@@ -693,7 +693,7 @@ void swift::swift_registerProtocols(const ProtocolRecord *begin,
 
 static const ProtocolDescriptor *
 _searchProtocolRecords(ProtocolMetadataPrivateState &C,
-                       const Demangle::NodePointer &node) {
+                       NodePointer node) {
   for (auto &section : C.SectionsToScan.snapshot()) {
     for (const auto &record : section) {
       if (auto protocol = record.Protocol.getPointer()) {
@@ -707,7 +707,7 @@ _searchProtocolRecords(ProtocolMetadataPrivateState &C,
 }
 
 static const ProtocolDescriptor *
-_findProtocolDescriptor(const Demangle::NodePointer &node,
+_findProtocolDescriptor(NodePointer node,
                         Demangle::Demangler &Dem,
                         std::string &mangledName) {
   const ProtocolDescriptor *foundProtocol = nullptr;
@@ -944,14 +944,14 @@ class DecodedMetadataBuilder {
 
   Demangle::NodeFactory &getNodeFactory() { return demangler; }
 
-  BuiltTypeDecl createTypeDecl(const Demangle::NodePointer &node,
+  BuiltTypeDecl createTypeDecl(NodePointer node,
                                bool &typeAlias) const {
     // Look for a nominal type descriptor based on its mangled name.
     return _findNominalTypeDescriptor(node, demangler);
   }
 
   BuiltProtocolDecl createProtocolDecl(
-                                    const Demangle::NodePointer &node) const {
+                                    NodePointer node) const {
     // Look for a protocol descriptor based on its mangled name.
     std::string mangledName;
     if (auto protocol = _findProtocolDescriptor(node, demangler, mangledName))