[libSyntax] Don't reference count SyntaxData

Instead, reference count the SyntaxData's parent. This has a couple of
advantages:
1. We eliminate a const_cast that was potentially unsafe
2. It more closely resembles the architecture on the Swift side
3. It has the potential to be optimised further if the parent can be
   accessed in an unsafe, non-reference-counted way

Author: ahoppen

include/swift/Syntax/AbsoluteRawSyntax.h

@@ -40,6 +40,10 @@ class SyntaxIndexInTree {
 
   /// Advance this index to point to its first immediate child.
   SyntaxIndexInTree advancedToFirstChild() const;
+
+  bool operator==(SyntaxIndexInTree Other) const {
+    return IndexInTree == Other.IndexInTree;
+  }
 };
 
 /// A syntax identifier that globally identifies a \c Syntax node.
@@ -97,6 +101,10 @@ class SyntaxIdentifier {
     auto NewIndexInTree = IndexInTree.advancedToFirstChild();
     return SyntaxIdentifier(RootId, NewIndexInTree);
   }
+
+  bool operator==(SyntaxIdentifier Other) const {
+    return RootId == Other.RootId && IndexInTree == Other.IndexInTree;
+  }
 };
 
 /// Represents a node's position in a syntax tree, described by its overal
@@ -231,6 +239,18 @@ struct AbsoluteRawSyntax {
   AbsoluteSyntaxPosition::IndexInParentType getIndexInParent() const {
     return getPosition().getIndexInParent();
   }
+
+  /// Construct a new \c AbsoluteRawSyntax node that has the same info as the
+  /// current one, but
+  ///  - the \p NewRaw as the backing storage
+  ///  - the \p NewRootId as the RootId
+  AbsoluteRawSyntax
+  replacingSelf(const RC<RawSyntax> &NewRaw,
+                SyntaxIdentifier::RootIdType NewRootId) const {
+    SyntaxIdentifier NewNodeId(NewRootId, Info.getNodeId().getIndexInTree());
+    AbsoluteSyntaxInfo NewInfo(Info.getPosition(), NewNodeId);
+    return AbsoluteRawSyntax(NewRaw, NewInfo);
+  }
 };
 
 } // end namespace syntax

include/swift/Syntax/Syntax.h

@@ -41,37 +41,24 @@ class SourceFileSyntax;
 
 template <typename SyntaxNode> SyntaxNode makeRoot(RC<RawSyntax> Raw) {
   auto Data = SyntaxData::make(AbsoluteRawSyntax::forRoot(Raw));
-  return { Data, Data.get() };
+  return SyntaxNode(Data);
 }
 
 const auto NoParent = llvm::None;
 
 /// The main handle for syntax nodes - subclasses contain all public
 /// structured editing APIs.
 ///
