clang  3.9.0
CanonicalType.h
Go to the documentation of this file.
1 //===-- CanonicalType.h - C Language Family Type Representation -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the CanQual class template, which provides access to
11 // canonical types.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_AST_CANONICALTYPE_H
16 #define LLVM_CLANG_AST_CANONICALTYPE_H
17 
18 #include "clang/AST/Type.h"
19 #include "llvm/ADT/iterator.h"
20 #include "llvm/Support/Casting.h"
21 
22 namespace clang {
23 
24 template<typename T> class CanProxy;
25 template<typename T> struct CanProxyAdaptor;
26 
27 //----------------------------------------------------------------------------//
28 // Canonical, qualified type template
29 //----------------------------------------------------------------------------//
30 
31 /// \brief Represents a canonical, potentially-qualified type.
32 ///
33 /// The CanQual template is a lightweight smart pointer that provides access
34 /// to the canonical representation of a type, where all typedefs and other
35 /// syntactic sugar has been eliminated. A CanQualType may also have various
36 /// qualifiers (const, volatile, restrict) attached to it.
37 ///
38 /// The template type parameter @p T is one of the Type classes (PointerType,
39 /// BuiltinType, etc.). The type stored within @c CanQual<T> will be of that
40 /// type (or some subclass of that type). The typedef @c CanQualType is just
41 /// a shorthand for @c CanQual<Type>.
42 ///
43 /// An instance of @c CanQual<T> can be implicitly converted to a
44 /// @c CanQual<U> when T is derived from U, which essentially provides an
45 /// implicit upcast. For example, @c CanQual<LValueReferenceType> can be
46 /// converted to @c CanQual<ReferenceType>. Note that any @c CanQual type can
47 /// be implicitly converted to a QualType, but the reverse operation requires
48 /// a call to ASTContext::getCanonicalType().
49 ///
50 ///
51 template<typename T = Type>
52 class CanQual {
53  /// \brief The actual, canonical type.
54  QualType Stored;
55 
56 public:
57  /// \brief Constructs a NULL canonical type.
58  CanQual() : Stored() { }
59 
60  /// \brief Converting constructor that permits implicit upcasting of
61  /// canonical type pointers.
62  template <typename U>
63  CanQual(const CanQual<U> &Other,
64  typename std::enable_if<std::is_base_of<T, U>::value, int>::type = 0);
65 
66  /// \brief Retrieve the underlying type pointer, which refers to a
67  /// canonical type.
68  ///
69  /// The underlying pointer must not be NULL.
70  const T *getTypePtr() const { return cast<T>(Stored.getTypePtr()); }
71 
72  /// \brief Retrieve the underlying type pointer, which refers to a
73  /// canonical type, or NULL.
74  ///
75  const T *getTypePtrOrNull() const {
76  return cast_or_null<T>(Stored.getTypePtrOrNull());
77  }
78 
79  /// \brief Implicit conversion to a qualified type.
80  operator QualType() const { return Stored; }
81 
82  /// \brief Implicit conversion to bool.
83  explicit operator bool() const { return !isNull(); }
84 
85  bool isNull() const {
86  return Stored.isNull();
87  }
88 
89  SplitQualType split() const { return Stored.split(); }
90 
91  /// \brief Retrieve a canonical type pointer with a different static type,
92  /// upcasting or downcasting as needed.
93  ///
94  /// The getAs() function is typically used to try to downcast to a
95  /// more specific (canonical) type in the type system. For example:
96  ///
97  /// @code
98  /// void f(CanQual<Type> T) {
99  /// if (CanQual<PointerType> Ptr = T->getAs<PointerType>()) {
100  /// // look at Ptr's pointee type
101  /// }
102  /// }
103  /// @endcode
104  ///
105  /// \returns A proxy pointer to the same type, but with the specified
106  /// static type (@p U). If the dynamic type is not the specified static type
107  /// or a derived class thereof, a NULL canonical type.
108  template<typename U> CanProxy<U> getAs() const;
109 
110  template<typename U> CanProxy<U> castAs() const;
111 
112  /// \brief Overloaded arrow operator that produces a canonical type
113  /// proxy.
114  CanProxy<T> operator->() const;
115 
116  /// \brief Retrieve all qualifiers.
117  Qualifiers getQualifiers() const { return Stored.getLocalQualifiers(); }
118 
119  /// \brief Retrieve the const/volatile/restrict qualifiers.
120  unsigned getCVRQualifiers() const { return Stored.getLocalCVRQualifiers(); }
121 
122  /// \brief Determines whether this type has any qualifiers
123  bool hasQualifiers() const { return Stored.hasLocalQualifiers(); }
124 
125  bool isConstQualified() const {
126  return Stored.isLocalConstQualified();
127  }
128  bool isVolatileQualified() const {
129  return Stored.isLocalVolatileQualified();
130  }
131  bool isRestrictQualified() const {
132  return Stored.isLocalRestrictQualified();
133  }
134 
135  /// \brief Determines if this canonical type is furthermore
136  /// canonical as a parameter. The parameter-canonicalization
137  /// process decays arrays to pointers and drops top-level qualifiers.
138  bool isCanonicalAsParam() const {
139  return Stored.isCanonicalAsParam();
140  }
141 
142  /// \brief Retrieve the unqualified form of this type.
144 
145  /// \brief Retrieves a version of this type with const applied.
146  /// Note that this does not always yield a canonical type.
147  QualType withConst() const {
148  return Stored.withConst();
149  }
150 
151  /// \brief Determines whether this canonical type is more qualified than
152  /// the @p Other canonical type.
153  bool isMoreQualifiedThan(CanQual<T> Other) const {
154  return Stored.isMoreQualifiedThan(Other.Stored);
155  }
156 
157  /// \brief Determines whether this canonical type is at least as qualified as
158  /// the @p Other canonical type.
159  bool isAtLeastAsQualifiedAs(CanQual<T> Other) const {
160  return Stored.isAtLeastAsQualifiedAs(Other.Stored);
161  }
162 
163  /// \brief If the canonical type is a reference type, returns the type that
164  /// it refers to; otherwise, returns the type itself.
166 
167  /// \brief Retrieve the internal representation of this canonical type.
168  void *getAsOpaquePtr() const { return Stored.getAsOpaquePtr(); }
169 
170  /// \brief Construct a canonical type from its internal representation.
171  static CanQual<T> getFromOpaquePtr(void *Ptr);
172 
173  /// \brief Builds a canonical type from a QualType.
174  ///
175  /// This routine is inherently unsafe, because it requires the user to
176  /// ensure that the given type is a canonical type with the correct
177  // (dynamic) type.
178  static CanQual<T> CreateUnsafe(QualType Other);
179 
180  void dump() const { Stored.dump(); }
181 
182  void Profile(llvm::FoldingSetNodeID &ID) const {
183  ID.AddPointer(getAsOpaquePtr());
184  }
185 };
186 
187 template<typename T, typename U>
188 inline bool operator==(CanQual<T> x, CanQual<U> y) {
189  return x.getAsOpaquePtr() == y.getAsOpaquePtr();
190 }
191 
192 template<typename T, typename U>
193 inline bool operator!=(CanQual<T> x, CanQual<U> y) {
194  return x.getAsOpaquePtr() != y.getAsOpaquePtr();
195 }
196 
197 /// \brief Represents a canonical, potentially-qualified type.
199 
202 }
203 
205  CanQualType T) {
206  DB << static_cast<QualType>(T);
207  return DB;
208 }
209 
210 //----------------------------------------------------------------------------//
211 // Internal proxy classes used by canonical types
212 //----------------------------------------------------------------------------//
213 
214 #define LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(Accessor) \
215 CanQualType Accessor() const { \
216 return CanQualType::CreateUnsafe(this->getTypePtr()->Accessor()); \
217 }
218 
219 #define LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type, Accessor) \
220 Type Accessor() const { return this->getTypePtr()->Accessor(); }
221 
222 /// \brief Base class of all canonical proxy types, which is responsible for
223 /// storing the underlying canonical type and providing basic conversions.
224 template<typename T>
226 protected:
228 
229 public:
230  /// \brief Retrieve the pointer to the underlying Type
231  const T *getTypePtr() const { return Stored.getTypePtr(); }
232 
233  /// \brief Implicit conversion to the underlying pointer.
234  ///
235  /// Also provides the ability to use canonical type proxies in a Boolean
236  // context,e.g.,
237  /// @code
238  /// if (CanQual<PointerType> Ptr = T->getAs<PointerType>()) { ... }
239  /// @endcode
240  operator const T*() const { return this->Stored.getTypePtrOrNull(); }
241 
242  /// \brief Try to convert the given canonical type to a specific structural
243  /// type.
244  template<typename U> CanProxy<U> getAs() const {
245  return this->Stored.template getAs<U>();
246  }
247 
249 
250  // Type predicates
251  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjectType)
252  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteType)
253  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteOrObjectType)
254  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariablyModifiedType)
255  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegerType)
256  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isEnumeralType)
259  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isWideCharType)
260  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegralType)
261  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegralOrEnumerationType)
262  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isRealFloatingType)
263  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isComplexType)
264  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAnyComplexType)
265  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isFloatingType)
266  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isRealType)
267  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isArithmeticType)
268  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVoidType)
269  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isDerivedType)
270  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isScalarType)
271  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAggregateType)
272  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAnyPointerType)
273  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVoidPointerType)
274  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isFunctionPointerType)
275  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isMemberFunctionPointerType)
276  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isClassType)
277  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isStructureType)
278  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isInterfaceType)
279  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isStructureOrClassType)
280  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnionType)
281  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isComplexIntegerType)
282  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isNullPtrType)
283  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isDependentType)
284  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isOverloadableType)
285  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isArrayType)
286  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasPointerRepresentation)
287  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasObjCPointerRepresentation)
288  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasIntegerRepresentation)
289  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasSignedIntegerRepresentation)
290  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasUnsignedIntegerRepresentation)
291  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasFloatingRepresentation)
292  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isPromotableIntegerType)
293  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSignedIntegerType)
294  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnsignedIntegerType)
295  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSignedIntegerOrEnumerationType)
296  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnsignedIntegerOrEnumerationType)
297  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isConstantSizeType)
298  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSpecifierType)
300 
301  /// \brief Retrieve the proxy-adaptor type.
302  ///
303  /// This arrow operator is used when CanProxyAdaptor has been specialized
304  /// for the given type T. In that case, we reference members of the
305  /// CanProxyAdaptor specialization. Otherwise, this operator will be hidden
306  /// by the arrow operator in the primary CanProxyAdaptor template.
307  const CanProxyAdaptor<T> *operator->() const {
308  return static_cast<const CanProxyAdaptor<T> *>(this);
309  }
310 };
311 
312 /// \brief Replacable canonical proxy adaptor class that provides the link
313 /// between a canonical type and the accessors of the type.
314 ///
315 /// The CanProxyAdaptor is a replaceable class template that is instantiated
316 /// as part of each canonical proxy type. The primary template merely provides
317 /// redirection to the underlying type (T), e.g., @c PointerType. One can
318 /// provide specializations of this class template for each underlying type
319 /// that provide accessors returning canonical types (@c CanQualType) rather
320 /// than the more typical @c QualType, to propagate the notion of "canonical"
321 /// through the system.
322 template<typename T>
323 struct CanProxyAdaptor : CanProxyBase<T> { };
324 
325 /// \brief Canonical proxy type returned when retrieving the members of a
326 /// canonical type or as the result of the @c CanQual<T>::getAs member
327 /// function.
328 ///
329 /// The CanProxy type mainly exists as a proxy through which operator-> will
330 /// look to either map down to a raw T* (e.g., PointerType*) or to a proxy
331 /// type that provides canonical-type access to the fields of the type.
332 template<typename T>
333 class CanProxy : public CanProxyAdaptor<T> {
334 public:
335  /// \brief Build a NULL proxy.
336  CanProxy() { }
337 
338  /// \brief Build a proxy to the given canonical type.
339  CanProxy(CanQual<T> Stored) { this->Stored = Stored; }
340 
341  /// \brief Implicit conversion to the stored canonical type.
342  operator CanQual<T>() const { return this->Stored; }
343 };
344 
345 } // end namespace clang
346 
347 namespace llvm {
348 
349 /// Implement simplify_type for CanQual<T>, so that we can dyn_cast from
350 /// CanQual<T> to a specific Type class. We're prefer isa/dyn_cast/cast/etc.
351 /// to return smart pointer (proxies?).
352 template<typename T>
353 struct simplify_type< ::clang::CanQual<T> > {
354  typedef const T *SimpleType;
356  return Val.getTypePtr();
357  }
358 };
359 
360 // Teach SmallPtrSet that CanQual<T> is "basically a pointer".
361 template<typename T>
362 class PointerLikeTypeTraits<clang::CanQual<T> > {
363 public:
364  static inline void *getAsVoidPointer(clang::CanQual<T> P) {
365  return P.getAsOpaquePtr();
366  }
367  static inline clang::CanQual<T> getFromVoidPointer(void *P) {
369  }
370  // qualifier information is encoded in the low bits.
371  enum { NumLowBitsAvailable = 0 };
372 };
373 
374 } // end namespace llvm
375 
376 namespace clang {
377 
378 //----------------------------------------------------------------------------//
379 // Canonical proxy adaptors for canonical type nodes.
380 //----------------------------------------------------------------------------//
381 
382 /// \brief Iterator adaptor that turns an iterator over canonical QualTypes
383 /// into an iterator over CanQualTypes.
384 template <typename InputIterator>
386  : llvm::iterator_adaptor_base<
387  CanTypeIterator<InputIterator>, InputIterator,
388  typename std::iterator_traits<InputIterator>::iterator_category,
389  CanQualType,
390  typename std::iterator_traits<InputIterator>::difference_type,
391  CanProxy<Type>, CanQualType> {
393  explicit CanTypeIterator(InputIterator Iter)
394  : CanTypeIterator::iterator_adaptor_base(std::move(Iter)) {}
395 
396  CanQualType operator*() const { return CanQualType::CreateUnsafe(*this->I); }
397  CanProxy<Type> operator->() const;
398 };
399 
400 template<>
401 struct CanProxyAdaptor<ComplexType> : public CanProxyBase<ComplexType> {
402  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
403 };
404 
405 template<>
406 struct CanProxyAdaptor<PointerType> : public CanProxyBase<PointerType> {
407  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
408 };
409 
410 template<>
412  : public CanProxyBase<BlockPointerType> {
413  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
414 };
415 
416 template<>
417 struct CanProxyAdaptor<ReferenceType> : public CanProxyBase<ReferenceType> {
418  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
419 };
420 
421 template<>
423  : public CanProxyBase<LValueReferenceType> {
424  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
425 };
426 
427 template<>
429  : public CanProxyBase<RValueReferenceType> {
430  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
431 };
432 
433 template<>
435  : public CanProxyBase<MemberPointerType> {
436  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
437  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Type *, getClass)
438 };
439 
440 // CanProxyAdaptors for arrays are intentionally unimplemented because
441 // they are not safe.
442 template<> struct CanProxyAdaptor<ArrayType>;
443 template<> struct CanProxyAdaptor<ConstantArrayType>;
444 template<> struct CanProxyAdaptor<IncompleteArrayType>;
445 template<> struct CanProxyAdaptor<VariableArrayType>;
446 template<> struct CanProxyAdaptor<DependentSizedArrayType>;
447 
448 template<>
450  : public CanProxyBase<DependentSizedExtVectorType> {
451  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
452  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Expr *, getSizeExpr)
454 };
455 
456 template<>
457 struct CanProxyAdaptor<VectorType> : public CanProxyBase<VectorType> {
458  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
459  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)
460 };
461 
462 template<>
463 struct CanProxyAdaptor<ExtVectorType> : public CanProxyBase<ExtVectorType> {
464  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
465  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)
466 };
467 
468 template<>
469 struct CanProxyAdaptor<FunctionType> : public CanProxyBase<FunctionType> {
470  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
472 };
473 
474 template<>
476  : public CanProxyBase<FunctionNoProtoType> {
477  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
479 };
480 
481 template<>
483  : public CanProxyBase<FunctionProtoType> {
484  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
486  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumParams)
487  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasExtParameterInfos)
489  ArrayRef<FunctionProtoType::ExtParameterInfo>, getExtParameterInfos)
490  CanQualType getParamType(unsigned i) const {
492  }
493 
494  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariadic)
495  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getTypeQuals)
496 
497  typedef CanTypeIterator<FunctionProtoType::param_type_iterator>
499 
500  param_type_iterator param_type_begin() const {
501  return param_type_iterator(this->getTypePtr()->param_type_begin());
502  }
503 
505  return param_type_iterator(this->getTypePtr()->param_type_end());
506  }
507 
508  // Note: canonical function types never have exception specifications
509 };
510 
511 template<>
512 struct CanProxyAdaptor<TypeOfType> : public CanProxyBase<TypeOfType> {
514 };
515 
516 template<>
517 struct CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
518  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Expr *, getUnderlyingExpr)
520 };
521 
522 template <>
524  : public CanProxyBase<UnaryTransformType> {
528 };
529 
530 template<>
531 struct CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
533  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
534 };
535 
536 template<>
537 struct CanProxyAdaptor<RecordType> : public CanProxyBase<RecordType> {
539  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
540  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasConstFields)
541 };
542 
543 template<>
544 struct CanProxyAdaptor<EnumType> : public CanProxyBase<EnumType> {
546  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
547 };
548 
549 template<>
551  : public CanProxyBase<TemplateTypeParmType> {
552  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getDepth)
553  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getIndex)
554  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isParameterPack)
557 };
558 
559 template<>
561  : public CanProxyBase<ObjCObjectType> {
564  getInterface)
565  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedId)
566  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedClass)
567  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedId)
568  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClass)
569 
570  typedef ObjCObjectPointerType::qual_iterator qual_iterator;
571  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)
572  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)
573  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)
574  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)
575 };
576 
577 template<>
579  : public CanProxyBase<ObjCObjectPointerType> {
580  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
582  getInterfaceType)
583  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCIdType)
584  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCClassType)
585  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedIdType)
586  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClassType)
587 
588  typedef ObjCObjectPointerType::qual_iterator qual_iterator;
589  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)
590  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)
591  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)
592  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)
593 };
594 
595 //----------------------------------------------------------------------------//
596 // Method and function definitions
597 //----------------------------------------------------------------------------//
598 template<typename T>
600  return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType());
601 }
602 
603 template<typename T>
605  if (CanQual<ReferenceType> RefType = getAs<ReferenceType>())
606  return RefType->getPointeeType();
607  else
608  return *this;
609 }
610 
611 template<typename T>
614  Result.Stored = QualType::getFromOpaquePtr(Ptr);
615  assert((!Result || Result.Stored.getAsOpaquePtr() == (void*)-1 ||
616  Result.Stored.isCanonical()) && "Type is not canonical!");
617  return Result;
618 }
619 
620 template<typename T>
622  assert((Other.isNull() || Other.isCanonical()) && "Type is not canonical!");
623  assert((Other.isNull() || isa<T>(Other.getTypePtr())) &&
624  "Dynamic type does not meet the static type's requires");
626  Result.Stored = Other;
627  return Result;
628 }
629 
630 template<typename T>
631 template<typename U>
634  (void)at;
635 
636  if (Stored.isNull())
637  return CanProxy<U>();
638 
639  if (isa<U>(Stored.getTypePtr()))
640  return CanQual<U>::CreateUnsafe(Stored);
641 
642  return CanProxy<U>();
643 }
644 
645 template<typename T>
646 template<typename U>
649  (void)at;
650 
651  assert(!Stored.isNull() && isa<U>(Stored.getTypePtr()));
652  return CanQual<U>::CreateUnsafe(Stored);
653 }
654 
655 template<typename T>
657  return CanProxy<T>(*this);
658 }
659 
660 template <typename InputIterator>
662  return CanProxy<Type>(*this);
663 }
664 
665 }
666 
667 
668 #endif
static CanQual< T > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
Replacable canonical proxy adaptor class that provides the link between a canonical type and the acce...
Definition: CanonicalType.h:25
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5278
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2179
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:5413
A (possibly-)qualified type.
Definition: Type.h:598
bool isCanonicalAsParam() const
Determines if this canonical type is furthermore canonical as a parameter.
void dump() const
bool operator==(CanQual< T > x, CanQual< U > y)
#define LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(Accessor)
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
bool isLocalRestrictQualified() const
Determine whether this particular QualType instance has the "restrict" qualifier set, without looking through typedefs that may have added "restrict" at a different level.
Definition: Type.h:682
static clang::CanQual< T > getFromVoidPointer(void *P)
CanProxy(CanQual< T > Stored)
Build a proxy to the given canonical type.
C Language Family Type Representation.
StringRef P
CanTypeIterator(InputIterator Iter)
unsigned getCVRQualifiers() const
Retrieve the const/volatile/restrict qualifiers.
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:198
The base class of the type hierarchy.
Definition: Type.h:1281
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
Canonical proxy type returned when retrieving the members of a canonical type or as the result of the...
Definition: CanonicalType.h:24
bool isConstQualified() const
CanProxy< U > castAs() const
void * getAsOpaquePtr() const
Definition: Type.h:646
CanProxy< U > getAs() const
Try to convert the given canonical type to a specific structural type.
bool isCanonical() const
Definition: Type.h:5303
CanProxy()
Build a NULL proxy.
void dump(const char *s) const
Definition: ASTDumper.cpp:2448
The collection of all-type qualifiers we support.
Definition: Type.h:117
QualType withConst() const
Retrieves a version of this type with const applied.
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
One of these records is kept for each identifier that is lexed.
struct ExtInfo & getExtInfo()
Definition: CGCleanup.h:267
Represents a class type in Objective C.
Definition: Type.h:4727
static void * getAsVoidPointer(clang::CanQual< T > P)
ObjCObjectType::qual_iterator qual_iterator
An iterator over the qualifiers on the object type.
Definition: Type.h:5110
bool isLocalVolatileQualified() const
Determine whether this particular QualType instance has the "volatile" qualifier set, without looking through typedefs that may have added "volatile" at a different level.
Definition: Type.h:692
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2383
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
bool isNull() const
Definition: CanonicalType.h:85
static bool isBooleanType(QualType Ty)
SplitQualType split() const
Definition: CanonicalType.h:89
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
detail::InMemoryDirectory::const_iterator I
QualType getCanonicalTypeInternal() const
Definition: Type.h:2001
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2718
const T * getTypePtrOrNull() const
Retrieve the underlying type pointer, which refers to a canonical type, or NULL.
Definition: CanonicalType.h:75
Represents a K&R-style 'int foo()' function, which has no information available about its arguments...
Definition: Type.h:3039
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:873
CanQualType getCanonicalTypeUnqualified() const
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5403
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:702
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2659
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:5267
const T * getTypePtr() const
Retrieve the pointer to the underlying Type.
void * getAsOpaquePtr() const
Retrieve the internal representation of this canonical type.
param_type_iterator param_type_end() const
const Type * getTypePtrOrNull() const
Definition: Type.h:5263
Expr - This represents one expression.
Definition: Expr.h:105
Qualifiers getQualifiers() const
Retrieve all qualifiers.
Declaration of a template type parameter.
bool isLocalConstQualified() const
Determine whether this particular QualType instance has the "const" qualifier set, without looking through typedefs that may have added "const" at a different level.
Definition: Type.h:672
#define bool
Definition: stdbool.h:31
Represents the type decltype(expr) (C++11).
Definition: Type.h:3590
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:541
A unary type transform, which is a type constructed from another.
Definition: Type.h:3631
bool isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type...
static SimpleType getSimplifiedValue(::clang::CanQual< T > Val)
Represents a GCC generic vector type.
Definition: Type.h:2756
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2366
The result type of a method or function.
void Profile(llvm::FoldingSetNodeID &ID) const
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:727
bool isVolatileQualified() const
Encodes a location in the source.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3733
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5259
Represents typeof(type), a GCC extension.
Definition: Type.h:3566
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:4936
const std::string ID
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
static QualType getUnderlyingType(const SubRegion *R)
QualType withConst() const
Definition: Type.h:764
Represents a canonical, potentially-qualified type.
Definition: CanonicalType.h:52
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
CanQual< T > Stored
#define LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type, Accessor)
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4580
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:647
CanQual< Type > getNonReferenceType() const
If the canonical type is a reference type, returns the type that it refers to; otherwise, returns the type itself.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
Iterator adaptor that turns an iterator over canonical QualTypes into an iterator over CanQualTypes...
Base class of all canonical proxy types, which is responsible for storing the underlying canonical ty...
EnumDecl - Represents an enum.
Definition: Decl.h:3013
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2401
bool isCanonicalAsParam() const
Definition: Type.h:5307
CanProxy< T > operator->() const
Overloaded arrow operator that produces a canonical type proxy.
Represents a pointer to an Objective C object.
Definition: Type.h:4991
bool hasQualifiers() const
Determines whether this type has any qualifiers.
Pointer to a block type.
Definition: Type.h:2286
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
Complex values, per C99 6.2.5p11.
Definition: Type.h:2119
static CanQual< T > getFromOpaquePtr(void *Ptr)
Construct a canonical type from its internal representation.
bool isRestrictQualified() const
ExtVectorType - Extended vector type.
Definition: Type.h:2816
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2319
CanProxy< Type > operator->() const
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
Represents a C array with an unspecified size.
Definition: Type.h:2562
bool operator!=(CanQual< T > x, CanQual< U > y)
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:70
static bool isCharType(QualType T)
bool isMoreQualifiedThan(CanQual< T > Other) const
Determines whether this canonical type is more qualified than the Other canonical type...
CanQualType operator*() const
CanQual()
Constructs a NULL canonical type.
Definition: CanonicalType.h:58
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2607
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2512
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2904
static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)
Get the type of the Nth parameter from a given set of overload candidates.