---

yaml
---
r: 327679
b: refs/heads/tensorflow
c: b9985db
h: refs/heads/master
i:
  327677: e7727c5
  327675: e860e8a
  327671: ac00eb7
  327663: abad4b8
  327647: 597a54a
  327615: 51b96a0
  327551: 195f526
  327423: 9239924
  327167: b4ff457
  326655: caf4a22
  325631: 757ef7a
  323583: 598034e
  319487: e9b3cb6
  311295: 881526f
  294911: 1f1cc10
  262143: ddec100

Author: rintaro

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 80085e0d272720348879c7c97373b36c7ba58395
+refs/heads/tensorflow: b9985dbe877160ec901fb0a0b4a495f69041f5aa
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/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();
   }

branches/tensorflow/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);

branches/tensorflow/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) {

branches/tensorflow/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;
 

branches/tensorflow/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);
+}

branches/tensorflow/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) {

branches/tensorflow/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;
   }

branches/tensorflow/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();
+}

branches/tensorflow/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();