clang  3.7.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>
189  return x.getAsOpaquePtr() == y.getAsOpaquePtr();
190 }
191 
192 template<typename T, typename U>
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> {
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> {
452  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Expr *, getSizeExpr)
454 };
455 
456 template<>
457 struct CanProxyAdaptor<VectorType> : public CanProxyBase<VectorType> {
459  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)
460 };
461 
462 template<>
463 struct CanProxyAdaptor<ExtVectorType> : public CanProxyBase<ExtVectorType> {
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  CanQualType getParamType(unsigned i) const {
489  }
490 
491  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariadic)
492  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getTypeQuals)
493 
494  typedef CanTypeIterator<FunctionProtoType::param_type_iterator>
496 
497  param_type_iterator param_type_begin() const {
498  return param_type_iterator(this->getTypePtr()->param_type_begin());
499  }
500 
502  return param_type_iterator(this->getTypePtr()->param_type_end());
503  }
504 
505  // Note: canonical function types never have exception specifications
506 };
507 
508 template<>
509 struct CanProxyAdaptor<TypeOfType> : public CanProxyBase<TypeOfType> {
511 };
512 
513 template<>
514 struct CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
515  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Expr *, getUnderlyingExpr)
517 };
518 
519 template <>
521  : public CanProxyBase<UnaryTransformType> {
525 };
526 
527 template<>
528 struct CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
530  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
531 };
532 
533 template<>
534 struct CanProxyAdaptor<RecordType> : public CanProxyBase<RecordType> {
536  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
537  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasConstFields)
538 };
539 
540 template<>
541 struct CanProxyAdaptor<EnumType> : public CanProxyBase<EnumType> {
543  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
544 };
545 
546 template<>
548  : public CanProxyBase<TemplateTypeParmType> {
549  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getDepth)
550  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getIndex)
551  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isParameterPack)
554 };
555 
556 template<>
558  : public CanProxyBase<ObjCObjectType> {
561  getInterface)
562  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedId)
563  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedClass)
564  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedId)
565  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClass)
566 
567  typedef ObjCObjectPointerType::qual_iterator qual_iterator;
568  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)
569  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)
570  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)
571  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)
572 };
573 
574 template<>
576  : public CanProxyBase<ObjCObjectPointerType> {
577  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
579  getInterfaceType)
580  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCIdType)
581  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCClassType)
582  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedIdType)
583  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClassType)
584 
585  typedef ObjCObjectPointerType::qual_iterator qual_iterator;
586  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)
587  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)
588  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)
589  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)
590 };
591 
592 //----------------------------------------------------------------------------//
593 // Method and function definitions
594 //----------------------------------------------------------------------------//
595 template<typename T>
597  return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType());
598 }
599 
600 template<typename T>
602  if (CanQual<ReferenceType> RefType = getAs<ReferenceType>())
603  return RefType->getPointeeType();
604  else
605  return *this;
606 }
607 
608 template<typename T>
611  Result.Stored = QualType::getFromOpaquePtr(Ptr);
612  assert((!Result || Result.Stored.getAsOpaquePtr() == (void*)-1 ||
613  Result.Stored.isCanonical()) && "Type is not canonical!");
614  return Result;
615 }
616 
617 template<typename T>
619  assert((Other.isNull() || Other.isCanonical()) && "Type is not canonical!");
620  assert((Other.isNull() || isa<T>(Other.getTypePtr())) &&
621  "Dynamic type does not meet the static type's requires");
623  Result.Stored = Other;
624  return Result;
625 }
626 
627 template<typename T>
628 template<typename U>
631  (void)at;
632 
633  if (Stored.isNull())
634  return CanProxy<U>();
635 
636  if (isa<U>(Stored.getTypePtr()))
637  return CanQual<U>::CreateUnsafe(Stored);
638 
639  return CanProxy<U>();
640 }
641 
642 template<typename T>
643 template<typename U>
646  (void)at;
647 
648  assert(!Stored.isNull() && isa<U>(Stored.getTypePtr()));
649  return CanQual<U>::CreateUnsafe(Stored);
650 }
651 
652 template<typename T>
654  return CanProxy<T>(*this);
655 }
656 
657 template <typename InputIterator>
659  return CanProxy<Type>(*this);
660 }
661 
662 }
663 
664 
665 #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:5035
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:5169
bool isCanonicalAsParam() const
Determines if this canonical type is furthermore canonical as a parameter. The parameter-canonicaliza...
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.
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:650
static clang::CanQual< T > getFromVoidPointer(void *P)
CanProxy(CanQual< T > Stored)
Build a proxy to the given canonical type.
CanTypeIterator(InputIterator Iter)
unsigned getCVRQualifiers() const
Retrieve the const/volatile/restrict qualifiers.
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:154
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:614
CanProxy< U > getAs() const
Try to convert the given canonical type to a specific structural type.
bool isCanonical() const
Definition: Type.h:5060
CanProxy()
Build a NULL proxy.
void dump(const char *s) const
Definition: ASTDumper.cpp:2286
QualType withConst() const
Retrieves a version of this type with const applied. Note that this does not always yield a canonical...
static void * getAsVoidPointer(clang::CanQual< T > P)
ObjCObjectType::qual_iterator qual_iterator
Definition: Type.h:4900
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:660
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:851
QualType getCanonicalTypeInternal() const
Definition: Type.h:1951
const T * getTypePtrOrNull() const
Retrieve the underlying type pointer, which refers to a canonical type, or NULL.
Definition: CanonicalType.h:75
AnnotatingParser & P
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:866
CanQualType getCanonicalTypeUnqualified() const
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition: Type.h:5159
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:670
SplitQualType split() const
Definition: Type.h:5024
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:5020
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:640
#define bool
Definition: stdbool.h:31
DecltypeType (C++0x)
Definition: Type.h:3422
A unary type transform, which is a type constructed from another.
Definition: Type.h:3463
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)
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:695
bool isVolatileQualified() const
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
const Type * getTypePtr() const
Definition: Type.h:5016
TypeOfType (GCC extension).
Definition: Type.h:3398
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
static QualType getUnderlyingType(const SubRegion *R)
QualType withConst() const
Definition: Type.h:736
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)
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:615
CanQual< Type > getNonReferenceType() const
If the canonical type is a reference type, returns the type that it refers to; otherwise, returns the type itself.
static const Type * getElementType(const Expr *BaseExpr)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
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...
bool isCanonicalAsParam() const
Definition: Type.h:5064
CanProxy< T > operator->() const
Overloaded arrow operator that produces a canonical type proxy.
bool hasQualifiers() const
Determines whether this type has any qualifiers.
static CanQual< T > getFromOpaquePtr(void *Ptr)
Construct a canonical type from its internal representation.
bool isRestrictQualified() const
static __inline__ uint32_t uint32_t y
Definition: arm_acle.h:113
CanProxy< Type > operator->() const
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
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
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)
Get the type of the Nth parameter from a given set of overload candidates.