Revert #26937, #27190, and #27132

include/swift/Parse/HiddenLibSyntaxAction.h

@@ -70,8 +70,6 @@ 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/LibSyntaxGenerator.h

@@ -44,7 +44,7 @@ class LibSyntaxGenerator {
 
     auto Recorded = Recorder.recordToken(Kind, Range, LeadingTriviaPieces,
                                          TrailingTriviaPieces);
-    auto Raw = static_cast<RawSyntax *>(Recorded.takeOpaqueNode());
+    auto Raw = static_cast<RawSyntax *>(Recorded.getOpaqueNode());
     return make<TokenSyntax>(Raw);
   }
 
@@ -55,7 +55,7 @@ class LibSyntaxGenerator {
     auto Children = Node.getDeferredChildren();
 
     auto Recorded = Recorder.recordRawSyntax(Kind, Children);
-    RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.takeOpaqueNode()) };
+    RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.getOpaqueNode()) };
     Raw->Release(); // -1 since it's transfer of ownership.
     return make<SyntaxNode>(Raw);
   }

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -51,7 +51,7 @@ class ParsedRawSyntaxNode {
     CharSourceRange Range;
   };
   struct DeferredLayoutNode {
-    MutableArrayRef<ParsedRawSyntaxNode> Children;
+    ArrayRef<ParsedRawSyntaxNode> Children;
   };
   struct DeferredTokenNode {
     const ParsedTriviaPiece *TriviaPieces;
@@ -73,8 +73,8 @@ class ParsedRawSyntaxNode {
   bool IsMissing = false;
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k,
-                      MutableArrayRef<ParsedRawSyntaxNode> deferredNodes)
-    : DeferredLayout({deferredNodes}),
+                      ArrayRef<ParsedRawSyntaxNode> deferredNodes)
+    : DeferredLayout{deferredNodes},
       SynKind(uint16_t(k)), TokKind(uint16_t(tok::unknown)),
       DK(DataKind::DeferredLayout) {
     assert(getKind() == k && "Syntax kind with too large value!");
@@ -97,8 +97,6 @@ class ParsedRawSyntaxNode {
     assert(DeferredToken.NumTrailingTrivia == numTrailingTrivia &&
            "numLeadingTrivia is too large value!");
   }
-  ParsedRawSyntaxNode(ParsedRawSyntaxNode &other) = delete;
-  ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &other) = delete;
 
 public:
   ParsedRawSyntaxNode()
@@ -117,35 +115,6 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
 
-  ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
-    assert(DK != DataKind::Recorded);
-    switch (other.DK) {
-    case DataKind::Null:
-      break;
-    case DataKind::Recorded:
-      RecordedData = std::move(other.RecordedData);
-      break;
-    case DataKind::DeferredLayout:
-      DeferredLayout = std::move(other.DeferredLayout);
-      break;
-    case DataKind::DeferredToken:
-      DeferredToken = std::move(other.DeferredToken);
-      break;
-    }
-    SynKind = std::move(other.SynKind);
-    TokKind = std::move(other.TokKind);
-    DK = std::move(other.DK);
-    IsMissing = std::move(other.IsMissing);
-    other.reset();
-    return *this;
-  }
-  ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) : ParsedRawSyntaxNode() {
-    *this = std::move(other);
-  }
-  ~ParsedRawSyntaxNode() {
-    assert(DK != DataKind::Recorded);
-  }
-
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }
   tok getTokenKind() const { return tok(TokKind); }
 
