[SyntaxParse] Return dedicated pointer from HiddenLibSyntaxAction

SyntaxParseActions::recordToken() et al. may return the same pointer
value for different nodes (e.g. `nullptr`). So we cannot use DenseMap to
associate the node from the explicit syntax parsing actions to libSyntax
node. Instead, use a structure that wraps them.

Author: rintaro

include/swift/Parse/HiddenLibSyntaxAction.h

@@ -15,23 +15,40 @@
 
 #include "swift/Parse/SyntaxParseActions.h"
 #include "swift/SyntaxParse/SyntaxTreeCreator.h"
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Allocator.h"
 
 namespace swift {
+namespace syntax {
+class RawSyntax;
+}
+
 /// Holds an explicitly provided action and uses it to handle all function
 /// calls. Also hides an implicit SyntaxTreeCreator and ensures libSyntax nodes
 /// are always created. Provides an interface to map results of the explicitly
 /// provided action to the hidden libSyntax action.
 // todo [gsoc]: remove when possible
 class HiddenLibSyntaxAction : public SyntaxParseActions {
+
+  struct Node {
+    OpaqueSyntaxNode ExplicitActionNode;
+    OpaqueSyntaxNode LibSyntaxNode;
+
+    Node(OpaqueSyntaxNode ExplicitActionNode, OpaqueSyntaxNode LibSyntaxNode)
+        : ExplicitActionNode(ExplicitActionNode), LibSyntaxNode(LibSyntaxNode) {
+    }
+  };
+
   std::shared_ptr<SyntaxParseActions> ExplicitAction;
   std::shared_ptr<SyntaxTreeCreator> LibSyntaxAction;
-  llvm::DenseMap<OpaqueSyntaxNode, OpaqueSyntaxNode> OpaqueNodeMap;
+  llvm::SpecificBumpPtrAllocator<Node> NodeAllocator;
 
   bool areBothLibSyntax() {
     return ExplicitAction->getOpaqueKind() == OpaqueSyntaxNodeKind::LibSyntax;
   }
 
+  OpaqueSyntaxNode makeHiddenNode(OpaqueSyntaxNode explicitActionNode,
+                                  OpaqueSyntaxNode libSyntaxNode);
+
 public:
   HiddenLibSyntaxAction(
       const std::shared_ptr<SyntaxParseActions> &SPActions,
@@ -57,14 +74,18 @@ class HiddenLibSyntaxAction : public SyntaxParseActions {
     return ExplicitAction->getOpaqueKind();
   }
 
-  /// Returns the libSyntax node corresponding to the provided node that has
-  /// been created by the explicit action.
-  OpaqueSyntaxNode getLibSyntaxNodeFor(OpaqueSyntaxNode explicitNode);
+  /// Returns the libSyntax node from the specified node that has been created
+  /// by this action.
+  syntax::RawSyntax *getLibSyntaxNodeFor(OpaqueSyntaxNode node);
+
+  /// Returns the node created by explicit syntax action from the specified
+  /// node that has been created by this action.
+  OpaqueSyntaxNode getExplicitNodeFor(OpaqueSyntaxNode node);
 
   bool isReleaseNeeded() {
     return ExplicitAction == LibSyntaxAction || !areBothLibSyntax();
   }
-  
+
   /// Returns the underlying libSyntax SyntaxTreeCreator.
   std::shared_ptr<SyntaxTreeCreator> getLibSyntaxAction() {
     return LibSyntaxAction;

include/swift/Parse/LibSyntaxGenerator.h

@@ -66,15 +66,13 @@ class LibSyntaxGenerator {
 
   template <typename SyntaxNode>
   SyntaxNode getLibSyntaxNodeFor(OpaqueSyntaxNode Node) {
-    auto Raw = static_cast<RawSyntax *>(Actions->getLibSyntaxNodeFor(Node));
-    return make<SyntaxNode>(Raw);
+    return make<SyntaxNode>(Actions->getLibSyntaxNodeFor(Node));
   }
 
-  void releaseLibSyntaxNodeIfNeededFor(OpaqueSyntaxNode Node) {
-    if (!Actions->isReleaseNeeded())
-      return;
-    auto Raw = static_cast<RawSyntax *>(Actions->getLibSyntaxNodeFor(Node));
-    Raw->Release();
+  OpaqueSyntaxNode finalizeNode(OpaqueSyntaxNode Node) {
+    if (Actions->isReleaseNeeded())
+      Actions->getLibSyntaxNodeFor(Node)->Release();
+    return Actions->getExplicitNodeFor(Node);
   }
 };
 } // namespace swift

include/swift/Parse/Parser.h

@@ -402,7 +402,7 @@ class Parser {
 
   /// Calling this function to finalize libSyntax tree creation without destroying
   /// the parser instance.
-  ParsedRawSyntaxNode finalizeSyntaxTree() {
+  OpaqueSyntaxNode finalizeSyntaxTree() {
     assert(Tok.is(tok::eof) && "not done parsing yet");
     return SyntaxContext->finalizeRoot();
   }

include/swift/Parse/SyntaxParsingContext.h

@@ -350,7 +350,7 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
   /// This function will be called during the destroying of a root syntax
   /// parsing context. However, we can explicitly call this function to get
   /// the syntax tree before closing the root context.
-  ParsedRawSyntaxNode finalizeRoot();
+  OpaqueSyntaxNode finalizeRoot();
 
   /// Make a missing node corresponding to the given token kind and
   /// push this node into the context. The synthesized node can help

lib/Parse/HiddenLibSyntaxAction.cpp

@@ -28,65 +28,100 @@ using namespace swift;
 using namespace swift::syntax;
 using namespace llvm;
 
+OpaqueSyntaxNode
+HiddenLibSyntaxAction::makeHiddenNode(OpaqueSyntaxNode explicitActionNode,
+                                      OpaqueSyntaxNode libSyntaxNode) {
+  auto dat = NodeAllocator.Allocate();
+  return new (dat) Node(explicitActionNode, libSyntaxNode);
+}
+
 OpaqueSyntaxNode HiddenLibSyntaxAction::recordToken(
     tok tokenKind, ArrayRef<ParsedTriviaPiece> leadingTrivia,
     ArrayRef<ParsedTriviaPiece> trailingTrivia, CharSourceRange range) {
   OpaqueSyntaxNode primaryNode = ExplicitAction->recordToken(
       tokenKind, leadingTrivia, trailingTrivia, range);
+  OpaqueSyntaxNode secondaryNode = nullptr;
 
-  if (!areBothLibSyntax()) {
-    OpaqueSyntaxNode secondaryNode = LibSyntaxAction->recordToken(
-        tokenKind, leadingTrivia, trailingTrivia, range);
-    OpaqueNodeMap[primaryNode] = secondaryNode;
+  if (areBothLibSyntax()) {
+    secondaryNode = primaryNode;
+  } else {
+    secondaryNode = LibSyntaxAction->recordToken(tokenKind, leadingTrivia,
+                                                 trailingTrivia, range);
   }
 
-  return primaryNode;
+  return makeHiddenNode(primaryNode, secondaryNode);
 }
 
 OpaqueSyntaxNode HiddenLibSyntaxAction::recordMissingToken(tok tokenKind,
                                                            SourceLoc loc) {
   OpaqueSyntaxNode primaryNode =
       ExplicitAction->recordMissingToken(tokenKind, loc);
+  OpaqueSyntaxNode secondaryNode = nullptr;
 
-  if (!areBothLibSyntax()) {
-    OpaqueSyntaxNode secondaryNode =
-        LibSyntaxAction->recordMissingToken(tokenKind, loc);
-    OpaqueNodeMap[primaryNode] = secondaryNode;
+  if (areBothLibSyntax()) {
+    secondaryNode = primaryNode;
+  } else {
+    secondaryNode = LibSyntaxAction->recordMissingToken(tokenKind, loc);
   }
 
-  return primaryNode;
+  return makeHiddenNode(primaryNode, secondaryNode);
 }
 
 OpaqueSyntaxNode
 HiddenLibSyntaxAction::recordRawSyntax(syntax::SyntaxKind kind,
                                        ArrayRef<OpaqueSyntaxNode> elements,
                                        CharSourceRange range) {
-  OpaqueSyntaxNode primaryNode =
-      ExplicitAction->recordRawSyntax(kind, elements, range);
+  OpaqueSyntaxNode primaryNode = nullptr;
+  OpaqueSyntaxNode secondaryNode = nullptr;
+
+  {
+    SmallVector<OpaqueSyntaxNode, 4> primaryElements;
+    primaryElements.reserve(elements.size());
+    for (auto element : elements) {
+      OpaqueSyntaxNode primaryElement = nullptr;
+      if (element)
+        primaryElement = ((Node *)element)->ExplicitActionNode;
+      primaryElements.push_back(primaryElement);
+    }
 
-  if (!areBothLibSyntax()) {
+    primaryNode = ExplicitAction->recordRawSyntax(kind, primaryElements, range);
+  }
+
+  if (areBothLibSyntax()) {
+    secondaryNode = primaryNode;
+  } else {
     SmallVector<OpaqueSyntaxNode, 4> secondaryElements;
     secondaryElements.reserve(elements.size());
-    for (auto &&element : elements) {
-      secondaryElements.push_back(OpaqueNodeMap[element]);
+    for (auto element : elements) {
+      OpaqueSyntaxNode secondaryElement = nullptr;
+      if (element)
+        secondaryElement = ((Node *)element)->LibSyntaxNode;
+      secondaryElements.push_back(secondaryElement);
     }
-    OpaqueSyntaxNode secondaryNode =
+    secondaryNode =
         LibSyntaxAction->recordRawSyntax(kind, secondaryElements, range);
-    OpaqueNodeMap[primaryNode] = secondaryNode;
   }
 
-  return primaryNode;
+  return makeHiddenNode(primaryNode, secondaryNode);
 }
 
 std::pair<size_t, OpaqueSyntaxNode>
 HiddenLibSyntaxAction::lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) {
-  return ExplicitAction->lookupNode(lexerOffset, kind);
+  size_t length;
+  OpaqueSyntaxNode n;
+  std::tie(length, n) = ExplicitAction->lookupNode(lexerOffset, kind);
+  if (length == 0)
+    return {0, nullptr};
+  return {length, makeHiddenNode(n, nullptr)};
 }
 
-OpaqueSyntaxNode
-HiddenLibSyntaxAction::getLibSyntaxNodeFor(OpaqueSyntaxNode explicitNode) {
-  if (!areBothLibSyntax())
-    return OpaqueNodeMap[explicitNode];
+RawSyntax *HiddenLibSyntaxAction::getLibSyntaxNodeFor(OpaqueSyntaxNode node) {
+  auto hiddenNode = (Node *)node;
+  return (RawSyntax *)hiddenNode->LibSyntaxNode;
+}
 
-  return explicitNode;
+OpaqueSyntaxNode
+HiddenLibSyntaxAction::getExplicitNodeFor(OpaqueSyntaxNode node) {
+  auto hiddenNode = (Node *)node;
+  return hiddenNode->ExplicitActionNode;
 }

lib/Parse/Parser.cpp

@@ -1212,11 +1212,7 @@ OpaqueSyntaxNode ParserUnit::parse() {
     P.parseTopLevel();
     Done = P.Tok.is(tok::eof);
   }
-  auto rawNode = P.finalizeSyntaxTree();
-  if (rawNode.isNull()) {
-    return nullptr;
-  }
-  return rawNode.getOpaqueNode();
+  return P.finalizeSyntaxTree();
 }
 
 Parser &ParserUnit::getParser() {

lib/Parse/SyntaxParsingContext.cpp

@@ -272,21 +272,21 @@ ParsedRawSyntaxNode SyntaxParsingContext::finalizeSourceFile() {
                                   { itemList, EOFToken });
 }
 
-ParsedRawSyntaxNode SyntaxParsingContext::finalizeRoot() {
+  OpaqueSyntaxNode SyntaxParsingContext::finalizeRoot() {
   assert(isTopOfContextStack() && "some sub-contexts are not destructed");
   assert(isRoot() && "only root context can finalize the tree");
   assert(Mode == AccumulationMode::Root);
   if (getStorage().empty()) {
-    return ParsedRawSyntaxNode::null(); // already finalized.
+    return nullptr; // already finalized.
   }
   ParsedRawSyntaxNode root = finalizeSourceFile();
-  getSyntaxCreator().releaseLibSyntaxNodeIfNeededFor(root.getOpaqueNode());
+  auto opaqueRoot = getSyntaxCreator().finalizeNode(root.getOpaqueNode());
 
   // Clear the parts because we will call this function again when destroying
   // the root context.
   getStorage().clear();
 
-  return root;
+  return opaqueRoot;
 }
 
 void SyntaxParsingContext::synthesize(tok Kind, SourceLoc Loc) {
@@ -356,7 +356,7 @@ SyntaxParsingContext::~SyntaxParsingContext() {
     auto &nodes = getStorage();
     for (auto i = nodes.begin()+Offset, e = nodes.end(); i != e; ++i)
       if (i->isRecorded())
-        getSyntaxCreator().releaseLibSyntaxNodeIfNeededFor(i->getOpaqueNode());
+        getSyntaxCreator().finalizeNode(i->getOpaqueNode());
 
     nodes.erase(nodes.begin()+Offset, nodes.end());
     break;

lib/ParseSIL/ParseSIL.cpp

@@ -165,7 +165,7 @@ static bool parseIntoSourceFileImpl(SourceFile &SF,
 
   if (STreeCreator) {
     auto rawNode = P.finalizeSyntaxTree();
-    STreeCreator->acceptSyntaxRoot(rawNode.getOpaqueNode(), SF);
+    STreeCreator->acceptSyntaxRoot(rawNode, SF);
   }
 
   return FoundSideEffects;