1 | //===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- 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 | // This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), |
10 | // cast_if_present<X>(), and dyn_cast_if_present<X>() templates. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_SUPPORT_CASTING_H |
15 | #define LLVM_SUPPORT_CASTING_H |
16 | |
17 | #include "llvm/Support/Compiler.h" |
18 | #include "llvm/Support/type_traits.h" |
19 | #include <cassert> |
20 | #include <memory> |
21 | #include <optional> |
22 | #include <type_traits> |
23 | |
24 | namespace llvm { |
25 | |
26 | //===----------------------------------------------------------------------===// |
27 | // simplify_type |
28 | //===----------------------------------------------------------------------===// |
29 | |
30 | /// Define a template that can be specialized by smart pointers to reflect the |
31 | /// fact that they are automatically dereferenced, and are not involved with the |
32 | /// template selection process... the default implementation is a noop. |
33 | // TODO: rename this and/or replace it with other cast traits. |
34 | template <typename From> struct simplify_type { |
35 | using SimpleType = From; // The real type this represents... |
36 | |
37 | // An accessor to get the real value... |
38 | static SimpleType &getSimplifiedValue(From &Val) { return Val; } |
39 | }; |
40 | |
41 | template <typename From> struct simplify_type<const From> { |
42 | using NonConstSimpleType = typename simplify_type<From>::SimpleType; |
43 | using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type; |
44 | using RetType = |
45 | typename add_lvalue_reference_if_not_pointer<SimpleType>::type; |
46 | |
47 | static RetType getSimplifiedValue(const From &Val) { |
48 | return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val)); |
49 | } |
50 | }; |
51 | |
52 | // TODO: add this namespace once everyone is switched to using the new |
53 | // interface. |
54 | // namespace detail { |
55 | |
56 | //===----------------------------------------------------------------------===// |
57 | // isa_impl |
58 | //===----------------------------------------------------------------------===// |
59 | |
60 | // The core of the implementation of isa<X> is here; To and From should be |
61 | // the names of classes. This template can be specialized to customize the |
62 | // implementation of isa<> without rewriting it from scratch. |
63 | template <typename To, typename From, typename Enabler = void> struct isa_impl { |
64 | static inline bool doit(const From &Val) { return To::classof(&Val); } |
65 | }; |
66 | |
67 | // Always allow upcasts, and perform no dynamic check for them. |
68 | template <typename To, typename From> |
69 | struct isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> { |
70 | static inline bool doit(const From &) { return true; } |
71 | }; |
72 | |
73 | template <typename To, typename From> struct isa_impl_cl { |
74 | static inline bool doit(const From &Val) { |
75 | return isa_impl<To, From>::doit(Val); |
76 | } |
77 | }; |
78 | |
79 | template <typename To, typename From> struct isa_impl_cl<To, const From> { |
80 | static inline bool doit(const From &Val) { |
81 | return isa_impl<To, From>::doit(Val); |
82 | } |
83 | }; |
84 | |
85 | template <typename To, typename From> |
86 | struct isa_impl_cl<To, const std::unique_ptr<From>> { |
87 | static inline bool doit(const std::unique_ptr<From> &Val) { |
88 | assert(Val && "isa<> used on a null pointer" ); |
89 | return isa_impl_cl<To, From>::doit(*Val); |
90 | } |
91 | }; |
92 | |
93 | template <typename To, typename From> struct isa_impl_cl<To, From *> { |
94 | static inline bool doit(const From *Val) { |
95 | assert(Val && "isa<> used on a null pointer" ); |
96 | return isa_impl<To, From>::doit(*Val); |
97 | } |
98 | }; |
99 | |
100 | template <typename To, typename From> struct isa_impl_cl<To, From *const> { |
101 | static inline bool doit(const From *Val) { |
102 | assert(Val && "isa<> used on a null pointer" ); |
103 | return isa_impl<To, From>::doit(*Val); |
104 | } |
105 | }; |
106 | |
107 | template <typename To, typename From> struct isa_impl_cl<To, const From *> { |
108 | static inline bool doit(const From *Val) { |
109 | assert(Val && "isa<> used on a null pointer" ); |
110 | return isa_impl<To, From>::doit(*Val); |
111 | } |
112 | }; |
113 | |
114 | template <typename To, typename From> |
115 | struct isa_impl_cl<To, const From *const> { |
116 | static inline bool doit(const From *Val) { |
117 | assert(Val && "isa<> used on a null pointer" ); |
118 | return isa_impl<To, From>::doit(*Val); |
119 | } |
120 | }; |
121 | |
122 | template <typename To, typename From, typename SimpleFrom> |
123 | struct isa_impl_wrap { |
124 | // When From != SimplifiedType, we can simplify the type some more by using |
125 | // the simplify_type template. |
126 | static bool doit(const From &Val) { |
127 | return isa_impl_wrap<To, SimpleFrom, |
128 | typename simplify_type<SimpleFrom>::SimpleType>:: |
129 | doit(simplify_type<const From>::getSimplifiedValue(Val)); |
130 | } |
131 | }; |
132 | |
133 | template <typename To, typename FromTy> |
134 | struct isa_impl_wrap<To, FromTy, FromTy> { |
135 | // When From == SimpleType, we are as simple as we are going to get. |
136 | static bool doit(const FromTy &Val) { |
137 | return isa_impl_cl<To, FromTy>::doit(Val); |
138 | } |
139 | }; |
140 | |
141 | //===----------------------------------------------------------------------===// |
142 | // cast_retty + cast_retty_impl |
143 | //===----------------------------------------------------------------------===// |
144 | |
145 | template <class To, class From> struct cast_retty; |
146 | |
147 | // Calculate what type the 'cast' function should return, based on a requested |
148 | // type of To and a source type of From. |
149 | template <class To, class From> struct cast_retty_impl { |
150 | using ret_type = To &; // Normal case, return Ty& |
151 | }; |
152 | template <class To, class From> struct cast_retty_impl<To, const From> { |
153 | using ret_type = const To &; // Normal case, return Ty& |
154 | }; |
155 | |
156 | template <class To, class From> struct cast_retty_impl<To, From *> { |
157 | using ret_type = To *; // Pointer arg case, return Ty* |
158 | }; |
159 | |
160 | template <class To, class From> struct cast_retty_impl<To, const From *> { |
161 | using ret_type = const To *; // Constant pointer arg case, return const Ty* |
162 | }; |
163 | |
164 | template <class To, class From> struct cast_retty_impl<To, const From *const> { |
165 | using ret_type = const To *; // Constant pointer arg case, return const Ty* |
166 | }; |
167 | |
168 | template <class To, class From> |
169 | struct cast_retty_impl<To, std::unique_ptr<From>> { |
170 | private: |
171 | using PointerType = typename cast_retty_impl<To, From *>::ret_type; |
172 | using ResultType = std::remove_pointer_t<PointerType>; |
173 | |
174 | public: |
175 | using ret_type = std::unique_ptr<ResultType>; |
176 | }; |
177 | |
178 | template <class To, class From, class SimpleFrom> struct cast_retty_wrap { |
179 | // When the simplified type and the from type are not the same, use the type |
180 | // simplifier to reduce the type, then reuse cast_retty_impl to get the |
181 | // resultant type. |
182 | using ret_type = typename cast_retty<To, SimpleFrom>::ret_type; |
183 | }; |
184 | |
185 | template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> { |
186 | // When the simplified type is equal to the from type, use it directly. |
187 | using ret_type = typename cast_retty_impl<To, FromTy>::ret_type; |
188 | }; |
189 | |
190 | template <class To, class From> struct cast_retty { |
191 | using ret_type = typename cast_retty_wrap< |
192 | To, From, typename simplify_type<From>::SimpleType>::ret_type; |
193 | }; |
194 | |
195 | //===----------------------------------------------------------------------===// |
196 | // cast_convert_val |
197 | //===----------------------------------------------------------------------===// |
198 | |
199 | // Ensure the non-simple values are converted using the simplify_type template |
200 | // that may be specialized by smart pointers... |
201 | // |
202 | template <class To, class From, class SimpleFrom> struct cast_convert_val { |
203 | // This is not a simple type, use the template to simplify it... |
204 | static typename cast_retty<To, From>::ret_type doit(const From &Val) { |
205 | return cast_convert_val<To, SimpleFrom, |
206 | typename simplify_type<SimpleFrom>::SimpleType>:: |
207 | doit(simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val))); |
208 | } |
209 | }; |
210 | |
211 | template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> { |
212 | // If it's a reference, switch to a pointer to do the cast and then deref it. |
213 | static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) { |
214 | return *(std::remove_reference_t<typename cast_retty<To, FromTy>::ret_type> |
215 | *)&const_cast<FromTy &>(Val); |
216 | } |
217 | }; |
218 | |
219 | template <class To, class FromTy> |
220 | struct cast_convert_val<To, FromTy *, FromTy *> { |
221 | // If it's a pointer, we can use c-style casting directly. |
222 | static typename cast_retty<To, FromTy *>::ret_type doit(const FromTy *Val) { |
223 | return (typename cast_retty<To, FromTy *>::ret_type) const_cast<FromTy *>( |
224 | Val); |
225 | } |
226 | }; |
227 | |
228 | //===----------------------------------------------------------------------===// |
229 | // is_simple_type |
230 | //===----------------------------------------------------------------------===// |
231 | |
232 | template <class X> struct is_simple_type { |
233 | static const bool value = |
234 | std::is_same_v<X, typename simplify_type<X>::SimpleType>; |
235 | }; |
236 | |
237 | // } // namespace detail |
238 | |
239 | //===----------------------------------------------------------------------===// |
240 | // CastIsPossible |
241 | //===----------------------------------------------------------------------===// |
242 | |
243 | /// This struct provides a way to check if a given cast is possible. It provides |
244 | /// a static function called isPossible that is used to check if a cast can be |
245 | /// performed. It should be overridden like this: |
246 | /// |
247 | /// template<> struct CastIsPossible<foo, bar> { |
248 | /// static inline bool isPossible(const bar &b) { |
249 | /// return bar.isFoo(); |
250 | /// } |
251 | /// }; |
252 | template <typename To, typename From, typename Enable = void> |
253 | struct CastIsPossible { |
254 | static inline bool isPossible(const From &f) { |
255 | return isa_impl_wrap< |
256 | To, const From, |
257 | typename simplify_type<const From>::SimpleType>::doit(f); |
258 | } |
259 | }; |
260 | |
261 | // Needed for optional unwrapping. This could be implemented with isa_impl, but |
262 | // we want to implement things in the new method and move old implementations |
263 | // over. In fact, some of the isa_impl templates should be moved over to |
264 | // CastIsPossible. |
265 | template <typename To, typename From> |
266 | struct CastIsPossible<To, std::optional<From>> { |
267 | static inline bool isPossible(const std::optional<From> &f) { |
268 | assert(f && "CastIsPossible::isPossible called on a nullopt!" ); |
269 | return isa_impl_wrap< |
270 | To, const From, |
271 | typename simplify_type<const From>::SimpleType>::doit(*f); |
272 | } |
273 | }; |
274 | |
275 | /// Upcasting (from derived to base) and casting from a type to itself should |
276 | /// always be possible. |
277 | template <typename To, typename From> |
278 | struct CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> { |
279 | static inline bool isPossible(const From &f) { return true; } |
280 | }; |
281 | |
282 | //===----------------------------------------------------------------------===// |
283 | // Cast traits |
284 | //===----------------------------------------------------------------------===// |
285 | |
286 | /// All of these cast traits are meant to be implementations for useful casts |
287 | /// that users may want to use that are outside the standard behavior. An |
288 | /// example of how to use a special cast called `CastTrait` is: |
289 | /// |
290 | /// template<> struct CastInfo<foo, bar> : public CastTrait<foo, bar> {}; |
291 | /// |
292 | /// Essentially, if your use case falls directly into one of the use cases |
293 | /// supported by a given cast trait, simply inherit your special CastInfo |
294 | /// directly from one of these to avoid having to reimplement the boilerplate |
295 | /// `isPossible/castFailed/doCast/doCastIfPossible`. A cast trait can also |
296 | /// provide a subset of those functions. |
297 | |
298 | /// This cast trait just provides castFailed for the specified `To` type to make |
299 | /// CastInfo specializations more declarative. In order to use this, the target |
300 | /// result type must be `To` and `To` must be constructible from `nullptr`. |
301 | template <typename To> struct NullableValueCastFailed { |
302 | static To castFailed() { return To(nullptr); } |
303 | }; |
304 | |
305 | /// This cast trait just provides the default implementation of doCastIfPossible |
306 | /// to make CastInfo specializations more declarative. The `Derived` template |
307 | /// parameter *must* be provided for forwarding castFailed and doCast. |
308 | template <typename To, typename From, typename Derived> |
309 | struct DefaultDoCastIfPossible { |
310 | static To doCastIfPossible(From f) { |
311 | if (!Derived::isPossible(f)) |
312 | return Derived::castFailed(); |
313 | return Derived::doCast(f); |
314 | } |
315 | }; |
316 | |
317 | namespace detail { |
318 | /// A helper to derive the type to use with `Self` for cast traits, when the |
319 | /// provided CRTP derived type is allowed to be void. |
320 | template <typename OptionalDerived, typename Default> |
321 | using SelfType = std::conditional_t<std::is_same_v<OptionalDerived, void>, |
322 | Default, OptionalDerived>; |
323 | } // namespace detail |
324 | |
325 | /// This cast trait provides casting for the specific case of casting to a |
326 | /// value-typed object from a pointer-typed object. Note that `To` must be |
327 | /// nullable/constructible from a pointer to `From` to use this cast. |
328 | template <typename To, typename From, typename Derived = void> |
329 | struct ValueFromPointerCast |
330 | : public CastIsPossible<To, From *>, |
331 | public NullableValueCastFailed<To>, |
332 | public DefaultDoCastIfPossible< |
333 | To, From *, |
334 | detail::SelfType<Derived, ValueFromPointerCast<To, From>>> { |
335 | static inline To doCast(From *f) { return To(f); } |
336 | }; |
337 | |
338 | /// This cast trait provides std::unique_ptr casting. It has the semantics of |
339 | /// moving the contents of the input unique_ptr into the output unique_ptr |
340 | /// during the cast. It's also a good example of how to implement a move-only |
341 | /// cast. |
342 | template <typename To, typename From, typename Derived = void> |
343 | struct UniquePtrCast : public CastIsPossible<To, From *> { |
344 | using Self = detail::SelfType<Derived, UniquePtrCast<To, From>>; |
345 | using CastResultType = std::unique_ptr< |
346 | std::remove_reference_t<typename cast_retty<To, From>::ret_type>>; |
347 | |
348 | static inline CastResultType doCast(std::unique_ptr<From> &&f) { |
349 | return CastResultType((typename CastResultType::element_type *)f.release()); |
350 | } |
351 | |
352 | static inline CastResultType castFailed() { return CastResultType(nullptr); } |
353 | |
354 | static inline CastResultType doCastIfPossible(std::unique_ptr<From> &&f) { |
355 | if (!Self::isPossible(f)) |
356 | return castFailed(); |
357 | return doCast(f); |
358 | } |
359 | }; |
360 | |
361 | /// This cast trait provides std::optional<T> casting. This means that if you |
362 | /// have a value type, you can cast it to another value type and have dyn_cast |
363 | /// return an std::optional<T>. |
364 | template <typename To, typename From, typename Derived = void> |
365 | struct OptionalValueCast |
366 | : public CastIsPossible<To, From>, |
367 | public DefaultDoCastIfPossible< |
368 | std::optional<To>, From, |
369 | detail::SelfType<Derived, OptionalValueCast<To, From>>> { |
370 | static inline std::optional<To> castFailed() { return std::optional<To>{}; } |
371 | |
372 | static inline std::optional<To> doCast(const From &f) { return To(f); } |
373 | }; |
374 | |
375 | /// Provides a cast trait that strips `const` from types to make it easier to |
376 | /// implement a const-version of a non-const cast. It just removes boilerplate |
377 | /// and reduces the amount of code you as the user need to implement. You can |
378 | /// use it like this: |
379 | /// |
380 | /// template<> struct CastInfo<foo, bar> { |
381 | /// ...verbose implementation... |
382 | /// }; |
383 | /// |
384 | /// template<> struct CastInfo<foo, const bar> : public |
385 | /// ConstStrippingForwardingCast<foo, const bar, CastInfo<foo, bar>> {}; |
386 | /// |
387 | template <typename To, typename From, typename ForwardTo> |
388 | struct ConstStrippingForwardingCast { |
389 | // Remove the pointer if it exists, then we can get rid of consts/volatiles. |
390 | using DecayedFrom = std::remove_cv_t<std::remove_pointer_t<From>>; |
391 | // Now if it's a pointer, add it back. Otherwise, we want a ref. |
392 | using NonConstFrom = |
393 | std::conditional_t<std::is_pointer_v<From>, DecayedFrom *, DecayedFrom &>; |
394 | |
395 | static inline bool isPossible(const From &f) { |
396 | return ForwardTo::isPossible(const_cast<NonConstFrom>(f)); |
397 | } |
398 | |
399 | static inline decltype(auto) castFailed() { return ForwardTo::castFailed(); } |
400 | |
401 | static inline decltype(auto) doCast(const From &f) { |
402 | return ForwardTo::doCast(const_cast<NonConstFrom>(f)); |
403 | } |
404 | |
405 | static inline decltype(auto) doCastIfPossible(const From &f) { |
406 | return ForwardTo::doCastIfPossible(const_cast<NonConstFrom>(f)); |
407 | } |
408 | }; |
409 | |
410 | /// Provides a cast trait that uses a defined pointer to pointer cast as a base |
411 | /// for reference-to-reference casts. Note that it does not provide castFailed |
412 | /// and doCastIfPossible because a pointer-to-pointer cast would likely just |
413 | /// return `nullptr` which could cause nullptr dereference. You can use it like |
414 | /// this: |
415 | /// |
416 | /// template <> struct CastInfo<foo, bar *> { ... verbose implementation... }; |
417 | /// |
418 | /// template <> |
419 | /// struct CastInfo<foo, bar> |
420 | /// : public ForwardToPointerCast<foo, bar, CastInfo<foo, bar *>> {}; |
421 | /// |
422 | template <typename To, typename From, typename ForwardTo> |
423 | struct ForwardToPointerCast { |
424 | static inline bool isPossible(const From &f) { |
425 | return ForwardTo::isPossible(&f); |
426 | } |
427 | |
428 | static inline decltype(auto) doCast(const From &f) { |
429 | return *ForwardTo::doCast(&f); |
430 | } |
431 | }; |
432 | |
433 | //===----------------------------------------------------------------------===// |
434 | // CastInfo |
435 | //===----------------------------------------------------------------------===// |
436 | |
437 | /// This struct provides a method for customizing the way a cast is performed. |
438 | /// It inherits from CastIsPossible, to support the case of declaring many |
439 | /// CastIsPossible specializations without having to specialize the full |
440 | /// CastInfo. |
441 | /// |
442 | /// In order to specialize different behaviors, specify different functions in |
443 | /// your CastInfo specialization. |
444 | /// For isa<> customization, provide: |
445 | /// |
446 | /// `static bool isPossible(const From &f)` |
447 | /// |
448 | /// For cast<> customization, provide: |
449 | /// |
450 | /// `static To doCast(const From &f)` |
451 | /// |
452 | /// For dyn_cast<> and the *_if_present<> variants' customization, provide: |
453 | /// |
454 | /// `static To castFailed()` and `static To doCastIfPossible(const From &f)` |
455 | /// |
456 | /// Your specialization might look something like this: |
457 | /// |
458 | /// template<> struct CastInfo<foo, bar> : public CastIsPossible<foo, bar> { |
459 | /// static inline foo doCast(const bar &b) { |
460 | /// return foo(const_cast<bar &>(b)); |
461 | /// } |
462 | /// static inline foo castFailed() { return foo(); } |
463 | /// static inline foo doCastIfPossible(const bar &b) { |
464 | /// if (!CastInfo<foo, bar>::isPossible(b)) |
465 | /// return castFailed(); |
466 | /// return doCast(b); |
467 | /// } |
468 | /// }; |
469 | |
470 | // The default implementations of CastInfo don't use cast traits for now because |
471 | // we need to specify types all over the place due to the current expected |
472 | // casting behavior and the way cast_retty works. New use cases can and should |
473 | // take advantage of the cast traits whenever possible! |
474 | |
475 | template <typename To, typename From, typename Enable = void> |
476 | struct CastInfo : public CastIsPossible<To, From> { |
477 | using Self = CastInfo<To, From, Enable>; |
478 | |
479 | using CastReturnType = typename cast_retty<To, From>::ret_type; |
480 | |
481 | static inline CastReturnType doCast(const From &f) { |
482 | return cast_convert_val< |
483 | To, From, |
484 | typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f)); |
485 | } |
486 | |
487 | // This assumes that you can construct the cast return type from `nullptr`. |
488 | // This is largely to support legacy use cases - if you don't want this |
489 | // behavior you should specialize CastInfo for your use case. |
490 | static inline CastReturnType castFailed() { return CastReturnType(nullptr); } |
491 | |
492 | static inline CastReturnType doCastIfPossible(const From &f) { |
493 | if (!Self::isPossible(f)) |
494 | return castFailed(); |
495 | return doCast(f); |
496 | } |
497 | }; |
498 | |
499 | /// This struct provides an overload for CastInfo where From has simplify_type |
500 | /// defined. This simply forwards to the appropriate CastInfo with the |
501 | /// simplified type/value, so you don't have to implement both. |
502 | template <typename To, typename From> |
503 | struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> { |
504 | using Self = CastInfo<To, From>; |
505 | using SimpleFrom = typename simplify_type<From>::SimpleType; |
506 | using SimplifiedSelf = CastInfo<To, SimpleFrom>; |
507 | |
508 | static inline bool isPossible(From &f) { |
509 | return SimplifiedSelf::isPossible( |
510 | simplify_type<From>::getSimplifiedValue(f)); |
511 | } |
512 | |
513 | static inline decltype(auto) doCast(From &f) { |
514 | return SimplifiedSelf::doCast(simplify_type<From>::getSimplifiedValue(f)); |
515 | } |
516 | |
517 | static inline decltype(auto) castFailed() { |
518 | return SimplifiedSelf::castFailed(); |
519 | } |
520 | |
521 | static inline decltype(auto) doCastIfPossible(From &f) { |
522 | return SimplifiedSelf::doCastIfPossible( |
523 | simplify_type<From>::getSimplifiedValue(f)); |
524 | } |
525 | }; |
526 | |
527 | //===----------------------------------------------------------------------===// |
528 | // Pre-specialized CastInfo |
529 | //===----------------------------------------------------------------------===// |
530 | |
531 | /// Provide a CastInfo specialized for std::unique_ptr. |
532 | template <typename To, typename From> |
533 | struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {}; |
534 | |
535 | /// Provide a CastInfo specialized for std::optional<From>. It's assumed that if |
536 | /// the input is std::optional<From> that the output can be std::optional<To>. |
537 | /// If that's not the case, specialize CastInfo for your use case. |
538 | template <typename To, typename From> |
539 | struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> { |
540 | }; |
541 | |
542 | /// isa<X> - Return true if the parameter to the template is an instance of one |
543 | /// of the template type arguments. Used like this: |
544 | /// |
545 | /// if (isa<Type>(myVal)) { ... } |
546 | /// if (isa<Type0, Type1, Type2>(myVal)) { ... } |
547 | template <typename To, typename From> |
548 | [[nodiscard]] inline bool isa(const From &Val) { |
549 | return CastInfo<To, const From>::isPossible(Val); |
550 | } |
551 | |
552 | template <typename First, typename Second, typename... Rest, typename From> |
553 | [[nodiscard]] inline bool isa(const From &Val) { |
554 | return isa<First>(Val) || isa<Second, Rest...>(Val); |
555 | } |
556 | |
557 | /// cast<X> - Return the argument parameter cast to the specified type. This |
558 | /// casting operator asserts that the type is correct, so it does not return |
559 | /// null on failure. It does not allow a null argument (use cast_if_present for |
560 | /// that). It is typically used like this: |
561 | /// |
562 | /// cast<Instruction>(myVal)->getParent() |
563 | |
564 | template <typename To, typename From> |
565 | [[nodiscard]] inline decltype(auto) cast(const From &Val) { |
566 | assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!" ); |
567 | return CastInfo<To, const From>::doCast(Val); |
568 | } |
569 | |
570 | template <typename To, typename From> |
571 | [[nodiscard]] inline decltype(auto) cast(From &Val) { |
572 | assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!" ); |
573 | return CastInfo<To, From>::doCast(Val); |
574 | } |
575 | |
576 | template <typename To, typename From> |
577 | [[nodiscard]] inline decltype(auto) cast(From *Val) { |
578 | assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!" ); |
579 | return CastInfo<To, From *>::doCast(Val); |
580 | } |
581 | |
582 | template <typename To, typename From> |
583 | [[nodiscard]] inline decltype(auto) cast(std::unique_ptr<From> &&Val) { |
584 | assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!" ); |
585 | return CastInfo<To, std::unique_ptr<From>>::doCast(std::move(Val)); |
586 | } |
587 | |
588 | //===----------------------------------------------------------------------===// |
589 | // ValueIsPresent |
590 | //===----------------------------------------------------------------------===// |
591 | |
592 | template <typename T> |
593 | constexpr bool IsNullable = |
594 | std::is_pointer_v<T> || std::is_constructible_v<T, std::nullptr_t>; |
595 | |
596 | /// ValueIsPresent provides a way to check if a value is, well, present. For |
597 | /// pointers, this is the equivalent of checking against nullptr, for Optionals |
598 | /// this is the equivalent of checking hasValue(). It also provides a method for |
599 | /// unwrapping a value (think calling .value() on an optional). |
600 | |
601 | // Generic values can't *not* be present. |
602 | template <typename T, typename Enable = void> struct ValueIsPresent { |
603 | using UnwrappedType = T; |
604 | static inline bool isPresent(const T &t) { return true; } |
605 | static inline decltype(auto) unwrapValue(T &t) { return t; } |
606 | }; |
607 | |
608 | // Optional provides its own way to check if something is present. |
609 | template <typename T> struct ValueIsPresent<std::optional<T>> { |
610 | using UnwrappedType = T; |
611 | static inline bool isPresent(const std::optional<T> &t) { |
612 | return t.has_value(); |
613 | } |
614 | static inline decltype(auto) unwrapValue(std::optional<T> &t) { return *t; } |
615 | }; |
616 | |
617 | // If something is "nullable" then we just compare it to nullptr to see if it |
618 | // exists. |
619 | template <typename T> |
620 | struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> { |
621 | using UnwrappedType = T; |
622 | static inline bool isPresent(const T &t) { return t != T(nullptr); } |
623 | static inline decltype(auto) unwrapValue(T &t) { return t; } |
624 | }; |
625 | |
626 | namespace detail { |
627 | // Convenience function we can use to check if a value is present. Because of |
628 | // simplify_type, we have to call it on the simplified type for now. |
629 | template <typename T> inline bool isPresent(const T &t) { |
630 | return ValueIsPresent<typename simplify_type<T>::SimpleType>::isPresent( |
631 | simplify_type<T>::getSimplifiedValue(const_cast<T &>(t))); |
632 | } |
633 | |
634 | // Convenience function we can use to unwrap a value. |
635 | template <typename T> inline decltype(auto) unwrapValue(T &t) { |
636 | return ValueIsPresent<T>::unwrapValue(t); |
637 | } |
638 | } // namespace detail |
639 | |
640 | /// dyn_cast<X> - Return the argument parameter cast to the specified type. This |
641 | /// casting operator returns null if the argument is of the wrong type, so it |
642 | /// can be used to test for a type as well as cast if successful. The value |
643 | /// passed in must be present, if not, use dyn_cast_if_present. This should be |
644 | /// used in the context of an if statement like this: |
645 | /// |
646 | /// if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... } |
647 | |
648 | template <typename To, typename From> |
649 | [[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) { |
650 | assert(detail::isPresent(Val) && "dyn_cast on a non-existent value" ); |
651 | return CastInfo<To, const From>::doCastIfPossible(Val); |
652 | } |
653 | |
654 | template <typename To, typename From> |
655 | [[nodiscard]] inline decltype(auto) dyn_cast(From &Val) { |
656 | assert(detail::isPresent(Val) && "dyn_cast on a non-existent value" ); |
657 | return CastInfo<To, From>::doCastIfPossible(Val); |
658 | } |
659 | |
660 | template <typename To, typename From> |
661 | [[nodiscard]] inline decltype(auto) dyn_cast(From *Val) { |
662 | assert(detail::isPresent(Val) && "dyn_cast on a non-existent value" ); |
663 | return CastInfo<To, From *>::doCastIfPossible(Val); |
664 | } |
665 | |
666 | template <typename To, typename From> |
667 | [[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) { |
668 | assert(detail::isPresent(Val) && "dyn_cast on a non-existent value" ); |
669 | return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible( |
670 | std::forward<std::unique_ptr<From> &&>(Val)); |
671 | } |
672 | |
673 | /// isa_and_present<X> - Functionally identical to isa, except that a null value |
674 | /// is accepted. |
675 | template <typename... X, class Y> |
676 | [[nodiscard]] inline bool isa_and_present(const Y &Val) { |
677 | if (!detail::isPresent(Val)) |
678 | return false; |
679 | return isa<X...>(Val); |
680 | } |
681 | |
682 | template <typename... X, class Y> |
683 | [[nodiscard]] inline bool isa_and_nonnull(const Y &Val) { |
684 | return isa_and_present<X...>(Val); |
685 | } |
686 | |
687 | /// cast_if_present<X> - Functionally identical to cast, except that a null |
688 | /// value is accepted. |
689 | template <class X, class Y> |
690 | [[nodiscard]] inline auto cast_if_present(const Y &Val) { |
691 | if (!detail::isPresent(Val)) |
692 | return CastInfo<X, const Y>::castFailed(); |
693 | assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!" ); |
694 | return cast<X>(detail::unwrapValue(Val)); |
695 | } |
696 | |
697 | template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y &Val) { |
698 | if (!detail::isPresent(Val)) |
699 | return CastInfo<X, Y>::castFailed(); |
700 | assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!" ); |
701 | return cast<X>(detail::unwrapValue(Val)); |
702 | } |
703 | |
704 | template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y *Val) { |
705 | if (!detail::isPresent(Val)) |
706 | return CastInfo<X, Y *>::castFailed(); |
707 | assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!" ); |
708 | return cast<X>(detail::unwrapValue(Val)); |
709 | } |
710 | |
711 | template <class X, class Y> |
712 | [[nodiscard]] inline auto cast_if_present(std::unique_ptr<Y> &&Val) { |
713 | if (!detail::isPresent(Val)) |
714 | return UniquePtrCast<X, Y>::castFailed(); |
715 | return UniquePtrCast<X, Y>::doCast(std::move(Val)); |
716 | } |
717 | |
718 | // Provide a forwarding from cast_or_null to cast_if_present for current |
719 | // users. This is deprecated and will be removed in a future patch, use |
720 | // cast_if_present instead. |
721 | template <class X, class Y> auto cast_or_null(const Y &Val) { |
722 | return cast_if_present<X>(Val); |
723 | } |
724 | |
725 | template <class X, class Y> auto cast_or_null(Y &Val) { |
726 | return cast_if_present<X>(Val); |
727 | } |
728 | |
729 | template <class X, class Y> auto cast_or_null(Y *Val) { |
730 | return cast_if_present<X>(Val); |
731 | } |
732 | |
733 | template <class X, class Y> auto cast_or_null(std::unique_ptr<Y> &&Val) { |
734 | return cast_if_present<X>(std::move(Val)); |
735 | } |
736 | |
737 | /// dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a |
738 | /// null (or none in the case of optionals) value is accepted. |
739 | template <class X, class Y> auto dyn_cast_if_present(const Y &Val) { |
740 | if (!detail::isPresent(Val)) |
741 | return CastInfo<X, const Y>::castFailed(); |
742 | return CastInfo<X, const Y>::doCastIfPossible(detail::unwrapValue(Val)); |
743 | } |
744 | |
745 | template <class X, class Y> auto dyn_cast_if_present(Y &Val) { |
746 | if (!detail::isPresent(Val)) |
747 | return CastInfo<X, Y>::castFailed(); |
748 | return CastInfo<X, Y>::doCastIfPossible(detail::unwrapValue(Val)); |
749 | } |
750 | |
751 | template <class X, class Y> auto dyn_cast_if_present(Y *Val) { |
752 | if (!detail::isPresent(Val)) |
753 | return CastInfo<X, Y *>::castFailed(); |
754 | return CastInfo<X, Y *>::doCastIfPossible(detail::unwrapValue(Val)); |
755 | } |
756 | |
757 | // Forwards to dyn_cast_if_present to avoid breaking current users. This is |
758 | // deprecated and will be removed in a future patch, use |
759 | // cast_if_present instead. |
760 | template <class X, class Y> auto dyn_cast_or_null(const Y &Val) { |
761 | return dyn_cast_if_present<X>(Val); |
762 | } |
763 | |
764 | template <class X, class Y> auto dyn_cast_or_null(Y &Val) { |
765 | return dyn_cast_if_present<X>(Val); |
766 | } |
767 | |
768 | template <class X, class Y> auto dyn_cast_or_null(Y *Val) { |
769 | return dyn_cast_if_present<X>(Val); |
770 | } |
771 | |
772 | /// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>, |
773 | /// taking ownership of the input pointer iff isa<X>(Val) is true. If the |
774 | /// cast is successful, From refers to nullptr on exit and the casted value |
775 | /// is returned. If the cast is unsuccessful, the function returns nullptr |
776 | /// and From is unchanged. |
777 | template <class X, class Y> |
778 | [[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType |
779 | unique_dyn_cast(std::unique_ptr<Y> &Val) { |
780 | if (!isa<X>(Val)) |
781 | return nullptr; |
782 | return cast<X>(std::move(Val)); |
783 | } |
784 | |
785 | template <class X, class Y> |
786 | [[nodiscard]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) { |
787 | return unique_dyn_cast<X, Y>(Val); |
788 | } |
789 | |
790 | // unique_dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, |
791 | // except that a null value is accepted. |
792 | template <class X, class Y> |
793 | [[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType |
794 | unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) { |
795 | if (!Val) |
796 | return nullptr; |
797 | return unique_dyn_cast<X, Y>(Val); |
798 | } |
799 | |
800 | template <class X, class Y> |
801 | [[nodiscard]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) { |
802 | return unique_dyn_cast_or_null<X, Y>(Val); |
803 | } |
804 | |
805 | } // end namespace llvm |
806 | |
807 | #endif // LLVM_SUPPORT_CASTING_H |
808 | |