-/// This opaque structure holds two pieces of data: a strong reference to a
-/// root node and a weak reference to the node itself. The node of interest can
-/// be weakly held because the data nodes contain strong references to
-/// their children.
+/// Essentially, this is a wrapper around \c SyntaxData that provides
+/// convenience methods based on the node's kind.
 class Syntax {
   friend struct SyntaxFactory;
 
 protected:
-  /// A strong reference to the root node of the tree in which this piece of
-  /// syntax resides.
-  const RC<SyntaxData> Root;
-
-  /// A raw pointer to the data representing this syntax node.
-  ///
-  /// This is mutable for being able to set cached child members, which are
-  /// lazily created.
-  mutable const SyntaxData *Data;
+  SyntaxData Data;
 
 public:
-  Syntax(const RC<SyntaxData> Root, const SyntaxData *Data)
-  : Root(Root), Data(Data) {
-    assert(Data != nullptr);
-  }
+  explicit Syntax(const SyntaxData Data) : Data(Data) {}
 
   virtual ~Syntax() {}
 
@@ -99,10 +86,6 @@ class Syntax {
 
   /// Get the Data for this Syntax node.
   const SyntaxData &getData() const {
-    return *Data;
-  }
-
-  const SyntaxData *getDataPointer() const {
     return Data;
   }
 
@@ -111,7 +94,7 @@ class Syntax {
   template <typename T>
   T castTo() const {
     assert(is<T>() && "castTo<T>() node of incompatible type!");
-    return T { Root, Data };
+    return T(Data);
   }
 
   /// If this Syntax node is of the right kind, cast and return it,
@@ -127,9 +110,6 @@ class Syntax {
   /// Return the parent of this node, if it has one.
   llvm::Optional<Syntax> getParent() const;
 
-  /// Return the root syntax of this node.
-  Syntax getRoot() const;
-
   /// Returns the child index of this node in its parent,
   /// if it has one, otherwise 0.
   CursorIndex getIndexInParent() const { return getData().getIndexInParent(); }
@@ -176,7 +156,8 @@ class Syntax {
   SWIFT_DEBUG_DUMP;
 
   bool hasSameIdentityAs(const Syntax &Other) const {
-    return Root == Other.Root && Data == Other.Data;
+    return Data.getAbsoluteRaw().getNodeId() ==
+           Other.Data.getAbsoluteRaw().getNodeId();
   }
 
   static bool kindof(SyntaxKind Kind) {
@@ -198,23 +179,23 @@ class Syntax {
 
   /// Get the offset at which the leading trivia of this node starts.
   AbsoluteOffsetPosition getAbsolutePositionBeforeLeadingTrivia() const {
-    return Data->getAbsolutePositionBeforeLeadingTrivia();
+    return Data.getAbsolutePositionBeforeLeadingTrivia();
   }
 
   /// Get the offset at which the actual content (i.e. non-triva) of this node
   /// starts.
   AbsoluteOffsetPosition getAbsolutePositionAfterLeadingTrivia() const {
-    return Data->getAbsolutePositionAfterLeadingTrivia();
+    return Data.getAbsolutePositionAfterLeadingTrivia();
   }
 
   /// Get the offset at which the trailing trivia of this node starts.
   AbsoluteOffsetPosition getAbsoluteEndPositionBeforeTrailingTrivia() const {
-    return Data->getAbsoluteEndPositionBeforeTrailingTrivia();
+    return Data.getAbsoluteEndPositionBeforeTrailingTrivia();
   }
 
   /// Get the offset at which the trailing trivia of this node starts.
   AbsoluteOffsetPosition getAbsoluteEndPositionAfterTrailingTrivia() const {
-    return Data->getAbsoluteEndPositionAfterTrailingTrivia();
+    return Data.getAbsoluteEndPositionAfterTrailingTrivia();
   }
 
   // TODO: hasSameStructureAs ?

include/swift/Syntax/SyntaxCollection.h

@@ -57,8 +57,7 @@ class SyntaxCollection : public Syntax {
   friend class Syntax;
 
 private:
-  static RC<SyntaxData>
-  makeData(std::initializer_list<Element> &Elements) {
+  static SyntaxData makeData(std::initializer_list<Element> &Elements) {
     std::vector<RC<RawSyntax>> List;
     List.reserve(Elements.size());
     for (auto &Elt : Elements)
@@ -67,12 +66,9 @@ class SyntaxCollection : public Syntax {
                                             SourcePresence::Present);
     return SyntaxData::make(AbsoluteRawSyntax::forRoot(Raw));
   }
-  SyntaxCollection(const RC<SyntaxData> Root): Syntax(Root, Root.get()) {}
 
 public:
-
-  SyntaxCollection(const RC<SyntaxData> Root, const SyntaxData *Data)
-  : Syntax(Root, Data) {}
+  SyntaxCollection(const SyntaxData Data) : Syntax(Data) {}
 
   SyntaxCollection(std::initializer_list<Element> list):
     SyntaxCollection(SyntaxCollection::makeData(list)) {}
@@ -108,7 +104,7 @@ class SyntaxCollection : public Syntax {
   Element operator[](const size_t Index) const {
     assert(Index < size());
     assert(!empty());
-    return { Root, Data->getChild(Index).get() };
+    return Element(*Data.getChild(Index));
   }
 
   /// Return a new collection with the given element added to the end.
@@ -120,7 +116,7 @@ class SyntaxCollection : public Syntax {
     std::copy(OldLayout.begin(), OldLayout.end(), back_inserter(NewLayout));
     NewLayout.push_back(E.getRaw());
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return a new collection with an element removed from the end.
@@ -130,7 +126,7 @@ class SyntaxCollection : public Syntax {
     assert(!empty());
     auto NewLayout = getRaw()->getLayout().drop_back();
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return a new collection with the given element appended to the front.
@@ -141,7 +137,7 @@ class SyntaxCollection : public Syntax {
     std::copy(OldLayout.begin(), OldLayout.end(),
               std::back_inserter(NewLayout));
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return a new collection with an element removed from the end.
@@ -151,7 +147,7 @@ class SyntaxCollection : public Syntax {
     assert(!empty());
     auto NewLayout = getRaw()->getLayout().drop_front();
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return a new collection with the Element inserted at index i.
@@ -170,7 +166,7 @@ class SyntaxCollection : public Syntax {
     std::copy(OldLayout.begin() + i, OldLayout.end(),
               std::back_inserter(NewLayout));
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return a new collection with the element removed at index i.
@@ -181,13 +177,13 @@ class SyntaxCollection : public Syntax {
     std::advance(iterator, i);
     NewLayout.erase(iterator);
     auto Raw = RawSyntax::make(CollectionKind, NewLayout, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   /// Return an empty syntax collection of this type.
   SyntaxCollection<CollectionKind, Element> cleared() const {
     auto Raw = RawSyntax::make(CollectionKind, {}, getRaw()->getPresence());
-    return Data->replacingSelf<SyntaxCollection<CollectionKind, Element>>(Raw);
+    return SyntaxCollection<CollectionKind, Element>(Data.replacingSelf(Raw));
   }
 
   static bool kindof(SyntaxKind Kind) {