Revert "FileManager: Improve the FileEntryRef API and customize its OptionalStorage" and follow-ups

This reverts commit 5530fb5.
This reverts commit 010238a.
This reverts commit 84e8257.

Having trouble getting the bots compiling. Will try again later.

Author: dexonsmith

clang/include/clang/Basic/FileEntry.h

@@ -31,32 +31,16 @@ class File;
 
 namespace clang {
 
-class FileEntryRef;
-
-} // namespace clang
-
-namespace llvm {
-namespace optional_detail {
-
-/// Forward declare a template specialization for OptionalStorage.
-template <>
-class OptionalStorage<clang::FileEntryRef, /*is_trivially_copyable*/ true>;
-
-} // namespace optional_detail
-} // namespace llvm
-
-namespace clang {
-
 class DirectoryEntry;
 class FileEntry;
 
 /// A reference to a \c FileEntry that includes the name of the file as it was
 /// accessed by the FileManager's client.
 class FileEntryRef {
 public:
-  StringRef getName() const { return ME->first(); }
+  const StringRef getName() const { return Entry->first(); }
   const FileEntry &getFileEntry() const {
-    return *ME->second->V.get<FileEntry *>();
+    return *Entry->second->V.get<FileEntry *>();
   }
 
   inline bool isValid() const;
@@ -65,26 +49,12 @@ class FileEntryRef {
   inline const llvm::sys::fs::UniqueID &getUniqueID() const;
   inline time_t getModificationTime() const;
 
-  /// Check if the underlying FileEntry is the same, intentially ignoring
-  /// whether the file was referenced with the same spelling of the filename.
   friend bool operator==(const FileEntryRef &LHS, const FileEntryRef &RHS) {
-    return &LHS.getFileEntry() == &RHS.getFileEntry();
-  }
-  friend bool operator==(const FileEntry *LHS, const FileEntryRef &RHS) {
-    return LHS == &RHS.getFileEntry();
-  }
-  friend bool operator==(const FileEntryRef &LHS, const FileEntry *RHS) {
-    return &LHS.getFileEntry() == RHS;
+    return LHS.Entry == RHS.Entry;
   }
   friend bool operator!=(const FileEntryRef &LHS, const FileEntryRef &RHS) {
     return !(LHS == RHS);
   }
-  friend bool operator!=(const FileEntry *LHS, const FileEntryRef &RHS) {
-    return !(LHS == RHS);
-  }
-  friend bool operator!=(const FileEntryRef &LHS, const FileEntry *RHS) {
-    return !(LHS == RHS);
-  }
 
   struct MapValue;
 
@@ -108,191 +78,20 @@ class FileEntryRef {
     MapValue(MapEntry &ME) : V(&ME) {}
   };
 
-  /// Check if RHS referenced the file in exactly the same way.
-  bool isSameRef(const FileEntryRef &RHS) const { return ME == RHS.ME; }
-
-  /// Allow FileEntryRef to degrade into 'const FileEntry*' to facilitate
-  /// incremental adoption.
-  ///
-  /// The goal is to avoid code churn due to dances like the following:
-  /// \code
-  /// // Old code.
-  /// lvalue = rvalue;
-  ///
-  /// // Temporary code from an incremental patch.
-  /// lvalue = &rvalue.getFileEntry();
-  ///
-  /// // Final code.
-  /// lvalue = rvalue;
-  /// \endcode
-  ///
-  /// FIXME: Once FileEntryRef is "everywhere" and FileEntry::LastRef and
-  /// FileEntry::getName have been deleted, delete this implicit conversion.
-  operator const FileEntry *() const { return &getFileEntry(); }
-
-  FileEntryRef() = delete;
-  explicit FileEntryRef(const MapEntry &ME) : ME(&ME) {
-    assert(ME.second && "Expected payload");
-    assert(ME.second->V && "Expected non-null");
-    assert(ME.second->V.is<FileEntry *>() && "Expected FileEntry");
-  }
-
-  /// Expose the underlying MapEntry to simplify packing in a PointerIntPair or
-  /// PointerUnion and allow construction in Optional.
-  const clang::FileEntryRef::MapEntry &getMapEntry() const { return *ME; }
-
 private:
-  friend class llvm::optional_detail::OptionalStorage<
-      FileEntryRef, /*is_trivially_copyable*/ true>;
-  struct optional_none_tag {};
-
-  // Private constructor for use by OptionalStorage.
-  FileEntryRef(optional_none_tag) : ME(nullptr) {}
-  constexpr bool hasOptionalValue() const { return ME; }
-
-  const MapEntry *ME;
-};
-
-static_assert(sizeof(FileEntryRef) == sizeof(const FileEntry *),
-              "FileEntryRef must avoid size overhead");
-
-static_assert(std::is_trivially_copyable<FileEntryRef>::value,
-              "FileEntryRef must be trivially copyable");
-
-} // end namespace clang
-
-namespace llvm {
-namespace optional_detail {
-
-/// Customize OptionalStorage<FileEntryRef> to use FileEntryRef and its
-/// optional_none_tag to keep it the size of a single pointer.
-template <> class OptionalStorage<clang::FileEntryRef> {
-  clang::FileEntryRef MaybeRef;
-
-public:
-  ~OptionalStorage() = default;
-  constexpr OptionalStorage() noexcept
-      : MaybeRef(clang::FileEntryRef::optional_none_tag) {}
-  constexpr OptionalStorage(OptionalStorage const &Other) = default;
-  constexpr OptionalStorage(OptionalStorage &&Other) = default;
-  OptionalStorage &operator=(OptionalStorage const &Other) = default;
-  OptionalStorage &operator=(OptionalStorage &&Other) = default;
-
-  template <class... ArgTypes>
-  constexpr explicit OptionalStorage(in_place_t, ArgTypes &&...Args)
-      : MaybeRef(std::forward<ArgTypes>(Args)...) {}
-
-  void reset() noexcept { MaybeRef = clang::FileEntryRef::optional_none_tag(); }
-
-  constexpr bool hasValue() const noexcept {
-    return MaybeRef.hasOptionalValue();
-  }
-
-  clang::FileEntryRef &getValue() LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasValue());
-    return MaybeRef;
-  }
-  constexpr clang::FileEntryRef const &
-  getValue() const LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasValue());
-    return MaybeRef;
-  }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  clang::FileEntryRef &&getValue() &&noexcept {
-    assert(hasValue());
-    return std::move(MaybeRef);
-  }
-#endif
-
-  template <class... Args> void emplace(Args &&...args) {
-    MaybeRef = clang::FileEntryRef(std::forward<Args>(args)...);
-  }
-
-  OptionalStorage &operator=(clang::FileEntryRef Ref) {
-    MaybeRef = Ref;
-    return *this;
-  }
-};
-
-static_assert(sizeof(Optional<clang::FileEntryRef>) ==
-                  sizeof(clang::FileEntryRef),
-              "Optional<FileEntryRef> must avoid size overhead");
-
-static_assert(std::is_trivially_copyable<Optional<clang::FileEntryRef>>::value,
-              "Optional<FileEntryRef> should be trivially copyable");
-
-} // end namespace optional_detail
-} // end namespace llvm
-
-namespace clang {
+  friend class FileManager;
 
-/// Wrapper around Optional<FileEntryRef> that degrades to 'const FileEntry*',
-/// facilitating incremental patches to propagate FileEntryRef.
-///
-/// This class can be used as return value or field where it's convenient for
-/// an Optional<FileEntryRef> to degrade to a 'const FileEntry*'. The purpose
-/// is to avoid code churn due to dances like the following:
-/// \code
-/// // Old code.
-/// lvalue = rvalue;
-///
-/// // Temporary code from an incremental patch.
-/// Optional<FileEntryRef> MaybeF = rvalue;
-/// lvalue = MaybeF ? &MaybeF.getFileEntry() : nullptr;
-///
-/// // Final code.
-/// lvalue = rvalue;
-/// \endcode
-///
-/// FIXME: Once FileEntryRef is "everywhere" and FileEntry::LastRef and
-/// FileEntry::getName have been deleted, delete this class and replace
-/// instances with Optional<FileEntryRef>.
-class OptionalFileEntryRefDegradesToFileEntryPtr
-    : public Optional<FileEntryRef> {
-public:
-  constexpr OptionalFileEntryRefDegradesToFileEntryPtr() noexcept = default;
-  constexpr OptionalFileEntryRefDegradesToFileEntryPtr(
-      OptionalFileEntryRefDegradesToFileEntryPtr &&) = default;
-  constexpr OptionalFileEntryRefDegradesToFileEntryPtr(
-      const OptionalFileEntryRefDegradesToFileEntryPtr &) = default;
-  OptionalFileEntryRefDegradesToFileEntryPtr &
-  operator=(OptionalFileEntryRefDegradesToFileEntryPtr &&) = default;
-  OptionalFileEntryRefDegradesToFileEntryPtr &
-  operator=(const OptionalFileEntryRefDegradesToFileEntryPtr &) = default;
-
-  OptionalFileEntryRefDegradesToFileEntryPtr(llvm::NoneType) {}
-  OptionalFileEntryRefDegradesToFileEntryPtr(FileEntryRef Ref)
-      : Optional<FileEntryRef>(Ref) {}
-  OptionalFileEntryRefDegradesToFileEntryPtr(Optional<FileEntryRef> MaybeRef)
-      : Optional<FileEntryRef>(MaybeRef) {}
-
-  OptionalFileEntryRefDegradesToFileEntryPtr &operator=(llvm::NoneType) {
-    Optional<FileEntryRef>::operator=(None);
-    return *this;
-  }
-  OptionalFileEntryRefDegradesToFileEntryPtr &operator=(FileEntryRef Ref) {
-    Optional<FileEntryRef>::operator=(Ref);
-    return *this;
-  }
-  OptionalFileEntryRefDegradesToFileEntryPtr &
-  operator=(Optional<FileEntryRef> MaybeRef) {
-    Optional<FileEntryRef>::operator=(MaybeRef);
-    return *this;
+  FileEntryRef() = delete;
+  explicit FileEntryRef(const MapEntry &Entry)
+      : Entry(&Entry) {
+    assert(Entry.second && "Expected payload");
+    assert(Entry.second->V && "Expected non-null");
+    assert(Entry.second->V.is<FileEntry *>() && "Expected FileEntry");
   }
 
-  /// Degrade to 'const FileEntry *' to allow  FileEntry::LastRef and
-  /// FileEntry::getName have been deleted, delete this class and replace
-  /// instances with Optional<FileEntryRef>
-  operator const FileEntry *() const {
-    return hasValue() ? &getValue().getFileEntry() : nullptr;
-  }
+  const MapEntry *Entry;
 };
 
-static_assert(
-    std::is_trivially_copyable<
-        OptionalFileEntryRefDegradesToFileEntryPtr>::value,
-    "OptionalFileEntryRefDegradesToFileEntryPtr should be trivially copyable");
-
 /// Cached information about one file (either on disk
 /// or in the virtual file system).
 ///
@@ -348,6 +147,10 @@ class FileEntry {
   bool isNamedPipe() const { return IsNamedPipe; }
 
   void closeFile() const;
+
+  // Only for use in tests to see if deferred opens are happening, rather than
+  // relying on RealPathName being empty.
+  bool isOpenForTests() const { return File != nullptr; }
 };
 
 bool FileEntryRef::isValid() const { return getFileEntry().isValid(); }

clang/unittests/Basic/CMakeLists.txt

@@ -5,7 +5,6 @@ set(LLVM_LINK_COMPONENTS
 add_clang_unittest(BasicTests
   CharInfoTest.cpp
   DiagnosticTest.cpp
-  FileEntryTest.cpp
   FileManagerTest.cpp
   LineOffsetMappingTest.cpp
   SourceManagerTest.cpp