clang 19.0.0git
FileEntry.h
Go to the documentation of this file.
1//===- clang/Basic/FileEntry.h - File references ----------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Defines interfaces for clang::FileEntry and clang::FileEntryRef.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_BASIC_FILEENTRY_H
15#define LLVM_CLANG_BASIC_FILEENTRY_H
16
19#include "clang/Basic/LLVM.h"
20#include "llvm/ADT/DenseMapInfo.h"
21#include "llvm/ADT/Hashing.h"
22#include "llvm/ADT/PointerUnion.h"
23#include "llvm/ADT/StringMap.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/Support/ErrorOr.h"
26#include "llvm/Support/FileSystem/UniqueID.h"
27
28#include <optional>
29#include <utility>
30
31namespace llvm {
32
33class MemoryBuffer;
34
35namespace vfs {
36
37class File;
38
39} // namespace vfs
40} // namespace llvm
41
42namespace clang {
43
44class FileEntryRef;
45
46namespace optional_detail {
47
48/// Forward declare a template specialization for OptionalStorage.
49template <> class OptionalStorage<clang::FileEntryRef>;
50
51} // namespace optional_detail
52
53class FileEntry;
54
55/// A reference to a \c FileEntry that includes the name of the file as it was
56/// accessed by the FileManager's client.
58public:
59 /// The name of this FileEntry. If a VFS uses 'use-external-name', this is
60 /// the redirected name. See getRequestedName().
61 StringRef getName() const { return getBaseMapEntry().first(); }
62
63 /// The name of this FileEntry, as originally requested without applying any
64 /// remappings for VFS 'use-external-name'.
65 ///
66 /// FIXME: this should be the semantics of getName(). See comment in
67 /// FileManager::getFileRef().
68 StringRef getNameAsRequested() const { return ME->first(); }
69
70 const FileEntry &getFileEntry() const {
71 return *getBaseMapEntry().second->V.get<FileEntry *>();
72 }
73 DirectoryEntryRef getDir() const { return ME->second->Dir; }
74
75 inline off_t getSize() const;
76 inline unsigned getUID() const;
77 inline const llvm::sys::fs::UniqueID &getUniqueID() const;
78 inline time_t getModificationTime() const;
79 inline bool isNamedPipe() const;
80 inline void closeFile() const;
81
82 /// Check if the underlying FileEntry is the same, intentially ignoring
83 /// whether the file was referenced with the same spelling of the filename.
84 friend bool operator==(const FileEntryRef &LHS, const FileEntryRef &RHS) {
85 return &LHS.getFileEntry() == &RHS.getFileEntry();
86 }
87 friend bool operator==(const FileEntry *LHS, const FileEntryRef &RHS) {
88 return LHS == &RHS.getFileEntry();
89 }
90 friend bool operator==(const FileEntryRef &LHS, const FileEntry *RHS) {
91 return &LHS.getFileEntry() == RHS;
92 }
93 friend bool operator!=(const FileEntryRef &LHS, const FileEntryRef &RHS) {
94 return !(LHS == RHS);
95 }
96 friend bool operator!=(const FileEntry *LHS, const FileEntryRef &RHS) {
97 return !(LHS == RHS);
98 }
99 friend bool operator!=(const FileEntryRef &LHS, const FileEntry *RHS) {
100 return !(LHS == RHS);
101 }
102
103 /// Hash code is based on the FileEntry, not the specific named reference,
104 /// just like operator==.
105 friend llvm::hash_code hash_value(FileEntryRef Ref) {
106 return llvm::hash_value(&Ref.getFileEntry());
107 }
108
109 struct MapValue;
110
111 /// Type used in the StringMap.
112 using MapEntry = llvm::StringMapEntry<llvm::ErrorOr<MapValue>>;
113
114 /// Type stored in the StringMap.
115 struct MapValue {
116 /// The pointer at another MapEntry is used when the FileManager should
117 /// silently forward from one name to another, which occurs in Redirecting
118 /// VFSs that use external names. In that case, the \c FileEntryRef
119 /// returned by the \c FileManager will have the external name, and not the
120 /// name that was used to lookup the file.
121 llvm::PointerUnion<FileEntry *, const MapEntry *> V;
122
123 /// Directory the file was found in.
125
126 MapValue() = delete;
127 MapValue(FileEntry &FE, DirectoryEntryRef Dir) : V(&FE), Dir(Dir) {}
128 MapValue(MapEntry &ME, DirectoryEntryRef Dir) : V(&ME), Dir(Dir) {}
129 };
130
131 /// Check if RHS referenced the file in exactly the same way.
132 bool isSameRef(const FileEntryRef &RHS) const { return ME == RHS.ME; }
133
134 /// Allow FileEntryRef to degrade into 'const FileEntry*' to facilitate
135 /// incremental adoption.
136 ///
137 /// The goal is to avoid code churn due to dances like the following:
138 /// \code
139 /// // Old code.
140 /// lvalue = rvalue;
141 ///
142 /// // Temporary code from an incremental patch.
143 /// lvalue = &rvalue.getFileEntry();
144 ///
145 /// // Final code.
146 /// lvalue = rvalue;
147 /// \endcode
148 ///
149 /// FIXME: Once FileEntryRef is "everywhere" and FileEntry::LastRef and
150 /// FileEntry::getName have been deleted, delete this implicit conversion.
151 operator const FileEntry *() const { return &getFileEntry(); }
152
153 FileEntryRef() = delete;
154 explicit FileEntryRef(const MapEntry &ME) : ME(&ME) {
155 assert(ME.second && "Expected payload");
156 assert(ME.second->V && "Expected non-null");
157 }
158
159 /// Expose the underlying MapEntry to simplify packing in a PointerIntPair or
160 /// PointerUnion and allow construction in Optional.
161 const clang::FileEntryRef::MapEntry &getMapEntry() const { return *ME; }
162
163 /// Retrieve the base MapEntry after redirects.
164 const MapEntry &getBaseMapEntry() const {
165 const MapEntry *Base = ME;
166 while (const auto *Next = Base->second->V.dyn_cast<const MapEntry *>())
167 Base = Next;
168 return *Base;
169 }
170
171private:
173 struct optional_none_tag {};
174
175 // Private constructor for use by OptionalStorage.
176 FileEntryRef(optional_none_tag) : ME(nullptr) {}
177 bool hasOptionalValue() const { return ME; }
178
179 friend struct llvm::DenseMapInfo<FileEntryRef>;
180 struct dense_map_empty_tag {};
181 struct dense_map_tombstone_tag {};
182
183 // Private constructors for use by DenseMapInfo.
184 FileEntryRef(dense_map_empty_tag)
185 : ME(llvm::DenseMapInfo<const MapEntry *>::getEmptyKey()) {}
186 FileEntryRef(dense_map_tombstone_tag)
187 : ME(llvm::DenseMapInfo<const MapEntry *>::getTombstoneKey()) {}
188 bool isSpecialDenseMapKey() const {
189 return isSameRef(FileEntryRef(dense_map_empty_tag())) ||
190 isSameRef(FileEntryRef(dense_map_tombstone_tag()));
191 }
192
193 const MapEntry *ME;
194};
195
196static_assert(sizeof(FileEntryRef) == sizeof(const FileEntry *),
197 "FileEntryRef must avoid size overhead");
198
199static_assert(std::is_trivially_copyable<FileEntryRef>::value,
200 "FileEntryRef must be trivially copyable");
201
203
204namespace optional_detail {
205
206/// Customize OptionalStorage<FileEntryRef> to use FileEntryRef and its
207/// optional_none_tag to keep it the size of a single pointer.
208template <>
210 : public clang::FileMgr::MapEntryOptionalStorage<clang::FileEntryRef> {
211 using StorageImpl =
213
214public:
215 OptionalStorage() = default;
216
217 template <class... ArgTypes>
218 explicit OptionalStorage(std::in_place_t, ArgTypes &&...Args)
219 : StorageImpl(std::in_place_t{}, std::forward<ArgTypes>(Args)...) {}
220
222 StorageImpl::operator=(Ref);
223 return *this;
224 }
225};
226
227static_assert(sizeof(OptionalFileEntryRef) == sizeof(FileEntryRef),
228 "OptionalFileEntryRef must avoid size overhead");
229
230static_assert(std::is_trivially_copyable<OptionalFileEntryRef>::value,
231 "OptionalFileEntryRef should be trivially copyable");
232
233} // end namespace optional_detail
234} // namespace clang
235
236namespace llvm {
237
238/// Specialisation of DenseMapInfo for FileEntryRef.
239template <> struct DenseMapInfo<clang::FileEntryRef> {
241 return clang::FileEntryRef(clang::FileEntryRef::dense_map_empty_tag());
242 }
243
245 return clang::FileEntryRef(clang::FileEntryRef::dense_map_tombstone_tag());
246 }
247
248 static unsigned getHashValue(clang::FileEntryRef Val) {
249 return hash_value(Val);
250 }
251
253 // Catch the easy cases: both empty, both tombstone, or the same ref.
254 if (LHS.isSameRef(RHS))
255 return true;
256
257 // Confirm LHS and RHS are valid.
258 if (LHS.isSpecialDenseMapKey() || RHS.isSpecialDenseMapKey())
259 return false;
260
261 // It's safe to use operator==.
262 return LHS == RHS;
263 }
264
265 /// Support for finding `const FileEntry *` in a `DenseMap<FileEntryRef, T>`.
266 /// @{
267 static unsigned getHashValue(const clang::FileEntry *Val) {
268 return llvm::hash_value(Val);
269 }
270 static bool isEqual(const clang::FileEntry *LHS, clang::FileEntryRef RHS) {
271 if (RHS.isSpecialDenseMapKey())
272 return false;
273 return LHS == RHS;
274 }
275 /// @}
276};
277
278} // end namespace llvm
279
280namespace clang {
281
282inline bool operator==(const FileEntry *LHS, const OptionalFileEntryRef &RHS) {
283 return LHS == (RHS ? &RHS->getFileEntry() : nullptr);
284}
285inline bool operator==(const OptionalFileEntryRef &LHS, const FileEntry *RHS) {
286 return (LHS ? &LHS->getFileEntry() : nullptr) == RHS;
287}
288inline bool operator!=(const FileEntry *LHS, const OptionalFileEntryRef &RHS) {
289 return !(LHS == RHS);
290}
291inline bool operator!=(const OptionalFileEntryRef &LHS, const FileEntry *RHS) {
292 return !(LHS == RHS);
293}
294
295/// Cached information about one file (either on disk
296/// or in the virtual file system).
297///
298/// If the 'File' member is valid, then this FileEntry has an open file
299/// descriptor for the file.
301 friend class FileManager;
303 FileEntry();
304 FileEntry(const FileEntry &) = delete;
305 FileEntry &operator=(const FileEntry &) = delete;
306
307 std::string RealPathName; // Real path to the file; could be empty.
308 off_t Size = 0; // File size in bytes.
309 time_t ModTime = 0; // Modification time of file.
310 const DirectoryEntry *Dir = nullptr; // Directory file lives in.
311 llvm::sys::fs::UniqueID UniqueID;
312 unsigned UID = 0; // A unique (small) ID for the file.
313 bool IsNamedPipe = false;
314
315 /// The open file, if it is owned by the \p FileEntry.
316 mutable std::unique_ptr<llvm::vfs::File> File;
317
318 /// The file content, if it is owned by the \p FileEntry.
319 std::unique_ptr<llvm::MemoryBuffer> Content;
320
321public:
323
324 StringRef tryGetRealPathName() const { return RealPathName; }
325 off_t getSize() const { return Size; }
326 unsigned getUID() const { return UID; }
327 const llvm::sys::fs::UniqueID &getUniqueID() const { return UniqueID; }
328 time_t getModificationTime() const { return ModTime; }
329
330 /// Return the directory the file lives in.
331 const DirectoryEntry *getDir() const { return Dir; }
332
333 /// Check whether the file is a named pipe (and thus can't be opened by
334 /// the native FileManager methods).
335 bool isNamedPipe() const { return IsNamedPipe; }
336
337 void closeFile() const;
338};
339
340off_t FileEntryRef::getSize() const { return getFileEntry().getSize(); }
341
342unsigned FileEntryRef::getUID() const { return getFileEntry().getUID(); }
343
344const llvm::sys::fs::UniqueID &FileEntryRef::getUniqueID() const {
345 return getFileEntry().getUniqueID();
346}
347
350}
351
353
355
356} // end namespace clang
357
358#endif // LLVM_CLANG_BASIC_FILEENTRY_H
#define V(N, I)
Definition: ASTContext.h:3255
Defines interfaces for clang::DirectoryEntry and clang::DirectoryEntryRef.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...
Cached information about one directory (either on disk or in the virtual file system).
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Definition: FileEntry.h:57
friend bool operator==(const FileEntry *LHS, const FileEntryRef &RHS)
Definition: FileEntry.h:87
friend llvm::hash_code hash_value(FileEntryRef Ref)
Hash code is based on the FileEntry, not the specific named reference, just like operator==.
Definition: FileEntry.h:105
const FileEntry & getFileEntry() const
Definition: FileEntry.h:70
bool isSameRef(const FileEntryRef &RHS) const
Check if RHS referenced the file in exactly the same way.
Definition: FileEntry.h:132
const clang::FileEntryRef::MapEntry & getMapEntry() const
Expose the underlying MapEntry to simplify packing in a PointerIntPair or PointerUnion and allow cons...
Definition: FileEntry.h:161
void closeFile() const
Definition: FileEntry.h:354
time_t getModificationTime() const
Definition: FileEntry.h:348
friend bool operator!=(const FileEntryRef &LHS, const FileEntryRef &RHS)
Definition: FileEntry.h:93
bool isNamedPipe() const
Definition: FileEntry.h:352
FileEntryRef(const MapEntry &ME)
Definition: FileEntry.h:154
friend bool operator!=(const FileEntry *LHS, const FileEntryRef &RHS)
Definition: FileEntry.h:96
off_t getSize() const
Definition: FileEntry.h:340
llvm::StringMapEntry< llvm::ErrorOr< MapValue > > MapEntry
Type used in the StringMap.
Definition: FileEntry.h:112
StringRef getName() const
The name of this FileEntry.
Definition: FileEntry.h:61
friend bool operator!=(const FileEntryRef &LHS, const FileEntry *RHS)
Definition: FileEntry.h:99
const llvm::sys::fs::UniqueID & getUniqueID() const
Definition: FileEntry.h:344
StringRef getNameAsRequested() const
The name of this FileEntry, as originally requested without applying any remappings for VFS 'use-exte...
Definition: FileEntry.h:68
DirectoryEntryRef getDir() const
Definition: FileEntry.h:73
friend bool operator==(const FileEntryRef &LHS, const FileEntryRef &RHS)
Check if the underlying FileEntry is the same, intentially ignoring whether the file was referenced w...
Definition: FileEntry.h:84
unsigned getUID() const
Definition: FileEntry.h:342
friend bool operator==(const FileEntryRef &LHS, const FileEntry *RHS)
Definition: FileEntry.h:90
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:300
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileEntry.h:331
StringRef tryGetRealPathName() const
Definition: FileEntry.h:324
friend class FileEntryTestHelper
Definition: FileEntry.h:302
time_t getModificationTime() const
Definition: FileEntry.h:328
unsigned getUID() const
Definition: FileEntry.h:326
bool isNamedPipe() const
Check whether the file is a named pipe (and thus can't be opened by the native FileManager methods).
Definition: FileEntry.h:335
void closeFile() const
Definition: FileEntry.cpp:24
off_t getSize() const
Definition: FileEntry.h:325
const llvm::sys::fs::UniqueID & getUniqueID() const
Definition: FileEntry.h:327
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
Customized storage for refs derived from map entires in FileManager, using the private optional_none_...
OptionalStorage(std::in_place_t, ArgTypes &&...Args)
Definition: FileEntry.h:218
OptionalStorage & operator=(clang::FileEntryRef Ref)
Definition: FileEntry.h:221
Code completion in a.
The JSON file list parser is used to communicate input to InstallAPI.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
Definition: CallGraph.h:207
bool operator!=(CanQual< T > x, CanQual< U > y)
YAML serialization mapping.
Definition: Dominators.h:30
hash_code hash_value(const clang::tooling::dependencies::ModuleID &ID)
Definition: Format.h:5292
Type stored in the StringMap.
Definition: FileEntry.h:115
DirectoryEntryRef Dir
Directory the file was found in.
Definition: FileEntry.h:124
MapValue(FileEntry &FE, DirectoryEntryRef Dir)
Definition: FileEntry.h:127
MapValue(MapEntry &ME, DirectoryEntryRef Dir)
Definition: FileEntry.h:128
llvm::PointerUnion< FileEntry *, const MapEntry * > V
The pointer at another MapEntry is used when the FileManager should silently forward from one name to...
Definition: FileEntry.h:121
static unsigned getHashValue(const clang::FileEntry *Val)
Support for finding const FileEntry * in a DenseMap<FileEntryRef, T>.
Definition: FileEntry.h:267
static unsigned getHashValue(clang::FileEntryRef Val)
Definition: FileEntry.h:248
static bool isEqual(const clang::FileEntry *LHS, clang::FileEntryRef RHS)
Definition: FileEntry.h:270
static clang::FileEntryRef getTombstoneKey()
Definition: FileEntry.h:244
static clang::FileEntryRef getEmptyKey()
Definition: FileEntry.h:240
static bool isEqual(clang::FileEntryRef LHS, clang::FileEntryRef RHS)
Definition: FileEntry.h:252