[SyntaxParse] Fix memory leak for explicit syntax actions

Add SyntaxParseActions::discardRecordedNode() as a workaround for memory
leak during syntax parsing migration.

Author: rintaro

include/swift/Parse/HiddenLibSyntaxAction.h

@@ -70,6 +70,8 @@ class HiddenLibSyntaxAction : public SyntaxParseActions {
   std::pair<size_t, OpaqueSyntaxNode>
   lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) override;
 
+  void discardRecordedNode(OpaqueSyntaxNode node) override;
+
   OpaqueSyntaxNodeKind getOpaqueKind() override {
     return ExplicitAction->getOpaqueKind();
   }

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -68,6 +68,8 @@ class ParsedRawSyntaxRecorder {
   ParsedRawSyntaxNode recordEmptyRawSyntaxCollection(syntax::SyntaxKind kind,
                                                      SourceLoc loc);
 
+  void discardRecordedNode(ParsedRawSyntaxNode &node);
+
   /// Used for incremental re-parsing.
   ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
                                  syntax::SyntaxKind kind);

include/swift/Parse/SyntaxParseActions.h

@@ -61,6 +61,13 @@ class SyntaxParseActions {
                                            ArrayRef<OpaqueSyntaxNode> elements,
                                            CharSourceRange range) = 0;
 
+  /// Discard raw syntax node.
+  /// 
+  /// FIXME: This breaks invariant that any recorded node will be a part of the
+  /// result SourceFile syntax. This method is a temporary workaround, and
+  /// should be removed when we fully migrate to libSyntax parsing.
+  virtual void discardRecordedNode(OpaqueSyntaxNode node) = 0;
+
   /// Used for incremental re-parsing.
   virtual std::pair<size_t, OpaqueSyntaxNode>
   lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) {

include/swift/SyntaxParse/SyntaxTreeCreator.h

@@ -64,6 +64,8 @@ class SyntaxTreeCreator: public SyntaxParseActions {
                                    ArrayRef<OpaqueSyntaxNode> elements,
                                    CharSourceRange range) override;
 
+  void discardRecordedNode(OpaqueSyntaxNode node) override;
+
   std::pair<size_t, OpaqueSyntaxNode>
   lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) override;
 

lib/Parse/HiddenLibSyntaxAction.cpp

@@ -125,3 +125,12 @@ HiddenLibSyntaxAction::getExplicitNodeFor(OpaqueSyntaxNode node) {
   auto hiddenNode = (Node *)node;
   return hiddenNode->ExplicitActionNode;
 }
+
+void HiddenLibSyntaxAction::discardRecordedNode(OpaqueSyntaxNode opaqueN) {
+  if (!opaqueN)
+    return;
+  auto node = static_cast<Node *>(opaqueN);
+  if (!areBothLibSyntax())
+    LibSyntaxAction->discardRecordedNode(node->LibSyntaxNode);
+  ExplicitAction->discardRecordedNode(node->ExplicitActionNode);
+}

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -112,6 +112,10 @@ ParsedRawSyntaxRecorder::recordEmptyRawSyntaxCollection(SyntaxKind kind,
   return ParsedRawSyntaxNode{kind, tok::unknown, range, n};
 }
 
+void ParsedRawSyntaxRecorder::discardRecordedNode(ParsedRawSyntaxNode &node) {
+  SPActions->discardRecordedNode(node.takeOpaqueNode());
+}
+
 ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
                                     SyntaxKind kind) {

lib/Parse/SyntaxParsingContext.cpp

@@ -266,7 +266,7 @@ ParsedRawSyntaxNode SyntaxParsingContext::finalizeSourceFile() {
                                   llvm::makeMutableArrayRef(Layout, 2));
 }
 
-  OpaqueSyntaxNode 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);
@@ -349,11 +349,12 @@ SyntaxParsingContext::~SyntaxParsingContext() {
   // Remove all parts in this context.
   case AccumulationMode::Discard: {
     auto &nodes = getStorage();
-    for (auto i = nodes.begin()+Offset, e = nodes.end(); i != e; ++i)
-      if (i->isRecorded()) {
-        getSyntaxCreator().finalizeNode(i->getOpaqueNode());
-        i->reset();
-      }
+    for (auto i = nodes.begin()+Offset, e = nodes.end(); i != e; ++i) {
+      // FIXME: This should not be needed. This breaks invariant that any
+      // recorded node must be a part of result souce syntax tree.
+      if (i->isRecorded())
+        getRecorder().discardRecordedNode(*i);
+    }
     nodes.erase(nodes.begin()+Offset, nodes.end());
     break;
   }

lib/SyntaxParse/SyntaxTreeCreator.cpp

@@ -173,3 +173,9 @@ SyntaxTreeCreator::lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) {
   raw.resetWithoutRelease();
   return {length, opaqueN};
 }
+
+void SyntaxTreeCreator::discardRecordedNode(OpaqueSyntaxNode opaqueN) {
+  if (!opaqueN)
+    return;
+  static_cast<RawSyntax *>(opaqueN)->Release();
+}

tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp

@@ -190,6 +190,10 @@ class CLibParseActions : public SyntaxParseActions {
     return getNodeHandler()(&node);
   }
 
+  void discardRecordedNode(OpaqueSyntaxNode node) override {
+    // FIXME: This method should not be called at all.
+  }
+
   std::pair<size_t, OpaqueSyntaxNode>
   lookupNode(size_t lexerOffset, SyntaxKind kind) override {
     auto NodeLookup = getNodeLookup();