@@ -167,36 +136,6 @@ class ParsedRawSyntaxNode {
   /// Primary used for a deferred missing token.
   bool isMissing() const { return IsMissing; }
 
-  void reset() {
-    RecordedData = {};
-    SynKind = uint16_t(syntax::SyntaxKind::Unknown);
-    TokKind = uint16_t(tok::unknown);
-    DK = DataKind::Null;
-    IsMissing = false;
- }
-
-  ParsedRawSyntaxNode unsafeCopy() const {
-    ParsedRawSyntaxNode copy;
-    switch (DK) {
-    case DataKind::DeferredLayout:
-      copy.DeferredLayout = DeferredLayout;
-      break;
-    case DataKind::DeferredToken:
-      copy.DeferredToken = DeferredToken;
-      break;
-    case DataKind::Recorded:
-      copy.RecordedData = RecordedData;
-      break;
-    case DataKind::Null:
-      break;
-    }
-    copy.SynKind = SynKind;
-    copy.TokKind = TokKind;
-    copy.DK = DK;
-    copy.IsMissing = IsMissing;
-    return copy;
-  }
-
   CharSourceRange getDeferredRange() const {
     switch (DK) { 
     case DataKind::DeferredLayout:
@@ -214,24 +153,18 @@ class ParsedRawSyntaxNode {
     assert(isRecorded());
     return RecordedData.Range;
   }
-  const OpaqueSyntaxNode &getOpaqueNode() const {
+  OpaqueSyntaxNode getOpaqueNode() const {
     assert(isRecorded());
     return RecordedData.OpaqueNode;
   }
-  OpaqueSyntaxNode takeOpaqueNode() {
-    assert(isRecorded());
-    auto opaque = RecordedData.OpaqueNode;
-    reset();
-    return opaque;
-  }
 
   // Deferred Layout Data ====================================================//
 
   CharSourceRange getDeferredLayoutRange() const {
     assert(DK == DataKind::DeferredLayout);
     assert(!DeferredLayout.Children.empty());
-    auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
-      for (auto &Child : llvm::reverse(getDeferredChildren()))
+    auto getLastNonNullChild = [this]() {
+      for (auto &&Child : llvm::reverse(getDeferredChildren()))
         if (!Child.isNull())
           return Child;
       llvm_unreachable("layout node without non-null children");
@@ -245,28 +178,6 @@ class ParsedRawSyntaxNode {
     assert(DK == DataKind::DeferredLayout);
     return DeferredLayout.Children;
   }
-  MutableArrayRef<ParsedRawSyntaxNode> getDeferredChildren() {
-    assert(DK == DataKind::DeferredLayout);
-    return DeferredLayout.Children;
-  }
-  ParsedRawSyntaxNode copyDeferred() const {
-    ParsedRawSyntaxNode copy;
-    switch (DK) {
-    case DataKind::DeferredLayout:
-      copy.DeferredLayout = DeferredLayout;
-      break;
-    case DataKind::DeferredToken:
-      copy.DeferredToken = DeferredToken;
-      break;
-    default:
-      llvm_unreachable("node not deferred");
-    }
-    copy.SynKind = SynKind;
-    copy.TokKind = TokKind;
-    copy.DK = DK;
-    copy.IsMissing = IsMissing;
-    return copy;
-  }
 
   // Deferred Token Data =====================================================//
 
@@ -303,7 +214,7 @@ class ParsedRawSyntaxNode {
 
   /// Form a deferred syntax layout node.
   static ParsedRawSyntaxNode makeDeferred(syntax::SyntaxKind k,
-                        MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
+                        ArrayRef<ParsedRawSyntaxNode> deferredNodes,
                                           SyntaxParsingContext &ctx);
 
   /// Form a deferred token node.

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -60,16 +60,14 @@ class ParsedRawSyntaxRecorder {
   /// \p kind. Missing optional elements are represented with a null
   /// ParsedRawSyntaxNode object.
   ParsedRawSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
-                                      MutableArrayRef<ParsedRawSyntaxNode> elements);
+                                     ArrayRef<ParsedRawSyntaxNode> elements);
 
   /// Record a raw syntax collecton without eny elements. \p loc can be invalid
   /// or an approximate location of where an element of the collection would be
   /// if not missing.
   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/ParsedSyntax.h

@@ -26,7 +26,6 @@ class ParsedSyntax {
     : RawNode(std::move(rawNode)) {}
 
   const ParsedRawSyntaxNode &getRaw() const { return RawNode; }
-  ParsedRawSyntaxNode takeRaw() { return std::move(RawNode); }
   syntax::SyntaxKind getKind() const { return RawNode.getKind(); }
 
   /// Returns true if the syntax node is of the given type.
@@ -40,7 +39,7 @@ class ParsedSyntax {
   template <typename T>
   T castTo() const {
     assert(is<T>() && "castTo<T>() node of incompatible type!");
-    return T { RawNode.copyDeferred() };
+    return T { RawNode };
   }
 
   /// If this Syntax node is of the right kind, cast and return it,
@@ -53,10 +52,6 @@ class ParsedSyntax {
     return llvm::None;
   }
 
-  ParsedSyntax copyDeferred() const {
-    return ParsedSyntax { RawNode.copyDeferred() };
-  }
-
   static bool kindof(syntax::SyntaxKind Kind) {
     return true;
   }
@@ -70,7 +65,7 @@ class ParsedSyntax {
 class ParsedTokenSyntax final : public ParsedSyntax {
 public:
   explicit ParsedTokenSyntax(ParsedRawSyntaxNode rawNode)
-    : ParsedSyntax(std::move(rawNode)) {}
+    : ParsedSyntax(rawNode) {}
 
   tok getTokenKind() const {
     return getRaw().getTokenKind();

include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -53,32 +53,32 @@ public:
 %   elif node.is_syntax_collection():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      ArrayRef<Parsed${node.collection_element_type}> elts,
       ParsedRawSyntaxRecorder &rec);
 
 public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      ArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);
   static Parsed${node.name} make${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      ArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);
 
   static Parsed${node.name} makeBlank${node.syntax_kind}(SourceLoc loc,
       SyntaxParsingContext &SPCtx);
 %   elif node.is_unknown():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<ParsedSyntax> elts,
+      ArrayRef<ParsedSyntax> elts,
       ParsedRawSyntaxRecorder &rec);
 
 public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<ParsedSyntax> elts,
+      ArrayRef<ParsedSyntax> elts,
       SyntaxParsingContext &SPCtx);
 
   static Parsed${node.name} make${node.syntax_kind}(
-      MutableArrayRef<ParsedSyntax> elts,
+      ArrayRef<ParsedSyntax> elts,
       SyntaxParsingContext &SPCtx);
 %   end
 % end
@@ -95,21 +95,18 @@ public:
   /// optional trailing comma.
   static ParsedTupleTypeElementSyntax
   makeTupleTypeElement(ParsedTypeSyntax Type,
-                       Optional<ParsedTokenSyntax> TrailingComma,
-                       SyntaxParsingContext &SPCtx);
+                         Optional<ParsedTokenSyntax> TrailingComma,
+                         SyntaxParsingContext &SPCtx);
 
   /// The provided \c elements are in the appropriate order for the syntax
   /// \c kind's layout but optional elements are not be included.
   /// This function will form the exact layout based on the provided elements,
   /// substituting missing parts with a null ParsedRawSyntaxNode object.
   ///
   /// \returns true if the layout could be formed, false otherwise.
-  static bool
-  formExactLayoutFor(syntax::SyntaxKind kind,
-                     MutableArrayRef<ParsedRawSyntaxNode> elements,
-                     function_ref<void(syntax::SyntaxKind,
-                                       MutableArrayRef<ParsedRawSyntaxNode>)>
-                         receiver);
+  static bool formExactLayoutFor(syntax::SyntaxKind kind,
+                                 ArrayRef<ParsedRawSyntaxNode> elements,
+         function_ref<void(syntax::SyntaxKind, ArrayRef<ParsedRawSyntaxNode>)> receiver);
 };
 }
 

include/swift/Parse/SyntaxParseActions.h

@@ -61,13 +61,6 @@ 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) {