1//===--- TypeLoc.h - Type Source Info Wrapper -------------------*- 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/// \file
11/// \brief Defines the clang::TypeLoc interface and its subclasses.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_TYPELOC_H
16#define LLVM_CLANG_AST_TYPELOC_H
17
18#include "clang/AST/Decl.h"
19#include "clang/AST/TemplateBase.h"
20#include "clang/AST/Type.h"
21#include "clang/Basic/Specifiers.h"
22#include "llvm/Support/Compiler.h"
23
24namespace clang {
25  class ASTContext;
26  class ParmVarDecl;
27  class TypeSourceInfo;
28  class UnqualTypeLoc;
29
30// Predeclare all the type nodes.
31#define ABSTRACT_TYPELOC(Class, Base)
32#define TYPELOC(Class, Base) \
33  class Class##TypeLoc;
34#include "clang/AST/TypeLocNodes.def"
35
36/// \brief Base wrapper for a particular "section" of type source info.
37///
38/// A client should use the TypeLoc subclasses through castAs()/getAs()
39/// in order to get at the actual information.
40class TypeLoc {
41protected:
42  // The correctness of this relies on the property that, for Type *Ty,
43  //   QualType(Ty, 0).getAsOpaquePtr() == (void*) Ty
44  const void *Ty;
45  void *Data;
46
47public:
48  /// \brief Convert to the specified TypeLoc type, asserting that this TypeLoc
49  /// is of the desired type.
50  ///
51  /// \pre T::isKind(*this)
52  template<typename T>
53  T castAs() const {
54    assert(T::isKind(*this));
55    T t;
56    TypeLoc& tl = t;
57    tl = *this;
58    return t;
59  }
60
61  /// \brief Convert to the specified TypeLoc type, returning a null TypeLoc if
62  /// this TypeLoc is not of the desired type.
63  template<typename T>
64  T getAs() const {
65    if (!T::isKind(*this))
66      return T();
67    T t;
68    TypeLoc& tl = t;
69    tl = *this;
70    return t;
71  }
72
73  /// The kinds of TypeLocs.  Equivalent to the Type::TypeClass enum,
74  /// except it also defines a Qualified enum that corresponds to the
75  /// QualifiedLoc class.
76  enum TypeLocClass {
77#define ABSTRACT_TYPE(Class, Base)
78#define TYPE(Class, Base) \
79    Class = Type::Class,
80#include "clang/AST/TypeNodes.def"
81    Qualified
82  };
83
84  TypeLoc() : Ty(nullptr), Data(nullptr) { }
85  TypeLoc(QualType ty, void *opaqueData)
86    : Ty(ty.getAsOpaquePtr()), Data(opaqueData) { }
87  TypeLoc(const Type *ty, void *opaqueData)
88    : Ty(ty), Data(opaqueData) { }
89
90  TypeLocClass getTypeLocClass() const {
91    if (getType().hasLocalQualifiers()) return Qualified;
92    return (TypeLocClass) getType()->getTypeClass();
93  }
94
95  bool isNull() const { return !Ty; }
96  explicit operator bool() const { return Ty; }
97
98  /// \brief Returns the size of type source info data block for the given type.
99  static unsigned getFullDataSizeForType(QualType Ty);
100
101  /// \brief Returns the alignment of type source info data block for
102  /// the given type.
103  static unsigned getLocalAlignmentForType(QualType Ty);
104
105  /// \brief Get the type for which this source info wrapper provides
106  /// information.
107  QualType getType() const {
108    return QualType::getFromOpaquePtr(Ty);
109  }
110
111  const Type *getTypePtr() const {
112    return QualType::getFromOpaquePtr(Ty).getTypePtr();
113  }
114
115  /// \brief Get the pointer where source information is stored.
116  void *getOpaqueData() const {
117    return Data;
118  }
119
120  /// \brief Get the begin source location.
121  SourceLocation getBeginLoc() const;
122
123  /// \brief Get the end source location.
124  SourceLocation getEndLoc() const;
125
126  /// \brief Get the full source range.
127  SourceRange getSourceRange() const LLVM_READONLY {
128    return SourceRange(getBeginLoc(), getEndLoc());
129  }
130  SourceLocation getLocStart() const LLVM_READONLY { return getBeginLoc(); }
131  SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
132
133  /// \brief Get the local source range.
134  SourceRange getLocalSourceRange() const {
135    return getLocalSourceRangeImpl(*this);
136  }
137
138  /// \brief Returns the size of the type source info data block.
139  unsigned getFullDataSize() const {
140    return getFullDataSizeForType(getType());
141  }
142
143  /// \brief Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the
144  /// TypeLoc is a PointerLoc and next TypeLoc is for "int".
145  TypeLoc getNextTypeLoc() const {
146    return getNextTypeLocImpl(*this);
147  }
148
149  /// \brief Skips past any qualifiers, if this is qualified.
150  UnqualTypeLoc getUnqualifiedLoc() const; // implemented in this header
151
152  TypeLoc IgnoreParens() const;
153
154  /// \brief Find a type with the location of an explicit type qualifier.
155  ///
156  /// The result, if non-null, will be one of:
157  ///   QualifiedTypeLoc
158  ///   AtomicTypeLoc
159  ///   AttributedTypeLoc, for those type attributes that behave as qualifiers
160  TypeLoc findExplicitQualifierLoc() const;
161
162  /// \brief Initializes this to state that every location in this
163  /// type is the given location.
164  ///
165  /// This method exists to provide a simple transition for code that
166  /// relies on location-less types.
167  void initialize(ASTContext &Context, SourceLocation Loc) const {
168    initializeImpl(Context, *this, Loc);
169  }
170
171  /// \brief Initializes this by copying its information from another
172  /// TypeLoc of the same type.
173  void initializeFullCopy(TypeLoc Other) {
174    assert(getType() == Other.getType());
175    copy(Other);
176  }
177
178  /// \brief Initializes this by copying its information from another
179  /// TypeLoc of the same type.  The given size must be the full data
180  /// size.
181  void initializeFullCopy(TypeLoc Other, unsigned Size) {
182    assert(getType() == Other.getType());
183    assert(getFullDataSize() == Size);
184    copy(Other);
185  }
186
187  /// Copies the other type loc into this one.
188  void copy(TypeLoc other);
189
190  friend bool operator==(const TypeLoc &LHS, const TypeLoc &RHS) {
191    return LHS.Ty == RHS.Ty && LHS.Data == RHS.Data;
192  }
193
194  friend bool operator!=(const TypeLoc &LHS, const TypeLoc &RHS) {
195    return !(LHS == RHS);
196  }
197
198  /// Find the location of the nullability specifier (__nonnull,
199  /// __nullable, or __null_unspecifier), if there is one.
200  SourceLocation findNullabilityLoc() const;
201
202private:
203  static bool isKind(const TypeLoc&) {
204    return true;
205  }
206
207  static void initializeImpl(ASTContext &Context, TypeLoc TL,
208                             SourceLocation Loc);
209  static TypeLoc getNextTypeLocImpl(TypeLoc TL);
210  static TypeLoc IgnoreParensImpl(TypeLoc TL);
211  static SourceRange getLocalSourceRangeImpl(TypeLoc TL);
212};
213
214/// \brief Return the TypeLoc for a type source info.
215inline TypeLoc TypeSourceInfo::getTypeLoc() const {
216  // TODO: is this alignment already sufficient?
217  return TypeLoc(Ty, const_cast<void*>(static_cast<const void*>(this + 1)));
218}
219
220/// \brief Wrapper of type source information for a type with
221/// no direct qualifiers.
222class UnqualTypeLoc : public TypeLoc {
223public:
224  UnqualTypeLoc() {}
225  UnqualTypeLoc(const Type *Ty, void *Data) : TypeLoc(Ty, Data) {}
226
227  const Type *getTypePtr() const {
228    return reinterpret_cast<const Type*>(Ty);
229  }
230
231  TypeLocClass getTypeLocClass() const {
232    return (TypeLocClass) getTypePtr()->getTypeClass();
233  }
234
235private:
236  friend class TypeLoc;
237  static bool isKind(const TypeLoc &TL) {
238    return !TL.getType().hasLocalQualifiers();
239  }
240};
241
242/// \brief Wrapper of type source information for a type with
243/// non-trivial direct qualifiers.
244///
245/// Currently, we intentionally do not provide source location for
246/// type qualifiers.
247class QualifiedTypeLoc : public TypeLoc {
248public:
249  SourceRange getLocalSourceRange() const {
250    return SourceRange();
251  }
252
253  UnqualTypeLoc getUnqualifiedLoc() const {
254    unsigned align =
255        TypeLoc::getLocalAlignmentForType(QualType(getTypePtr(), 0));
256    uintptr_t dataInt = reinterpret_cast<uintptr_t>(Data);
257    dataInt = llvm::RoundUpToAlignment(dataInt, align);
258    return UnqualTypeLoc(getTypePtr(), reinterpret_cast<void*>(dataInt));
259  }
260
261  /// Initializes the local data of this type source info block to
262  /// provide no information.
263  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
264    // do nothing
265  }
266
267  void copyLocal(TypeLoc other) {
268    // do nothing
269  }
270
271  TypeLoc getNextTypeLoc() const {
272    return getUnqualifiedLoc();
273  }
274
275  /// \brief Returns the size of the type source info data block that is
276  /// specific to this type.
277  unsigned getLocalDataSize() const {
278    // In fact, we don't currently preserve any location information
279    // for qualifiers.
280    return 0;
281  }
282
283  /// \brief Returns the alignment of the type source info data block that is
284  /// specific to this type.
285  unsigned getLocalDataAlignment() const {
286    // We don't preserve any location information.
287    return 1;
288  }
289
290private:
291  friend class TypeLoc;
292  static bool isKind(const TypeLoc &TL) {
293    return TL.getType().hasLocalQualifiers();
294  }
295};
296
297inline UnqualTypeLoc TypeLoc::getUnqualifiedLoc() const {
298  if (QualifiedTypeLoc Loc = getAs<QualifiedTypeLoc>())
299    return Loc.getUnqualifiedLoc();
300  return castAs<UnqualTypeLoc>();
301}
302
303/// A metaprogramming base class for TypeLoc classes which correspond
304/// to a particular Type subclass.  It is accepted for a single
305/// TypeLoc class to correspond to multiple Type classes.
306///
307/// \tparam Base a class from which to derive
308/// \tparam Derived the class deriving from this one
309/// \tparam TypeClass the concrete Type subclass associated with this
310///   location type
311/// \tparam LocalData the structure type of local location data for
312///   this type
313///
314/// TypeLocs with non-constant amounts of local data should override
315/// getExtraLocalDataSize(); getExtraLocalData() will then point to
316/// this extra memory.
317///
318/// TypeLocs with an inner type should define
319///   QualType getInnerType() const
320/// and getInnerTypeLoc() will then point to this inner type's
321/// location data.
322///
323/// A word about hierarchies: this template is not designed to be
324/// derived from multiple times in a hierarchy.  It is also not
325/// designed to be used for classes where subtypes might provide
326/// different amounts of source information.  It should be subclassed
327/// only at the deepest portion of the hierarchy where all children
328/// have identical source information; if that's an abstract type,
329/// then further descendents should inherit from
330/// InheritingConcreteTypeLoc instead.
331template <class Base, class Derived, class TypeClass, class LocalData>
332class ConcreteTypeLoc : public Base {
333
334  const Derived *asDerived() const {
335    return static_cast<const Derived*>(this);
336  }
337
338  friend class TypeLoc;
339  static bool isKind(const TypeLoc &TL) {
340    return !TL.getType().hasLocalQualifiers() &&
341           Derived::classofType(TL.getTypePtr());
342  }
343
344  static bool classofType(const Type *Ty) {
345    return TypeClass::classof(Ty);
346  }
347
348public:
349  unsigned getLocalDataAlignment() const {
350    return std::max(llvm::alignOf<LocalData>(),
351                    asDerived()->getExtraLocalDataAlignment());
352  }
353  unsigned getLocalDataSize() const {
354    unsigned size = sizeof(LocalData);
355    unsigned extraAlign = asDerived()->getExtraLocalDataAlignment();
356    size = llvm::RoundUpToAlignment(size, extraAlign);
357    size += asDerived()->getExtraLocalDataSize();
358    return size;
359  }
360
361  void copyLocal(Derived other) {
362    // Some subclasses have no data to copy.
363    if (asDerived()->getLocalDataSize() == 0) return;
364
365    // Copy the fixed-sized local data.
366    memcpy(getLocalData(), other.getLocalData(), sizeof(LocalData));
367
368    // Copy the variable-sized local data. We need to do this
369    // separately because the padding in the source and the padding in
370    // the destination might be different.
371    memcpy(getExtraLocalData(), other.getExtraLocalData(),
372           asDerived()->getExtraLocalDataSize());
373  }
374
375  TypeLoc getNextTypeLoc() const {
376    return getNextTypeLoc(asDerived()->getInnerType());
377  }
378
379  const TypeClass *getTypePtr() const {
380    return cast<TypeClass>(Base::getTypePtr());
381  }
382
383protected:
384  unsigned getExtraLocalDataSize() const {
385    return 0;
386  }
387
388  unsigned getExtraLocalDataAlignment() const {
389    return 1;
390  }
391
392  LocalData *getLocalData() const {
393    return static_cast<LocalData*>(Base::Data);
394  }
395
396  /// Gets a pointer past the Info structure; useful for classes with
397  /// local data that can't be captured in the Info (e.g. because it's
398  /// of variable size).
399  void *getExtraLocalData() const {
400    unsigned size = sizeof(LocalData);
401    unsigned extraAlign = asDerived()->getExtraLocalDataAlignment();
402    size = llvm::RoundUpToAlignment(size, extraAlign);
403    return reinterpret_cast<char*>(Base::Data) + size;
404  }
405
406  void *getNonLocalData() const {
407    uintptr_t data = reinterpret_cast<uintptr_t>(Base::Data);
408    data += asDerived()->getLocalDataSize();
409    data = llvm::RoundUpToAlignment(data, getNextTypeAlign());
410    return reinterpret_cast<void*>(data);
411  }
412
413  struct HasNoInnerType {};
414  HasNoInnerType getInnerType() const { return HasNoInnerType(); }
415
416  TypeLoc getInnerTypeLoc() const {
417    return TypeLoc(asDerived()->getInnerType(), getNonLocalData());
418  }
419
420private:
421  unsigned getInnerTypeSize() const {
422    return getInnerTypeSize(asDerived()->getInnerType());
423  }
424
425  unsigned getInnerTypeSize(HasNoInnerType _) const {
426    return 0;
427  }
428
429  unsigned getInnerTypeSize(QualType _) const {
430    return getInnerTypeLoc().getFullDataSize();
431  }
432
433  unsigned getNextTypeAlign() const {
434    return getNextTypeAlign(asDerived()->getInnerType());
435  }
436
437  unsigned getNextTypeAlign(HasNoInnerType _) const {
438    return 1;
439  }
440
441  unsigned getNextTypeAlign(QualType T) const {
442    return TypeLoc::getLocalAlignmentForType(T);
443  }
444
445  TypeLoc getNextTypeLoc(HasNoInnerType _) const {
446    return TypeLoc();
447  }
448
449  TypeLoc getNextTypeLoc(QualType T) const {
450    return TypeLoc(T, getNonLocalData());
451  }
452};
453
454/// A metaprogramming class designed for concrete subtypes of abstract
455/// types where all subtypes share equivalently-structured source
456/// information.  See the note on ConcreteTypeLoc.
457template <class Base, class Derived, class TypeClass>
458class InheritingConcreteTypeLoc : public Base {
459  friend class TypeLoc;
460  static bool classofType(const Type *Ty) {
461    return TypeClass::classof(Ty);
462  }
463
464  static bool isKind(const TypeLoc &TL) {
465    return !TL.getType().hasLocalQualifiers() &&
466           Derived::classofType(TL.getTypePtr());
467  }
468  static bool isKind(const UnqualTypeLoc &TL) {
469    return Derived::classofType(TL.getTypePtr());
470  }
471
472public:
473  const TypeClass *getTypePtr() const {
474    return cast<TypeClass>(Base::getTypePtr());
475  }
476};
477
478
479struct TypeSpecLocInfo {
480  SourceLocation NameLoc;
481};
482
483/// \brief A reasonable base class for TypeLocs that correspond to
484/// types that are written as a type-specifier.
485class TypeSpecTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
486                                               TypeSpecTypeLoc,
487                                               Type,
488                                               TypeSpecLocInfo> {
489public:
490  enum { LocalDataSize = sizeof(TypeSpecLocInfo),
491         LocalDataAlignment = llvm::AlignOf<TypeSpecLocInfo>::Alignment };
492
493  SourceLocation getNameLoc() const {
494    return this->getLocalData()->NameLoc;
495  }
496  void setNameLoc(SourceLocation Loc) {
497    this->getLocalData()->NameLoc = Loc;
498  }
499  SourceRange getLocalSourceRange() const {
500    return SourceRange(getNameLoc(), getNameLoc());
501  }
502  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
503    setNameLoc(Loc);
504  }
505
506private:
507  friend class TypeLoc;
508  static bool isKind(const TypeLoc &TL);
509};
510
511
512struct BuiltinLocInfo {
513  SourceLocation BuiltinLoc;
514};
515
516/// \brief Wrapper for source info for builtin types.
517class BuiltinTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
518                                              BuiltinTypeLoc,
519                                              BuiltinType,
520                                              BuiltinLocInfo> {
521public:
522  SourceLocation getBuiltinLoc() const {
523    return getLocalData()->BuiltinLoc;
524  }
525  void setBuiltinLoc(SourceLocation Loc) {
526    getLocalData()->BuiltinLoc = Loc;
527  }
528
529  SourceLocation getNameLoc() const { return getBuiltinLoc(); }
530
531  WrittenBuiltinSpecs& getWrittenBuiltinSpecs() {
532    return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData()));
533  }
534  const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
535    return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData()));
536  }
537
538  bool needsExtraLocalData() const {
539    BuiltinType::Kind bk = getTypePtr()->getKind();
540    return (bk >= BuiltinType::UShort && bk <= BuiltinType::UInt128)
541      || (bk >= BuiltinType::Short && bk <= BuiltinType::LongDouble)
542      || bk == BuiltinType::UChar
543      || bk == BuiltinType::SChar;
544  }
545
546  unsigned getExtraLocalDataSize() const {
547    return needsExtraLocalData() ? sizeof(WrittenBuiltinSpecs) : 0;
548  }
549
550  unsigned getExtraLocalDataAlignment() const {
551    return needsExtraLocalData() ? llvm::alignOf<WrittenBuiltinSpecs>() : 1;
552  }
553
554  SourceRange getLocalSourceRange() const {
555    return SourceRange(getBuiltinLoc(), getBuiltinLoc());
556  }
557
558  TypeSpecifierSign getWrittenSignSpec() const {
559    if (needsExtraLocalData())
560      return static_cast<TypeSpecifierSign>(getWrittenBuiltinSpecs().Sign);
561    else
562      return TSS_unspecified;
563  }
564  bool hasWrittenSignSpec() const {
565    return getWrittenSignSpec() != TSS_unspecified;
566  }
567  void setWrittenSignSpec(TypeSpecifierSign written) {
568    if (needsExtraLocalData())
569      getWrittenBuiltinSpecs().Sign = written;
570  }
571
572  TypeSpecifierWidth getWrittenWidthSpec() const {
573    if (needsExtraLocalData())
574      return static_cast<TypeSpecifierWidth>(getWrittenBuiltinSpecs().Width);
575    else
576      return TSW_unspecified;
577  }
578  bool hasWrittenWidthSpec() const {
579    return getWrittenWidthSpec() != TSW_unspecified;
580  }
581  void setWrittenWidthSpec(TypeSpecifierWidth written) {
582    if (needsExtraLocalData())
583      getWrittenBuiltinSpecs().Width = written;
584  }
585
586  TypeSpecifierType getWrittenTypeSpec() const;
587  bool hasWrittenTypeSpec() const {
588    return getWrittenTypeSpec() != TST_unspecified;
589  }
590  void setWrittenTypeSpec(TypeSpecifierType written) {
591    if (needsExtraLocalData())
592      getWrittenBuiltinSpecs().Type = written;
593  }
594
595  bool hasModeAttr() const {
596    if (needsExtraLocalData())
597      return getWrittenBuiltinSpecs().ModeAttr;
598    else
599      return false;
600  }
601  void setModeAttr(bool written) {
602    if (needsExtraLocalData())
603      getWrittenBuiltinSpecs().ModeAttr = written;
604  }
605
606  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
607    setBuiltinLoc(Loc);
608    if (needsExtraLocalData()) {
609      WrittenBuiltinSpecs &wbs = getWrittenBuiltinSpecs();
610      wbs.Sign = TSS_unspecified;
611      wbs.Width = TSW_unspecified;
612      wbs.Type = TST_unspecified;
613      wbs.ModeAttr = false;
614    }
615  }
616};
617
618
619/// \brief Wrapper for source info for typedefs.
620class TypedefTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
621                                                        TypedefTypeLoc,
622                                                        TypedefType> {
623public:
624  TypedefNameDecl *getTypedefNameDecl() const {
625    return getTypePtr()->getDecl();
626  }
627};
628
629/// \brief Wrapper for source info for injected class names of class
630/// templates.
631class InjectedClassNameTypeLoc :
632    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
633                                     InjectedClassNameTypeLoc,
634                                     InjectedClassNameType> {
635public:
636  CXXRecordDecl *getDecl() const {
637    return getTypePtr()->getDecl();
638  }
639};
640
641/// \brief Wrapper for source info for unresolved typename using decls.
642class UnresolvedUsingTypeLoc :
643    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
644                                     UnresolvedUsingTypeLoc,
645                                     UnresolvedUsingType> {
646public:
647  UnresolvedUsingTypenameDecl *getDecl() const {
648    return getTypePtr()->getDecl();
649  }
650};
651
652/// \brief Wrapper for source info for tag types.  Note that this only
653/// records source info for the name itself; a type written 'struct foo'
654/// should be represented as an ElaboratedTypeLoc.  We currently
655/// only do that when C++ is enabled because of the expense of
656/// creating an ElaboratedType node for so many type references in C.
657class TagTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
658                                                    TagTypeLoc,
659                                                    TagType> {
660public:
661  TagDecl *getDecl() const { return getTypePtr()->getDecl(); }
662
663  /// \brief True if the tag was defined in this type specifier.
664  bool isDefinition() const {
665    TagDecl *D = getDecl();
666    return D->isCompleteDefinition() &&
667           (D->getIdentifier() == nullptr || D->getLocation() == getNameLoc());
668  }
669};
670
671/// \brief Wrapper for source info for record types.
672class RecordTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
673                                                       RecordTypeLoc,
674                                                       RecordType> {
675public:
676  RecordDecl *getDecl() const { return getTypePtr()->getDecl(); }
677};
678
679/// \brief Wrapper for source info for enum types.
680class EnumTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
681                                                     EnumTypeLoc,
682                                                     EnumType> {
683public:
684  EnumDecl *getDecl() const { return getTypePtr()->getDecl(); }
685};
686
687/// \brief Wrapper for template type parameters.
688class TemplateTypeParmTypeLoc :
689    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
690                                     TemplateTypeParmTypeLoc,
691                                     TemplateTypeParmType> {
692public:
693  TemplateTypeParmDecl *getDecl() const { return getTypePtr()->getDecl(); }
694};
695
696/// \brief Wrapper for substituted template type parameters.
697class SubstTemplateTypeParmTypeLoc :
698    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
699                                     SubstTemplateTypeParmTypeLoc,
700                                     SubstTemplateTypeParmType> {
701};
702
703  /// \brief Wrapper for substituted template type parameters.
704class SubstTemplateTypeParmPackTypeLoc :
705    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
706                                     SubstTemplateTypeParmPackTypeLoc,
707                                     SubstTemplateTypeParmPackType> {
708};
709
710struct AttributedLocInfo {
711  union {
712    Expr *ExprOperand;
713
714    /// A raw SourceLocation.
715    unsigned EnumOperandLoc;
716  };
717
718  SourceRange OperandParens;
719
720  SourceLocation AttrLoc;
721};
722
723/// \brief Type source information for an attributed type.
724class AttributedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
725                                                 AttributedTypeLoc,
726                                                 AttributedType,
727                                                 AttributedLocInfo> {
728public:
729  AttributedType::Kind getAttrKind() const {
730    return getTypePtr()->getAttrKind();
731  }
732
733  bool hasAttrExprOperand() const {
734    return (getAttrKind() >= AttributedType::FirstExprOperandKind &&
735            getAttrKind() <= AttributedType::LastExprOperandKind);
736  }
737
738  bool hasAttrEnumOperand() const {
739    return (getAttrKind() >= AttributedType::FirstEnumOperandKind &&
740            getAttrKind() <= AttributedType::LastEnumOperandKind);
741  }
742
743  bool hasAttrOperand() const {
744    return hasAttrExprOperand() || hasAttrEnumOperand();
745  }
746
747  bool isQualifier() const {
748    return getTypePtr()->isQualifier();
749  }
750
751  /// The modified type, which is generally canonically different from
752  /// the attribute type.
753  ///    int main(int, char**) __attribute__((noreturn))
754  ///    ~~~     ~~~~~~~~~~~~~
755  TypeLoc getModifiedLoc() const {
756    return getInnerTypeLoc();
757  }
758
759  /// The location of the attribute name, i.e.
760  ///    __attribute__((regparm(1000)))
761  ///                   ^~~~~~~
762  SourceLocation getAttrNameLoc() const {
763    return getLocalData()->AttrLoc;
764  }
765  void setAttrNameLoc(SourceLocation loc) {
766    getLocalData()->AttrLoc = loc;
767  }
768
769  /// The attribute's expression operand, if it has one.
770  ///    void *cur_thread __attribute__((address_space(21)))
771  ///                                                  ^~
772  Expr *getAttrExprOperand() const {
773    assert(hasAttrExprOperand());
774    return getLocalData()->ExprOperand;
775  }
776  void setAttrExprOperand(Expr *e) {
777    assert(hasAttrExprOperand());
778    getLocalData()->ExprOperand = e;
779  }
780
781  /// The location of the attribute's enumerated operand, if it has one.
782  ///    void * __attribute__((objc_gc(weak)))
783  ///                                  ^~~~
784  SourceLocation getAttrEnumOperandLoc() const {
785    assert(hasAttrEnumOperand());
786    return SourceLocation::getFromRawEncoding(getLocalData()->EnumOperandLoc);
787  }
788  void setAttrEnumOperandLoc(SourceLocation loc) {
789    assert(hasAttrEnumOperand());
790    getLocalData()->EnumOperandLoc = loc.getRawEncoding();
791  }
792
793  /// The location of the parentheses around the operand, if there is
794  /// an operand.
795  ///    void * __attribute__((objc_gc(weak)))
796  ///                                 ^    ^
797  SourceRange getAttrOperandParensRange() const {
798    assert(hasAttrOperand());
799    return getLocalData()->OperandParens;
800  }
801  void setAttrOperandParensRange(SourceRange range) {
802    assert(hasAttrOperand());
803    getLocalData()->OperandParens = range;
804  }
805
806  SourceRange getLocalSourceRange() const {
807    // Note that this does *not* include the range of the attribute
808    // enclosure, e.g.:
809    //    __attribute__((foo(bar)))
810    //    ^~~~~~~~~~~~~~~        ~~
811    // or
812    //    [[foo(bar)]]
813    //    ^~        ~~
814    // That enclosure doesn't necessarily belong to a single attribute
815    // anyway.
816    SourceRange range(getAttrNameLoc());
817    if (hasAttrOperand())
818      range.setEnd(getAttrOperandParensRange().getEnd());
819    return range;
820  }
821
822  void initializeLocal(ASTContext &Context, SourceLocation loc) {
823    setAttrNameLoc(loc);
824    if (hasAttrExprOperand()) {
825      setAttrOperandParensRange(SourceRange(loc));
826      setAttrExprOperand(nullptr);
827    } else if (hasAttrEnumOperand()) {
828      setAttrOperandParensRange(SourceRange(loc));
829      setAttrEnumOperandLoc(loc);
830    }
831  }
832
833  QualType getInnerType() const {
834    return getTypePtr()->getModifiedType();
835  }
836};
837
838
839struct ObjCObjectTypeLocInfo {
840  SourceLocation TypeArgsLAngleLoc;
841  SourceLocation TypeArgsRAngleLoc;
842  SourceLocation ProtocolLAngleLoc;
843  SourceLocation ProtocolRAngleLoc;
844  bool HasBaseTypeAsWritten;
845};
846
847// A helper class for defining ObjC TypeLocs that can qualified with
848// protocols.
849//
850// TypeClass basically has to be either ObjCInterfaceType or
851// ObjCObjectPointerType.
852class ObjCObjectTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
853                                                 ObjCObjectTypeLoc,
854                                                 ObjCObjectType,
855                                                 ObjCObjectTypeLocInfo> {
856  // TypeSourceInfo*'s are stored after Info, one for each type argument.
857  TypeSourceInfo **getTypeArgLocArray() const {
858    return (TypeSourceInfo**)this->getExtraLocalData();
859  }
860
861  // SourceLocations are stored after the type argument information, one for
862  // each Protocol.
863  SourceLocation *getProtocolLocArray() const {
864    return (SourceLocation*)(getTypeArgLocArray() + getNumTypeArgs());
865  }
866
867public:
868  SourceLocation getTypeArgsLAngleLoc() const {
869    return this->getLocalData()->TypeArgsLAngleLoc;
870  }
871  void setTypeArgsLAngleLoc(SourceLocation Loc) {
872    this->getLocalData()->TypeArgsLAngleLoc = Loc;
873  }
874
875  SourceLocation getTypeArgsRAngleLoc() const {
876    return this->getLocalData()->TypeArgsRAngleLoc;
877  }
878  void setTypeArgsRAngleLoc(SourceLocation Loc) {
879    this->getLocalData()->TypeArgsRAngleLoc = Loc;
880  }
881
882  unsigned getNumTypeArgs() const {
883    return this->getTypePtr()->getTypeArgsAsWritten().size();
884  }
885
886  TypeSourceInfo *getTypeArgTInfo(unsigned i) const {
887    assert(i < getNumTypeArgs() && "Index is out of bounds!");
888    return getTypeArgLocArray()[i];
889  }
890
891  void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo) {
892    assert(i < getNumTypeArgs() && "Index is out of bounds!");
893    getTypeArgLocArray()[i] = TInfo;
894  }
895
896  SourceLocation getProtocolLAngleLoc() const {
897    return this->getLocalData()->ProtocolLAngleLoc;
898  }
899  void setProtocolLAngleLoc(SourceLocation Loc) {
900    this->getLocalData()->ProtocolLAngleLoc = Loc;
901  }
902
903  SourceLocation getProtocolRAngleLoc() const {
904    return this->getLocalData()->ProtocolRAngleLoc;
905  }
906  void setProtocolRAngleLoc(SourceLocation Loc) {
907    this->getLocalData()->ProtocolRAngleLoc = Loc;
908  }
909
910  unsigned getNumProtocols() const {
911    return this->getTypePtr()->getNumProtocols();
912  }
913
914  SourceLocation getProtocolLoc(unsigned i) const {
915    assert(i < getNumProtocols() && "Index is out of bounds!");
916    return getProtocolLocArray()[i];
917  }
918  void setProtocolLoc(unsigned i, SourceLocation Loc) {
919    assert(i < getNumProtocols() && "Index is out of bounds!");
920    getProtocolLocArray()[i] = Loc;
921  }
922
923  ObjCProtocolDecl *getProtocol(unsigned i) const {
924    assert(i < getNumProtocols() && "Index is out of bounds!");
925    return *(this->getTypePtr()->qual_begin() + i);
926  }
927
928
929  ArrayRef<SourceLocation> getProtocolLocs() const {
930    return llvm::makeArrayRef(getProtocolLocArray(), getNumProtocols());
931  }
932
933  bool hasBaseTypeAsWritten() const {
934    return getLocalData()->HasBaseTypeAsWritten;
935  }
936
937  void setHasBaseTypeAsWritten(bool HasBaseType) {
938    getLocalData()->HasBaseTypeAsWritten = HasBaseType;
939  }
940
941  TypeLoc getBaseLoc() const {
942    return getInnerTypeLoc();
943  }
944
945  SourceRange getLocalSourceRange() const {
946    SourceLocation start = getTypeArgsLAngleLoc();
947    if (start.isInvalid())
948      start = getProtocolLAngleLoc();
949    SourceLocation end = getProtocolRAngleLoc();
950    if (end.isInvalid())
951      end = getTypeArgsRAngleLoc();
952    return SourceRange(start, end);
953  }
954
955  void initializeLocal(ASTContext &Context, SourceLocation Loc);
956
957  unsigned getExtraLocalDataSize() const {
958    return this->getNumTypeArgs() * sizeof(TypeSourceInfo *)
959         + this->getNumProtocols() * sizeof(SourceLocation);
960  }
961
962  unsigned getExtraLocalDataAlignment() const {
963    assert(llvm::alignOf<ObjCObjectTypeLoc>()
964	     >= llvm::alignOf<TypeSourceInfo *>() &&
965	   "not enough alignment for tail-allocated data");
966    return llvm::alignOf<TypeSourceInfo *>();
967  }
968
969  QualType getInnerType() const {
970    return getTypePtr()->getBaseType();
971  }
972};
973
974
975struct ObjCInterfaceLocInfo {
976  SourceLocation NameLoc;
977  SourceLocation NameEndLoc;
978};
979
980/// \brief Wrapper for source info for ObjC interfaces.
981class ObjCInterfaceTypeLoc : public ConcreteTypeLoc<ObjCObjectTypeLoc,
982                                                    ObjCInterfaceTypeLoc,
983                                                    ObjCInterfaceType,
984                                                    ObjCInterfaceLocInfo> {
985public:
986  ObjCInterfaceDecl *getIFaceDecl() const {
987    return getTypePtr()->getDecl();
988  }
989
990  SourceLocation getNameLoc() const {
991    return getLocalData()->NameLoc;
992  }
993
994  void setNameLoc(SourceLocation Loc) {
995    getLocalData()->NameLoc = Loc;
996  }
997
998  SourceRange getLocalSourceRange() const {
999    return SourceRange(getNameLoc(), getNameEndLoc());
1000  }
1001
1002  SourceLocation getNameEndLoc() const {
1003    return getLocalData()->NameEndLoc;
1004  }
1005
1006  void setNameEndLoc(SourceLocation Loc) {
1007    getLocalData()->NameEndLoc = Loc;
1008  }
1009
1010  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1011    setNameLoc(Loc);
1012    setNameEndLoc(Loc);
1013  }
1014};
1015
1016struct ParenLocInfo {
1017  SourceLocation LParenLoc;
1018  SourceLocation RParenLoc;
1019};
1020
1021class ParenTypeLoc
1022  : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType,
1023                           ParenLocInfo> {
1024public:
1025  SourceLocation getLParenLoc() const {
1026    return this->getLocalData()->LParenLoc;
1027  }
1028  SourceLocation getRParenLoc() const {
1029    return this->getLocalData()->RParenLoc;
1030  }
1031  void setLParenLoc(SourceLocation Loc) {
1032    this->getLocalData()->LParenLoc = Loc;
1033  }
1034  void setRParenLoc(SourceLocation Loc) {
1035    this->getLocalData()->RParenLoc = Loc;
1036  }
1037
1038  SourceRange getLocalSourceRange() const {
1039    return SourceRange(getLParenLoc(), getRParenLoc());
1040  }
1041
1042  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1043    setLParenLoc(Loc);
1044    setRParenLoc(Loc);
1045  }
1046
1047  TypeLoc getInnerLoc() const {
1048    return getInnerTypeLoc();
1049  }
1050
1051  QualType getInnerType() const {
1052    return this->getTypePtr()->getInnerType();
1053  }
1054};
1055
1056inline TypeLoc TypeLoc::IgnoreParens() const {
1057  if (ParenTypeLoc::isKind(*this))
1058    return IgnoreParensImpl(*this);
1059  return *this;
1060}
1061
1062
1063struct AdjustedLocInfo { }; // Nothing.
1064
1065class AdjustedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AdjustedTypeLoc,
1066                                               AdjustedType, AdjustedLocInfo> {
1067public:
1068  TypeLoc getOriginalLoc() const {
1069    return getInnerTypeLoc();
1070  }
1071
1072  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1073    // do nothing
1074  }
1075
1076  QualType getInnerType() const {
1077    // The inner type is the undecayed type, since that's what we have source
1078    // location information for.
1079    return getTypePtr()->getOriginalType();
1080  }
1081
1082  SourceRange getLocalSourceRange() const {
1083    return SourceRange();
1084  }
1085
1086  unsigned getLocalDataSize() const {
1087    // sizeof(AdjustedLocInfo) is 1, but we don't need its address to be unique
1088    // anyway.  TypeLocBuilder can't handle data sizes of 1.
1089    return 0;  // No data.
1090  }
1091};
1092
1093/// \brief Wrapper for source info for pointers decayed from arrays and
1094/// functions.
1095class DecayedTypeLoc : public InheritingConcreteTypeLoc<
1096                           AdjustedTypeLoc, DecayedTypeLoc, DecayedType> {
1097};
1098
1099struct PointerLikeLocInfo {
1100  SourceLocation StarLoc;
1101};
1102
1103/// A base class for
1104template <class Derived, class TypeClass, class LocalData = PointerLikeLocInfo>
1105class PointerLikeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, Derived,
1106                                                  TypeClass, LocalData> {
1107public:
1108  SourceLocation getSigilLoc() const {
1109    return this->getLocalData()->StarLoc;
1110  }
1111  void setSigilLoc(SourceLocation Loc) {
1112    this->getLocalData()->StarLoc = Loc;
1113  }
1114
1115  TypeLoc getPointeeLoc() const {
1116    return this->getInnerTypeLoc();
1117  }
1118
1119  SourceRange getLocalSourceRange() const {
1120    return SourceRange(getSigilLoc(), getSigilLoc());
1121  }
1122
1123  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1124    setSigilLoc(Loc);
1125  }
1126
1127  QualType getInnerType() const {
1128    return this->getTypePtr()->getPointeeType();
1129  }
1130};
1131
1132
1133/// \brief Wrapper for source info for pointers.
1134class PointerTypeLoc : public PointerLikeTypeLoc<PointerTypeLoc,
1135                                                 PointerType> {
1136public:
1137  SourceLocation getStarLoc() const {
1138    return getSigilLoc();
1139  }
1140  void setStarLoc(SourceLocation Loc) {
1141    setSigilLoc(Loc);
1142  }
1143};
1144
1145
1146/// \brief Wrapper for source info for block pointers.
1147class BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc,
1148                                                      BlockPointerType> {
1149public:
1150  SourceLocation getCaretLoc() const {
1151    return getSigilLoc();
1152  }
1153  void setCaretLoc(SourceLocation Loc) {
1154    setSigilLoc(Loc);
1155  }
1156};
1157
1158struct MemberPointerLocInfo : public PointerLikeLocInfo {
1159  TypeSourceInfo *ClassTInfo;
1160};
1161
1162/// \brief Wrapper for source info for member pointers.
1163class MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc,
1164                                                       MemberPointerType,
1165                                                       MemberPointerLocInfo> {
1166public:
1167  SourceLocation getStarLoc() const {
1168    return getSigilLoc();
1169  }
1170  void setStarLoc(SourceLocation Loc) {
1171    setSigilLoc(Loc);
1172  }
1173
1174  const Type *getClass() const {
1175    return getTypePtr()->getClass();
1176  }
1177  TypeSourceInfo *getClassTInfo() const {
1178    return getLocalData()->ClassTInfo;
1179  }
1180  void setClassTInfo(TypeSourceInfo* TI) {
1181    getLocalData()->ClassTInfo = TI;
1182  }
1183
1184  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1185    setSigilLoc(Loc);
1186    setClassTInfo(nullptr);
1187  }
1188
1189  SourceRange getLocalSourceRange() const {
1190    if (TypeSourceInfo *TI = getClassTInfo())
1191      return SourceRange(TI->getTypeLoc().getBeginLoc(), getStarLoc());
1192    else
1193      return SourceRange(getStarLoc());
1194  }
1195};
1196
1197/// Wraps an ObjCPointerType with source location information.
1198class ObjCObjectPointerTypeLoc :
1199    public PointerLikeTypeLoc<ObjCObjectPointerTypeLoc,
1200                              ObjCObjectPointerType> {
1201public:
1202  SourceLocation getStarLoc() const {
1203    return getSigilLoc();
1204  }
1205
1206  void setStarLoc(SourceLocation Loc) {
1207    setSigilLoc(Loc);
1208  }
1209};
1210
1211
1212class ReferenceTypeLoc : public PointerLikeTypeLoc<ReferenceTypeLoc,
1213                                                   ReferenceType> {
1214public:
1215  QualType getInnerType() const {
1216    return getTypePtr()->getPointeeTypeAsWritten();
1217  }
1218};
1219
1220class LValueReferenceTypeLoc :
1221    public InheritingConcreteTypeLoc<ReferenceTypeLoc,
1222                                     LValueReferenceTypeLoc,
1223                                     LValueReferenceType> {
1224public:
1225  SourceLocation getAmpLoc() const {
1226    return getSigilLoc();
1227  }
1228  void setAmpLoc(SourceLocation Loc) {
1229    setSigilLoc(Loc);
1230  }
1231};
1232
1233class RValueReferenceTypeLoc :
1234    public InheritingConcreteTypeLoc<ReferenceTypeLoc,
1235                                     RValueReferenceTypeLoc,
1236                                     RValueReferenceType> {
1237public:
1238  SourceLocation getAmpAmpLoc() const {
1239    return getSigilLoc();
1240  }
1241  void setAmpAmpLoc(SourceLocation Loc) {
1242    setSigilLoc(Loc);
1243  }
1244};
1245
1246
1247struct FunctionLocInfo {
1248  SourceLocation LocalRangeBegin;
1249  SourceLocation LParenLoc;
1250  SourceLocation RParenLoc;
1251  SourceLocation LocalRangeEnd;
1252};
1253
1254/// \brief Wrapper for source info for functions.
1255class FunctionTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
1256                                               FunctionTypeLoc,
1257                                               FunctionType,
1258                                               FunctionLocInfo> {
1259public:
1260  SourceLocation getLocalRangeBegin() const {
1261    return getLocalData()->LocalRangeBegin;
1262  }
1263  void setLocalRangeBegin(SourceLocation L) {
1264    getLocalData()->LocalRangeBegin = L;
1265  }
1266
1267  SourceLocation getLocalRangeEnd() const {
1268    return getLocalData()->LocalRangeEnd;
1269  }
1270  void setLocalRangeEnd(SourceLocation L) {
1271    getLocalData()->LocalRangeEnd = L;
1272  }
1273
1274  SourceLocation getLParenLoc() const {
1275    return this->getLocalData()->LParenLoc;
1276  }
1277  void setLParenLoc(SourceLocation Loc) {
1278    this->getLocalData()->LParenLoc = Loc;
1279  }
1280
1281  SourceLocation getRParenLoc() const {
1282    return this->getLocalData()->RParenLoc;
1283  }
1284  void setRParenLoc(SourceLocation Loc) {
1285    this->getLocalData()->RParenLoc = Loc;
1286  }
1287
1288  SourceRange getParensRange() const {
1289    return SourceRange(getLParenLoc(), getRParenLoc());
1290  }
1291
1292  ArrayRef<ParmVarDecl *> getParams() const {
1293    return llvm::makeArrayRef(getParmArray(), getNumParams());
1294  }
1295
1296  // ParmVarDecls* are stored after Info, one for each parameter.
1297  ParmVarDecl **getParmArray() const {
1298    return (ParmVarDecl**) getExtraLocalData();
1299  }
1300
1301  unsigned getNumParams() const {
1302    if (isa<FunctionNoProtoType>(getTypePtr()))
1303      return 0;
1304    return cast<FunctionProtoType>(getTypePtr())->getNumParams();
1305  }
1306  ParmVarDecl *getParam(unsigned i) const { return getParmArray()[i]; }
1307  void setParam(unsigned i, ParmVarDecl *VD) { getParmArray()[i] = VD; }
1308
1309  TypeLoc getReturnLoc() const {
1310    return getInnerTypeLoc();
1311  }
1312
1313  SourceRange getLocalSourceRange() const {
1314    return SourceRange(getLocalRangeBegin(), getLocalRangeEnd());
1315  }
1316
1317  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1318    setLocalRangeBegin(Loc);
1319    setLParenLoc(Loc);
1320    setRParenLoc(Loc);
1321    setLocalRangeEnd(Loc);
1322    for (unsigned i = 0, e = getNumParams(); i != e; ++i)
1323      setParam(i, nullptr);
1324  }
1325
1326  /// \brief Returns the size of the type source info data block that is
1327  /// specific to this type.
1328  unsigned getExtraLocalDataSize() const {
1329    return getNumParams() * sizeof(ParmVarDecl *);
1330  }
1331
1332  unsigned getExtraLocalDataAlignment() const {
1333    return llvm::alignOf<ParmVarDecl*>();
1334  }
1335
1336  QualType getInnerType() const { return getTypePtr()->getReturnType(); }
1337};
1338
1339class FunctionProtoTypeLoc :
1340    public InheritingConcreteTypeLoc<FunctionTypeLoc,
1341                                     FunctionProtoTypeLoc,
1342                                     FunctionProtoType> {
1343};
1344
1345class FunctionNoProtoTypeLoc :
1346    public InheritingConcreteTypeLoc<FunctionTypeLoc,
1347                                     FunctionNoProtoTypeLoc,
1348                                     FunctionNoProtoType> {
1349};
1350
1351
1352struct ArrayLocInfo {
1353  SourceLocation LBracketLoc, RBracketLoc;
1354  Expr *Size;
1355};
1356
1357/// \brief Wrapper for source info for arrays.
1358class ArrayTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
1359                                            ArrayTypeLoc,
1360                                            ArrayType,
1361                                            ArrayLocInfo> {
1362public:
1363  SourceLocation getLBracketLoc() const {
1364    return getLocalData()->LBracketLoc;
1365  }
1366  void setLBracketLoc(SourceLocation Loc) {
1367    getLocalData()->LBracketLoc = Loc;
1368  }
1369
1370  SourceLocation getRBracketLoc() const {
1371    return getLocalData()->RBracketLoc;
1372  }
1373  void setRBracketLoc(SourceLocation Loc) {
1374    getLocalData()->RBracketLoc = Loc;
1375  }
1376
1377  SourceRange getBracketsRange() const {
1378    return SourceRange(getLBracketLoc(), getRBracketLoc());
1379  }
1380
1381  Expr *getSizeExpr() const {
1382    return getLocalData()->Size;
1383  }
1384  void setSizeExpr(Expr *Size) {
1385    getLocalData()->Size = Size;
1386  }
1387
1388  TypeLoc getElementLoc() const {
1389    return getInnerTypeLoc();
1390  }
1391
1392  SourceRange getLocalSourceRange() const {
1393    return SourceRange(getLBracketLoc(), getRBracketLoc());
1394  }
1395
1396  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1397    setLBracketLoc(Loc);
1398    setRBracketLoc(Loc);
1399    setSizeExpr(nullptr);
1400  }
1401
1402  QualType getInnerType() const { return getTypePtr()->getElementType(); }
1403};
1404
1405class ConstantArrayTypeLoc :
1406    public InheritingConcreteTypeLoc<ArrayTypeLoc,
1407                                     ConstantArrayTypeLoc,
1408                                     ConstantArrayType> {
1409};
1410
1411class IncompleteArrayTypeLoc :
1412    public InheritingConcreteTypeLoc<ArrayTypeLoc,
1413                                     IncompleteArrayTypeLoc,
1414                                     IncompleteArrayType> {
1415};
1416
1417class DependentSizedArrayTypeLoc :
1418    public InheritingConcreteTypeLoc<ArrayTypeLoc,
1419                                     DependentSizedArrayTypeLoc,
1420                                     DependentSizedArrayType> {
1421
1422};
1423
1424class VariableArrayTypeLoc :
1425    public InheritingConcreteTypeLoc<ArrayTypeLoc,
1426                                     VariableArrayTypeLoc,
1427                                     VariableArrayType> {
1428};
1429
1430
1431// Location information for a TemplateName.  Rudimentary for now.
1432struct TemplateNameLocInfo {
1433  SourceLocation NameLoc;
1434};
1435
1436struct TemplateSpecializationLocInfo : TemplateNameLocInfo {
1437  SourceLocation TemplateKWLoc;
1438  SourceLocation LAngleLoc;
1439  SourceLocation RAngleLoc;
1440};
1441
1442class TemplateSpecializationTypeLoc :
1443    public ConcreteTypeLoc<UnqualTypeLoc,
1444                           TemplateSpecializationTypeLoc,
1445                           TemplateSpecializationType,
1446                           TemplateSpecializationLocInfo> {
1447public:
1448  SourceLocation getTemplateKeywordLoc() const {
1449    return getLocalData()->TemplateKWLoc;
1450  }
1451  void setTemplateKeywordLoc(SourceLocation Loc) {
1452    getLocalData()->TemplateKWLoc = Loc;
1453  }
1454
1455  SourceLocation getLAngleLoc() const {
1456    return getLocalData()->LAngleLoc;
1457  }
1458  void setLAngleLoc(SourceLocation Loc) {
1459    getLocalData()->LAngleLoc = Loc;
1460  }
1461
1462  SourceLocation getRAngleLoc() const {
1463    return getLocalData()->RAngleLoc;
1464  }
1465  void setRAngleLoc(SourceLocation Loc) {
1466    getLocalData()->RAngleLoc = Loc;
1467  }
1468
1469  unsigned getNumArgs() const {
1470    return getTypePtr()->getNumArgs();
1471  }
1472  void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
1473    getArgInfos()[i] = AI;
1474  }
1475  TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
1476    return getArgInfos()[i];
1477  }
1478
1479  TemplateArgumentLoc getArgLoc(unsigned i) const {
1480    return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i));
1481  }
1482
1483  SourceLocation getTemplateNameLoc() const {
1484    return getLocalData()->NameLoc;
1485  }
1486  void setTemplateNameLoc(SourceLocation Loc) {
1487    getLocalData()->NameLoc = Loc;
1488  }
1489
1490  /// \brief - Copy the location information from the given info.
1491  void copy(TemplateSpecializationTypeLoc Loc) {
1492    unsigned size = getFullDataSize();
1493    assert(size == Loc.getFullDataSize());
1494
1495    // We're potentially copying Expr references here.  We don't
1496    // bother retaining them because TypeSourceInfos live forever, so
1497    // as long as the Expr was retained when originally written into
1498    // the TypeLoc, we're okay.
1499    memcpy(Data, Loc.Data, size);
1500  }
1501
1502  SourceRange getLocalSourceRange() const {
1503    if (getTemplateKeywordLoc().isValid())
1504      return SourceRange(getTemplateKeywordLoc(), getRAngleLoc());
1505    else
1506      return SourceRange(getTemplateNameLoc(), getRAngleLoc());
1507  }
1508
1509  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1510    setTemplateKeywordLoc(Loc);
1511    setTemplateNameLoc(Loc);
1512    setLAngleLoc(Loc);
1513    setRAngleLoc(Loc);
1514    initializeArgLocs(Context, getNumArgs(), getTypePtr()->getArgs(),
1515                      getArgInfos(), Loc);
1516  }
1517
1518  static void initializeArgLocs(ASTContext &Context, unsigned NumArgs,
1519                                const TemplateArgument *Args,
1520                                TemplateArgumentLocInfo *ArgInfos,
1521                                SourceLocation Loc);
1522
1523  unsigned getExtraLocalDataSize() const {
1524    return getNumArgs() * sizeof(TemplateArgumentLocInfo);
1525  }
1526
1527  unsigned getExtraLocalDataAlignment() const {
1528    return llvm::alignOf<TemplateArgumentLocInfo>();
1529  }
1530
1531private:
1532  TemplateArgumentLocInfo *getArgInfos() const {
1533    return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData());
1534  }
1535};
1536
1537//===----------------------------------------------------------------------===//
1538//
1539//  All of these need proper implementations.
1540//
1541//===----------------------------------------------------------------------===//
1542
1543// FIXME: size expression and attribute locations (or keyword if we
1544// ever fully support altivec syntax).
1545class VectorTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
1546                                                       VectorTypeLoc,
1547                                                       VectorType> {
1548};
1549
1550// FIXME: size expression and attribute locations.
1551class ExtVectorTypeLoc : public InheritingConcreteTypeLoc<VectorTypeLoc,
1552                                                          ExtVectorTypeLoc,
1553                                                          ExtVectorType> {
1554};
1555
1556// FIXME: attribute locations.
1557// For some reason, this isn't a subtype of VectorType.
1558class DependentSizedExtVectorTypeLoc :
1559    public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
1560                                     DependentSizedExtVectorTypeLoc,
1561                                     DependentSizedExtVectorType> {
1562};
1563
1564// FIXME: location of the '_Complex' keyword.
1565class ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
1566                                                        ComplexTypeLoc,
1567                                                        ComplexType> {
1568};
1569
1570struct TypeofLocInfo {
1571  SourceLocation TypeofLoc;
1572  SourceLocation LParenLoc;
1573  SourceLocation RParenLoc;
1574};
1575
1576struct TypeOfExprTypeLocInfo : public TypeofLocInfo {
1577};
1578
1579struct TypeOfTypeLocInfo : public TypeofLocInfo {
1580  TypeSourceInfo* UnderlyingTInfo;
1581};
1582
1583template <class Derived, class TypeClass, class LocalData = TypeofLocInfo>
1584class TypeofLikeTypeLoc
1585  : public ConcreteTypeLoc<UnqualTypeLoc, Derived, TypeClass, LocalData> {
1586public:
1587  SourceLocation getTypeofLoc() const {
1588    return this->getLocalData()->TypeofLoc;
1589  }
1590  void setTypeofLoc(SourceLocation Loc) {
1591    this->getLocalData()->TypeofLoc = Loc;
1592  }
1593
1594  SourceLocation getLParenLoc() const {
1595    return this->getLocalData()->LParenLoc;
1596  }
1597  void setLParenLoc(SourceLocation Loc) {
1598    this->getLocalData()->LParenLoc = Loc;
1599  }
1600
1601  SourceLocation getRParenLoc() const {
1602    return this->getLocalData()->RParenLoc;
1603  }
1604  void setRParenLoc(SourceLocation Loc) {
1605    this->getLocalData()->RParenLoc = Loc;
1606  }
1607
1608  SourceRange getParensRange() const {
1609    return SourceRange(getLParenLoc(), getRParenLoc());
1610  }
1611  void setParensRange(SourceRange range) {
1612      setLParenLoc(range.getBegin());
1613      setRParenLoc(range.getEnd());
1614  }
1615
1616  SourceRange getLocalSourceRange() const {
1617    return SourceRange(getTypeofLoc(), getRParenLoc());
1618  }
1619
1620  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1621    setTypeofLoc(Loc);
1622    setLParenLoc(Loc);
1623    setRParenLoc(Loc);
1624  }
1625};
1626
1627class TypeOfExprTypeLoc : public TypeofLikeTypeLoc<TypeOfExprTypeLoc,
1628                                                   TypeOfExprType,
1629                                                   TypeOfExprTypeLocInfo> {
1630public:
1631  Expr* getUnderlyingExpr() const {
1632    return getTypePtr()->getUnderlyingExpr();
1633  }
1634  // Reimplemented to account for GNU/C++ extension
1635  //     typeof unary-expression
1636  // where there are no parentheses.
1637  SourceRange getLocalSourceRange() const;
1638};
1639
1640class TypeOfTypeLoc
1641  : public TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo> {
1642public:
1643  QualType getUnderlyingType() const {
1644    return this->getTypePtr()->getUnderlyingType();
1645  }
1646  TypeSourceInfo* getUnderlyingTInfo() const {
1647    return this->getLocalData()->UnderlyingTInfo;
1648  }
1649  void setUnderlyingTInfo(TypeSourceInfo* TI) const {
1650    this->getLocalData()->UnderlyingTInfo = TI;
1651  }
1652
1653  void initializeLocal(ASTContext &Context, SourceLocation Loc);
1654};
1655
1656// FIXME: location of the 'decltype' and parens.
1657class DecltypeTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
1658                                                         DecltypeTypeLoc,
1659                                                         DecltypeType> {
1660public:
1661  Expr *getUnderlyingExpr() const { return getTypePtr()->getUnderlyingExpr(); }
1662};
1663
1664struct UnaryTransformTypeLocInfo {
1665  // FIXME: While there's only one unary transform right now, future ones may
1666  // need different representations
1667  SourceLocation KWLoc, LParenLoc, RParenLoc;
1668  TypeSourceInfo *UnderlyingTInfo;
1669};
1670
1671class UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
1672                                                    UnaryTransformTypeLoc,
1673                                                    UnaryTransformType,
1674                                                    UnaryTransformTypeLocInfo> {
1675public:
1676  SourceLocation getKWLoc() const { return getLocalData()->KWLoc; }
1677  void setKWLoc(SourceLocation Loc) { getLocalData()->KWLoc = Loc; }
1678
1679  SourceLocation getLParenLoc() const { return getLocalData()->LParenLoc; }
1680  void setLParenLoc(SourceLocation Loc) { getLocalData()->LParenLoc = Loc; }
1681
1682  SourceLocation getRParenLoc() const { return getLocalData()->RParenLoc; }
1683  void setRParenLoc(SourceLocation Loc) { getLocalData()->RParenLoc = Loc; }
1684
1685  TypeSourceInfo* getUnderlyingTInfo() const {
1686    return getLocalData()->UnderlyingTInfo;
1687  }
1688  void setUnderlyingTInfo(TypeSourceInfo *TInfo) {
1689    getLocalData()->UnderlyingTInfo = TInfo;
1690  }
1691
1692  SourceRange getLocalSourceRange() const {
1693    return SourceRange(getKWLoc(), getRParenLoc());
1694  }
1695
1696  SourceRange getParensRange() const {
1697    return SourceRange(getLParenLoc(), getRParenLoc());
1698  }
1699  void setParensRange(SourceRange Range) {
1700    setLParenLoc(Range.getBegin());
1701    setRParenLoc(Range.getEnd());
1702  }
1703
1704  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1705    setKWLoc(Loc);
1706    setRParenLoc(Loc);
1707    setLParenLoc(Loc);
1708  }
1709};
1710
1711class AutoTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
1712                                                        AutoTypeLoc,
1713                                                        AutoType> {
1714};
1715
1716struct ElaboratedLocInfo {
1717  SourceLocation ElaboratedKWLoc;
1718  /// \brief Data associated with the nested-name-specifier location.
1719  void *QualifierData;
1720};
1721
1722class ElaboratedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
1723                                                 ElaboratedTypeLoc,
1724                                                 ElaboratedType,
1725                                                 ElaboratedLocInfo> {
1726public:
1727  SourceLocation getElaboratedKeywordLoc() const {
1728    return this->getLocalData()->ElaboratedKWLoc;
1729  }
1730  void setElaboratedKeywordLoc(SourceLocation Loc) {
1731    this->getLocalData()->ElaboratedKWLoc = Loc;
1732  }
1733
1734  NestedNameSpecifierLoc getQualifierLoc() const {
1735    return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
1736                                  getLocalData()->QualifierData);
1737  }
1738
1739  void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
1740    assert(QualifierLoc.getNestedNameSpecifier()
1741                                            == getTypePtr()->getQualifier() &&
1742           "Inconsistent nested-name-specifier pointer");
1743    getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
1744  }
1745
1746  SourceRange getLocalSourceRange() const {
1747    if (getElaboratedKeywordLoc().isValid())
1748      if (getQualifierLoc())
1749        return SourceRange(getElaboratedKeywordLoc(),
1750                           getQualifierLoc().getEndLoc());
1751      else
1752        return SourceRange(getElaboratedKeywordLoc());
1753    else
1754      return getQualifierLoc().getSourceRange();
1755  }
1756
1757  void initializeLocal(ASTContext &Context, SourceLocation Loc);
1758
1759  TypeLoc getNamedTypeLoc() const {
1760    return getInnerTypeLoc();
1761  }
1762
1763  QualType getInnerType() const {
1764    return getTypePtr()->getNamedType();
1765  }
1766
1767  void copy(ElaboratedTypeLoc Loc) {
1768    unsigned size = getFullDataSize();
1769    assert(size == Loc.getFullDataSize());
1770    memcpy(Data, Loc.Data, size);
1771  }
1772};
1773
1774// This is exactly the structure of an ElaboratedTypeLoc whose inner
1775// type is some sort of TypeDeclTypeLoc.
1776struct DependentNameLocInfo : ElaboratedLocInfo {
1777  SourceLocation NameLoc;
1778};
1779
1780class DependentNameTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
1781                                                    DependentNameTypeLoc,
1782                                                    DependentNameType,
1783                                                    DependentNameLocInfo> {
1784public:
1785  SourceLocation getElaboratedKeywordLoc() const {
1786    return this->getLocalData()->ElaboratedKWLoc;
1787  }
1788  void setElaboratedKeywordLoc(SourceLocation Loc) {
1789    this->getLocalData()->ElaboratedKWLoc = Loc;
1790  }
1791
1792  NestedNameSpecifierLoc getQualifierLoc() const {
1793    return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
1794                                  getLocalData()->QualifierData);
1795  }
1796
1797  void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
1798    assert(QualifierLoc.getNestedNameSpecifier()
1799                                            == getTypePtr()->getQualifier() &&
1800           "Inconsistent nested-name-specifier pointer");
1801    getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
1802  }
1803
1804  SourceLocation getNameLoc() const {
1805    return this->getLocalData()->NameLoc;
1806  }
1807  void setNameLoc(SourceLocation Loc) {
1808    this->getLocalData()->NameLoc = Loc;
1809  }
1810
1811  SourceRange getLocalSourceRange() const {
1812    if (getElaboratedKeywordLoc().isValid())
1813      return SourceRange(getElaboratedKeywordLoc(), getNameLoc());
1814    else
1815      return SourceRange(getQualifierLoc().getBeginLoc(), getNameLoc());
1816  }
1817
1818  void copy(DependentNameTypeLoc Loc) {
1819    unsigned size = getFullDataSize();
1820    assert(size == Loc.getFullDataSize());
1821    memcpy(Data, Loc.Data, size);
1822  }
1823
1824  void initializeLocal(ASTContext &Context, SourceLocation Loc);
1825};
1826
1827struct DependentTemplateSpecializationLocInfo : DependentNameLocInfo {
1828  SourceLocation TemplateKWLoc;
1829  SourceLocation LAngleLoc;
1830  SourceLocation RAngleLoc;
1831  // followed by a TemplateArgumentLocInfo[]
1832};
1833
1834class DependentTemplateSpecializationTypeLoc :
1835    public ConcreteTypeLoc<UnqualTypeLoc,
1836                           DependentTemplateSpecializationTypeLoc,
1837                           DependentTemplateSpecializationType,
1838                           DependentTemplateSpecializationLocInfo> {
1839public:
1840  SourceLocation getElaboratedKeywordLoc() const {
1841    return this->getLocalData()->ElaboratedKWLoc;
1842  }
1843  void setElaboratedKeywordLoc(SourceLocation Loc) {
1844    this->getLocalData()->ElaboratedKWLoc = Loc;
1845  }
1846
1847  NestedNameSpecifierLoc getQualifierLoc() const {
1848    if (!getLocalData()->QualifierData)
1849      return NestedNameSpecifierLoc();
1850
1851    return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
1852                                  getLocalData()->QualifierData);
1853  }
1854
1855  void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
1856    if (!QualifierLoc) {
1857      // Even if we have a nested-name-specifier in the dependent
1858      // template specialization type, we won't record the nested-name-specifier
1859      // location information when this type-source location information is
1860      // part of a nested-name-specifier.
1861      getLocalData()->QualifierData = nullptr;
1862      return;
1863    }
1864
1865    assert(QualifierLoc.getNestedNameSpecifier()
1866                                        == getTypePtr()->getQualifier() &&
1867           "Inconsistent nested-name-specifier pointer");
1868    getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
1869  }
1870
1871  SourceLocation getTemplateKeywordLoc() const {
1872    return getLocalData()->TemplateKWLoc;
1873  }
1874  void setTemplateKeywordLoc(SourceLocation Loc) {
1875    getLocalData()->TemplateKWLoc = Loc;
1876  }
1877
1878  SourceLocation getTemplateNameLoc() const {
1879    return this->getLocalData()->NameLoc;
1880  }
1881  void setTemplateNameLoc(SourceLocation Loc) {
1882    this->getLocalData()->NameLoc = Loc;
1883  }
1884
1885  SourceLocation getLAngleLoc() const {
1886    return this->getLocalData()->LAngleLoc;
1887  }
1888  void setLAngleLoc(SourceLocation Loc) {
1889    this->getLocalData()->LAngleLoc = Loc;
1890  }
1891
1892  SourceLocation getRAngleLoc() const {
1893    return this->getLocalData()->RAngleLoc;
1894  }
1895  void setRAngleLoc(SourceLocation Loc) {
1896    this->getLocalData()->RAngleLoc = Loc;
1897  }
1898
1899  unsigned getNumArgs() const {
1900    return getTypePtr()->getNumArgs();
1901  }
1902
1903  void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
1904    getArgInfos()[i] = AI;
1905  }
1906  TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
1907    return getArgInfos()[i];
1908  }
1909
1910  TemplateArgumentLoc getArgLoc(unsigned i) const {
1911    return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i));
1912  }
1913
1914  SourceRange getLocalSourceRange() const {
1915    if (getElaboratedKeywordLoc().isValid())
1916      return SourceRange(getElaboratedKeywordLoc(), getRAngleLoc());
1917    else if (getQualifierLoc())
1918      return SourceRange(getQualifierLoc().getBeginLoc(), getRAngleLoc());
1919    else if (getTemplateKeywordLoc().isValid())
1920      return SourceRange(getTemplateKeywordLoc(), getRAngleLoc());
1921    else
1922      return SourceRange(getTemplateNameLoc(), getRAngleLoc());
1923  }
1924
1925  void copy(DependentTemplateSpecializationTypeLoc Loc) {
1926    unsigned size = getFullDataSize();
1927    assert(size == Loc.getFullDataSize());
1928    memcpy(Data, Loc.Data, size);
1929  }
1930
1931  void initializeLocal(ASTContext &Context, SourceLocation Loc);
1932
1933  unsigned getExtraLocalDataSize() const {
1934    return getNumArgs() * sizeof(TemplateArgumentLocInfo);
1935  }
1936
1937  unsigned getExtraLocalDataAlignment() const {
1938    return llvm::alignOf<TemplateArgumentLocInfo>();
1939  }
1940
1941private:
1942  TemplateArgumentLocInfo *getArgInfos() const {
1943    return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData());
1944  }
1945};
1946
1947
1948struct PackExpansionTypeLocInfo {
1949  SourceLocation EllipsisLoc;
1950};
1951
1952class PackExpansionTypeLoc
1953  : public ConcreteTypeLoc<UnqualTypeLoc, PackExpansionTypeLoc,
1954                           PackExpansionType, PackExpansionTypeLocInfo> {
1955public:
1956  SourceLocation getEllipsisLoc() const {
1957    return this->getLocalData()->EllipsisLoc;
1958  }
1959
1960  void setEllipsisLoc(SourceLocation Loc) {
1961    this->getLocalData()->EllipsisLoc = Loc;
1962  }
1963
1964  SourceRange getLocalSourceRange() const {
1965    return SourceRange(getEllipsisLoc(), getEllipsisLoc());
1966  }
1967
1968  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
1969    setEllipsisLoc(Loc);
1970  }
1971
1972  TypeLoc getPatternLoc() const {
1973    return getInnerTypeLoc();
1974  }
1975
1976  QualType getInnerType() const {
1977    return this->getTypePtr()->getPattern();
1978  }
1979};
1980
1981struct AtomicTypeLocInfo {
1982  SourceLocation KWLoc, LParenLoc, RParenLoc;
1983};
1984
1985class AtomicTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AtomicTypeLoc,
1986                                             AtomicType, AtomicTypeLocInfo> {
1987public:
1988  TypeLoc getValueLoc() const {
1989    return this->getInnerTypeLoc();
1990  }
1991
1992  SourceRange getLocalSourceRange() const {
1993    return SourceRange(getKWLoc(), getRParenLoc());
1994  }
1995
1996  SourceLocation getKWLoc() const {
1997    return this->getLocalData()->KWLoc;
1998  }
1999  void setKWLoc(SourceLocation Loc) {
2000    this->getLocalData()->KWLoc = Loc;
2001  }
2002
2003  SourceLocation getLParenLoc() const {
2004    return this->getLocalData()->LParenLoc;
2005  }
2006  void setLParenLoc(SourceLocation Loc) {
2007    this->getLocalData()->LParenLoc = Loc;
2008  }
2009
2010  SourceLocation getRParenLoc() const {
2011    return this->getLocalData()->RParenLoc;
2012  }
2013  void setRParenLoc(SourceLocation Loc) {
2014    this->getLocalData()->RParenLoc = Loc;
2015  }
2016
2017  SourceRange getParensRange() const {
2018    return SourceRange(getLParenLoc(), getRParenLoc());
2019  }
2020  void setParensRange(SourceRange Range) {
2021    setLParenLoc(Range.getBegin());
2022    setRParenLoc(Range.getEnd());
2023  }
2024
2025  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
2026    setKWLoc(Loc);
2027    setLParenLoc(Loc);
2028    setRParenLoc(Loc);
2029  }
2030
2031  QualType getInnerType() const {
2032    return this->getTypePtr()->getValueType();
2033  }
2034};
2035
2036
2037}
2038
2039#endif
2040