Merge pull request #36313 from ahoppen/pr/custom-opt-storage

[libSyntax] Hide null AbsoluteRawSyntax behind a custom OptionalStorage implementation

Author: ahoppen

include/swift/Syntax/AbsoluteRawSyntax.h

@@ -28,6 +28,8 @@ class SyntaxIndexInTree {
   explicit SyntaxIndexInTree(size_t IndexInTree) : IndexInTree(IndexInTree) {}
 
 public:
+  /// Create an *uninitialized* \c SyntaxIndexInTree.
+  SyntaxIndexInTree() {}
   static SyntaxIndexInTree zero() { return SyntaxIndexInTree(0); }
 
   /// Assuming that this index points to the start of \p Raw, advance it so that
@@ -83,6 +85,9 @@ class SyntaxIdentifier {
   SyntaxIndexInTree IndexInTree;
 
 public:
+  /// Create an *uninitialized* \c SyntaxIdentifier.
+  SyntaxIdentifier() {}
+
   SyntaxIdentifier(RootIdType RootId, SyntaxIndexInTree IndexInTree)
       : RootId(RootId), IndexInTree(IndexInTree) {
     assert(RootId < NextUnusedRootId && "New RootIds should only be created "
@@ -139,6 +144,9 @@ class AbsoluteSyntaxPosition {
   IndexInParentType IndexInParent;
 
 public:
+  /// Create an *uninitialized* \c AbsoluteSyntaxPosition.
+  AbsoluteSyntaxPosition() {}
+
   AbsoluteSyntaxPosition(OffsetType Offset, IndexInParentType IndexInParent)
       : Offset(Offset), IndexInParent(IndexInParent) {}
 
@@ -185,6 +193,8 @@ class AbsoluteOffsetPosition {
   AbsoluteSyntaxPosition::OffsetType Offset;
 
 public:
+  /// Create an *uninitialized* \c AbsoluteOffsetPosition.
+  AbsoluteOffsetPosition() {}
   explicit AbsoluteOffsetPosition(AbsoluteSyntaxPosition::OffsetType Offset)
       : Offset(Offset) {}
   AbsoluteOffsetPosition(AbsoluteSyntaxPosition Position)
@@ -205,6 +215,8 @@ class AbsoluteSyntaxInfo {
   SyntaxIdentifier NodeId;
 
 public:
+  /// Create an *uninitialized* \c AbsoluteSyntaxInfo.
+  AbsoluteSyntaxInfo() {}
   AbsoluteSyntaxInfo(AbsoluteSyntaxPosition Position, SyntaxIdentifier NodeId)
       : Position(Position), NodeId(NodeId) {}
 
@@ -242,42 +254,111 @@ class AbsoluteSyntaxInfo {
 
 /// A \c RawSyntax node that is enrichted with information of its position
 /// within the syntax tree it lives in.
-struct AbsoluteRawSyntax {
+class AbsoluteRawSyntax {
+  /// OptionalStorage is a friend so it can access the \c nullptr initializer
+  /// and \c isNull.
+  template <typename, bool>
+  friend class llvm::optional_detail::OptionalStorage;
+
   const RawSyntax *Raw;
-  const AbsoluteSyntaxInfo Info;
+  AbsoluteSyntaxInfo Info;
+
+  /// Whether this is a null \c AbsoluteRawSyntax.
+  bool isNull() const { return Raw == nullptr; }
+
+  /// Create a null \c AbsoluteRawSyntax. This should only be used in \c
+  /// AbsoluteRawSyntax's \c OptionalStorage.
+  explicit AbsoluteRawSyntax(std::nullptr_t) : Raw(nullptr) {}
 
 public:
+  /// Create an *uninitialized* \c AbsoluteRawSyntax.
+  explicit AbsoluteRawSyntax() {}
+
+  /// Create a new \c AbsoluteRawData backed by \p Raw and with additional \p
+  /// Info. The caller of this constructor is responsible to ensure that the
+  /// Arena of \p Raw (and thus \p Raw itself) outlives this \c
+  /// AbsoluteRawSyntax.
   AbsoluteRawSyntax(const RawSyntax *Raw, AbsoluteSyntaxInfo Info)
-      : Raw(Raw), Info(Info) {}
+      : Raw(Raw), Info(Info) {
+    assert(Raw != nullptr &&
+           "A AbsoluteRawSyntax created through the memberwise constructor "
+           "should always have a RawSyntax");
+  }
 
   /// Construct a \c AbsoluteRawSyntax for a \c RawSyntax node that represents
   /// the syntax tree's root.
   static AbsoluteRawSyntax forRoot(const RawSyntax *Raw) {
     return AbsoluteRawSyntax(Raw, AbsoluteSyntaxInfo::forRoot());
   }
 
-  const RawSyntax *getRaw() const { return Raw; }
+  const RawSyntax *getRaw() const {
+    assert(!isNull() && "Cannot get Raw of a null AbsoluteRawSyntax");
+    return Raw;
+  }
 
-  AbsoluteSyntaxInfo getInfo() const { return Info; }
+  AbsoluteSyntaxInfo getInfo() const {
+    assert(!isNull() && "Cannot get Raw of a null AbsoluteRawSyntax");
+    return Info;
+  }
 
   /// Get the position at which the leading triva of this node starts.
-  AbsoluteSyntaxPosition getPosition() const { return Info.getPosition(); };
+  AbsoluteSyntaxPosition getPosition() const {
+    return getInfo().getPosition();
+  };
 
-  SyntaxIdentifier getNodeId() const { return Info.getNodeId(); };
+  SyntaxIdentifier getNodeId() const { return getInfo().getNodeId(); };
 
   AbsoluteSyntaxPosition::IndexInParentType getIndexInParent() const {
     return getPosition().getIndexInParent();
   }
 
+  size_t getNumChildren() const { return getRaw()->getLayout().size(); }
+
+  /// Get the child at \p Index if it exists. If the node does not have a child
+  /// at \p Index, return \c None. Asserts that \p Index < \c NumChildren
+  inline Optional<AbsoluteRawSyntax>
+  getChild(AbsoluteSyntaxPosition::IndexInParentType Index) const;
+
+  /// Get the child at \p Index, asserting that it exists. This is slightly
+  /// more performant than \c getChild in these cases since the \c
+  /// AbsoluteRawSyntax node does not have to be wrapped in an \c Optional.
+  AbsoluteRawSyntax
+  getPresentChild(AbsoluteSyntaxPosition::IndexInParentType Index) const {
+    assert(Index < getNumChildren() && "Index out of bounds");
+    auto RawChild = getRaw()->getChild(Index);
+    assert(RawChild &&
+           "Child retrieved using getPresentChild must always exist");
+
+    AbsoluteSyntaxPosition Position = getPosition().advancedToFirstChild();
+    SyntaxIdentifier NodeId = getNodeId().advancedToFirstChild();
+
+    for (size_t I = 0; I < Index; ++I) {
+      Position = Position.advancedBy(getRaw()->getChild(I));
+      NodeId = NodeId.advancedBy(getRaw()->getChild(I));
+    }
+
+    AbsoluteSyntaxInfo Info(Position, NodeId);
+    return AbsoluteRawSyntax(RawChild, Info);
+  }
+
+  /// Get the first non-missing token node in this tree. Return \c None if
+  /// this node does not contain non-missing tokens.
+  inline Optional<AbsoluteRawSyntax> getFirstToken() const;
+
+  /// Get the last non-missing token node in this tree. Return \c None if
+  /// this node does not contain non-missing tokens.
+  inline Optional<AbsoluteRawSyntax> getLastToken() const;
+
   /// 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 RawSyntax *NewRaw,
                 SyntaxIdentifier::RootIdType NewRootId) const {
-    SyntaxIdentifier NewNodeId(NewRootId, Info.getNodeId().getIndexInTree());
-    AbsoluteSyntaxInfo NewInfo(Info.getPosition(), NewNodeId);
+    SyntaxIdentifier NewNodeId(NewRootId,
+                               getInfo().getNodeId().getIndexInTree());
+    AbsoluteSyntaxInfo NewInfo(getInfo().getPosition(), NewNodeId);
     return AbsoluteRawSyntax(NewRaw, NewInfo);
   }
 };
@@ -288,6 +369,122 @@ struct AbsoluteRawSyntax {
 namespace llvm {
 raw_ostream &operator<<(raw_ostream &OS,
                         swift::syntax::AbsoluteOffsetPosition Pos);
+
+namespace optional_detail {
+
+using swift::syntax::AbsoluteRawSyntax;
+
+/// A custom \c OptionalStorage implementation for \c AbsoluteRawSyntax that
+/// makes \c Optional<AbsoluteRawSyntax> a zero-cost wrapper around \c
+/// AbsoluteRawSyntax by using a special (externally not accessible) null \c
+/// AbsoluteRawSyntax to represent a missing value.
+template <>
+class OptionalStorage<AbsoluteRawSyntax> {
+  AbsoluteRawSyntax Storage;
+
+public:
+  OptionalStorage() : Storage(nullptr) {}
+  OptionalStorage(OptionalStorage const &other) = default;
+  OptionalStorage(OptionalStorage &&other) = default;
+
+  template <class... ArgTypes>
+  explicit OptionalStorage(llvm::optional_detail::in_place_t,
+                           ArgTypes &&...Args)
+      : Storage(std::forward<ArgTypes>(Args)...) {}
+
+  void reset() { Storage = AbsoluteRawSyntax(nullptr); }
+
+  bool hasValue() const { return !Storage.isNull(); }
+
+  AbsoluteRawSyntax &getValue() LLVM_LVALUE_FUNCTION {
+    assert(hasValue());
+    return Storage;
+  }
+  AbsoluteRawSyntax const &getValue() const LLVM_LVALUE_FUNCTION {
+    assert(hasValue());
+    return Storage;
+  }
+#if LLVM_HAS_RVALUE_REFERENCE_THIS
+  AbsoluteRawSyntax &&getValue() &&noexcept {
+    assert(hasValue());
+    return std::move(Storage);
+  }
+#endif
+
+  template <class... Args>
+  void emplace(Args &&...args) {
+    Storage = AbsoluteRawSyntax(std::forward<Args>(args)...);
+  }
+
+  OptionalStorage &operator=(const AbsoluteRawSyntax &AbsoluteRaw) {
+    Storage = AbsoluteRaw;
+    return *this;
+  }
+
+  OptionalStorage &operator=(AbsoluteRawSyntax &&AbsoluteRaw) {
+    Storage = std::move(AbsoluteRaw);
+    return *this;
+  }
+
+  OptionalStorage &operator=(OptionalStorage const &other) = default;
+  OptionalStorage &operator=(OptionalStorage &&other) = default;
+};
+} // namespace optional_detail
 } // end namespace llvm
 
+namespace swift {
+namespace syntax {
+
+Optional<AbsoluteRawSyntax> AbsoluteRawSyntax::getChild(
+    AbsoluteSyntaxPosition::IndexInParentType Index) const {
+  assert(Index < getNumChildren() && "Index out of bounds");
+  if (getRaw()->getChild(Index)) {
+    return getPresentChild(Index);
+  } else {
+    return None;
+  }
+}
+
+Optional<AbsoluteRawSyntax> AbsoluteRawSyntax::getFirstToken() const {
+  if (getRaw()->isToken() && !getRaw()->isMissing()) {
+    return *this;
+  }
+
+  size_t NumChildren = getNumChildren();
+  for (size_t I = 0; I < NumChildren; ++I) {
+    if (auto Child = getChild(I)) {
+      if (Child->getRaw()->isMissing()) {
+        continue;
+      }
+
+      if (auto Token = Child->getFirstToken()) {
+        return Token;
+      }
+    }
+  }
+  return None;
+}
+
+Optional<AbsoluteRawSyntax> AbsoluteRawSyntax::getLastToken() const {
+  if (getRaw()->isToken() && !getRaw()->isMissing()) {
+    return *this;
+  }
+
+  for (int I = getNumChildren() - 1; I >= 0; --I) {
+    if (auto Child = getChild(I)) {
+      if (Child->getRaw()->isMissing()) {
+        continue;
+      }
+
+      if (auto Token = Child->getLastToken()) {
+        return Token;
+      }
+    }
+  }
+  return None;
+}
+
+} // end namespace syntax
+} // end namespace swift
+
 #endif // SWIFT_SYNTAX_ABSOLUTERAWSYNTAX_H

include/swift/Syntax/RawSyntax.h

@@ -526,6 +526,7 @@ class RawSyntax final
   /// Get a child based on a particular node's "Cursor", indicating
   /// the position of the terms in the production of the Swift grammar.
   const RawSyntax *getChild(CursorIndex Index) const {
+    assert(Index < getNumChildren() && "Index out of bounds");
     return getLayout()[Index];
   }