Clang Project

clang_source_code/include/clang/AST/DeclObjC.h
1//===- DeclObjC.h - Classes for representing declarations -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the DeclObjC interface and subclasses.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_DECLOBJC_H
14#define LLVM_CLANG_AST_DECLOBJC_H
15
16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclBase.h"
18#include "clang/AST/ExternalASTSource.h"
19#include "clang/AST/Redeclarable.h"
20#include "clang/AST/SelectorLocationsKind.h"
21#include "clang/AST/Type.h"
22#include "clang/Basic/IdentifierTable.h"
23#include "clang/Basic/LLVM.h"
24#include "clang/Basic/SourceLocation.h"
25#include "clang/Basic/Specifiers.h"
26#include "llvm/ADT/ArrayRef.h"
27#include "llvm/ADT/DenseMap.h"
28#include "llvm/ADT/DenseSet.h"
29#include "llvm/ADT/None.h"
30#include "llvm/ADT/PointerIntPair.h"
31#include "llvm/ADT/STLExtras.h"
32#include "llvm/ADT/StringRef.h"
33#include "llvm/ADT/iterator_range.h"
34#include "llvm/Support/Compiler.h"
35#include "llvm/Support/TrailingObjects.h"
36#include <cassert>
37#include <cstddef>
38#include <cstdint>
39#include <iterator>
40#include <string>
41#include <utility>
42
43namespace clang {
44
45class ASTContext;
46class CompoundStmt;
47class CXXCtorInitializer;
48class Expr;
49class ObjCCategoryDecl;
50class ObjCCategoryImplDecl;
51class ObjCImplementationDecl;
52class ObjCInterfaceDecl;
53class ObjCIvarDecl;
54class ObjCPropertyDecl;
55class ObjCPropertyImplDecl;
56class ObjCProtocolDecl;
57class Stmt;
58
59class ObjCListBase {
60protected:
61  /// List is an array of pointers to objects that are not owned by this object.
62  void **List = nullptr;
63  unsigned NumElts = 0;
64
65public:
66  ObjCListBase() = default;
67  ObjCListBase(const ObjCListBase &) = delete;
68  ObjCListBase &operator=(const ObjCListBase &) = delete;
69
70  unsigned size() const { return NumElts; }
71  bool empty() const { return NumElts == 0; }
72
73protected:
74  void set(void *const* InList, unsigned Elts, ASTContext &Ctx);
75};
76
77/// ObjCList - This is a simple template class used to hold various lists of
78/// decls etc, which is heavily used by the ObjC front-end.  This only use case
79/// this supports is setting the list all at once and then reading elements out
80/// of it.
81template <typename T>
82class ObjCList : public ObjCListBase {
83public:
84  void set(T* const* InList, unsigned Elts, ASTContext &Ctx) {
85    ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx);
86  }
87
88  using iterator = T* const *;
89
90  iterator begin() const { return (iterator)List; }
91  iterator end() const { return (iterator)List+NumElts; }
92
93  T* operator[](unsigned Idx) const {
94     (0) . __assert_fail ("Idx < NumElts && \"Invalid access\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 94, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Idx < NumElts && "Invalid access");
95    return (T*)List[Idx];
96  }
97};
98
99/// A list of Objective-C protocols, along with the source
100/// locations at which they were referenced.
101class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {
102  SourceLocation *Locations = nullptr;
103
104  using ObjCList<ObjCProtocolDecl>::set;
105
106public:
107  ObjCProtocolList() = default;
108
109  using loc_iterator = const SourceLocation *;
110
111  loc_iterator loc_begin() const { return Locations; }
112  loc_iterator loc_end() const { return Locations + size(); }
113
114  void set(ObjCProtocolDecl* const* InList, unsigned Elts,
115           const SourceLocation *Locs, ASTContext &Ctx);
116};
117
118/// ObjCMethodDecl - Represents an instance or class method declaration.
119/// ObjC methods can be declared within 4 contexts: class interfaces,
120/// categories, protocols, and class implementations. While C++ member
121/// functions leverage C syntax, Objective-C method syntax is modeled after
122/// Smalltalk (using colons to specify argument types/expressions).
123/// Here are some brief examples:
124///
125/// Setter/getter instance methods:
126/// - (void)setMenu:(NSMenu *)menu;
127/// - (NSMenu *)menu;
128///
129/// Instance method that takes 2 NSView arguments:
130/// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView;
131///
132/// Getter class method:
133/// + (NSMenu *)defaultMenu;
134///
135/// A selector represents a unique name for a method. The selector names for
136/// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
137///
138class ObjCMethodDecl : public NamedDecl, public DeclContext {
139  // This class stores some data in DeclContext::ObjCMethodDeclBits
140  // to save some space. Use the provided accessors to access it.
141
142public:
143  enum ImplementationControl { None, Required, Optional };
144
145private:
146  /// Return type of this method.
147  QualType MethodDeclType;
148
149  /// Type source information for the return type.
150  TypeSourceInfo *ReturnTInfo;
151
152  /// Array of ParmVarDecls for the formal parameters of this method
153  /// and optionally followed by selector locations.
154  void *ParamsAndSelLocs = nullptr;
155  unsigned NumParams = 0;
156
157  /// List of attributes for this method declaration.
158  SourceLocation DeclEndLoc; // the location of the ';' or '{'.
159
160  /// The following are only used for method definitions, null otherwise.
161  LazyDeclStmtPtr Body;
162
163  /// SelfDecl - Decl for the implicit self parameter. This is lazily
164  /// constructed by createImplicitParams.
165  ImplicitParamDecl *SelfDecl = nullptr;
166
167  /// CmdDecl - Decl for the implicit _cmd parameter. This is lazily
168  /// constructed by createImplicitParams.
169  ImplicitParamDecl *CmdDecl = nullptr;
170
171  ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
172                 Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
173                 DeclContext *contextDecl, bool isInstance = true,
174                 bool isVariadic = false, bool isPropertyAccessor = false,
175                 bool isImplicitlyDeclared = false, bool isDefined = false,
176                 ImplementationControl impControl = None,
177                 bool HasRelatedResultType = false);
178
179  SelectorLocationsKind getSelLocsKind() const {
180    return static_cast<SelectorLocationsKind>(ObjCMethodDeclBits.SelLocsKind);
181  }
182
183  void setSelLocsKind(SelectorLocationsKind Kind) {
184    ObjCMethodDeclBits.SelLocsKind = Kind;
185  }
186
187  bool hasStandardSelLocs() const {
188    return getSelLocsKind() != SelLoc_NonStandard;
189  }
190
191  /// Get a pointer to the stored selector identifiers locations array.
192  /// No locations will be stored if HasStandardSelLocs is true.
193  SourceLocation *getStoredSelLocs() {
194    return reinterpret_cast<SourceLocation *>(getParams() + NumParams);
195  }
196  const SourceLocation *getStoredSelLocs() const {
197    return reinterpret_cast<const SourceLocation *>(getParams() + NumParams);
198  }
199
200  /// Get a pointer to the stored selector identifiers locations array.
201  /// No locations will be stored if HasStandardSelLocs is true.
202  ParmVarDecl **getParams() {
203    return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs);
204  }
205  const ParmVarDecl *const *getParams() const {
206    return reinterpret_cast<const ParmVarDecl *const *>(ParamsAndSelLocs);
207  }
208
209  /// Get the number of stored selector identifiers locations.
210  /// No locations will be stored if HasStandardSelLocs is true.
211  unsigned getNumStoredSelLocs() const {
212    if (hasStandardSelLocs())
213      return 0;
214    return getNumSelectorLocs();
215  }
216
217  void setParamsAndSelLocs(ASTContext &C,
218                           ArrayRef<ParmVarDecl*> Params,
219                           ArrayRef<SourceLocation> SelLocs);
220
221  /// A definition will return its interface declaration.
222  /// An interface declaration will return its definition.
223  /// Otherwise it will return itself.
224  ObjCMethodDecl *getNextRedeclarationImpl() override;
225
226public:
227  friend class ASTDeclReader;
228  friend class ASTDeclWriter;
229
230  static ObjCMethodDecl *
231  Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,
232         Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
233         DeclContext *contextDecl, bool isInstance = true,
234         bool isVariadic = false, bool isPropertyAccessor = false,
235         bool isImplicitlyDeclared = false, bool isDefined = false,
236         ImplementationControl impControl = None,
237         bool HasRelatedResultType = false);
238
239  static ObjCMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
240
241  ObjCMethodDecl *getCanonicalDecl() override;
242  const ObjCMethodDecl *getCanonicalDecl() const {
243    return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl();
244  }
245
246  ObjCDeclQualifier getObjCDeclQualifier() const {
247    return static_cast<ObjCDeclQualifier>(ObjCMethodDeclBits.objcDeclQualifier);
248  }
249
250  void setObjCDeclQualifier(ObjCDeclQualifier QV) {
251    ObjCMethodDeclBits.objcDeclQualifier = QV;
252  }
253
254  /// Determine whether this method has a result type that is related
255  /// to the message receiver's type.
256  bool hasRelatedResultType() const {
257    return ObjCMethodDeclBits.RelatedResultType;
258  }
259
260  /// Note whether this method has a related result type.
261  void setRelatedResultType(bool RRT = true) {
262    ObjCMethodDeclBits.RelatedResultType = RRT;
263  }
264
265  /// True if this is a method redeclaration in the same interface.
266  bool isRedeclaration() const { return ObjCMethodDeclBits.IsRedeclaration; }
267  void setIsRedeclaration(bool RD) { ObjCMethodDeclBits.IsRedeclaration = RD; }
268  void setAsRedeclaration(const ObjCMethodDecl *PrevMethod);
269
270  /// True if redeclared in the same interface.
271  bool hasRedeclaration() const { return ObjCMethodDeclBits.HasRedeclaration; }
272  void setHasRedeclaration(bool HRD) const {
273    ObjCMethodDeclBits.HasRedeclaration = HRD;
274  }
275
276  /// Returns the location where the declarator ends. It will be
277  /// the location of ';' for a method declaration and the location of '{'
278  /// for a method definition.
279  SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; }
280
281  // Location information, modeled after the Stmt API.
282  SourceLocation getBeginLoc() const LLVM_READONLY { return getLocation(); }
283  SourceLocation getEndLoc() const LLVM_READONLY;
284  SourceRange getSourceRange() const override LLVM_READONLY {
285    return SourceRange(getLocation(), getEndLoc());
286  }
287
288  SourceLocation getSelectorStartLoc() const {
289    if (isImplicit())
290      return getBeginLoc();
291    return getSelectorLoc(0);
292  }
293
294  SourceLocation getSelectorLoc(unsigned Index) const {
295     (0) . __assert_fail ("Index < getNumSelectorLocs() && \"Index out of range!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 295, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Index < getNumSelectorLocs() && "Index out of range!");
296    if (hasStandardSelLocs())
297      return getStandardSelectorLoc(Index, getSelector(),
298                                   getSelLocsKind() == SelLoc_StandardWithSpace,
299                                    parameters(),
300                                   DeclEndLoc);
301    return getStoredSelLocs()[Index];
302  }
303
304  void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
305
306  unsigned getNumSelectorLocs() const {
307    if (isImplicit())
308      return 0;
309    Selector Sel = getSelector();
310    if (Sel.isUnarySelector())
311      return 1;
312    return Sel.getNumArgs();
313  }
314
315  ObjCInterfaceDecl *getClassInterface();
316  const ObjCInterfaceDecl *getClassInterface() const {
317    return const_cast<ObjCMethodDecl*>(this)->getClassInterface();
318  }
319
320  Selector getSelector() const { return getDeclName().getObjCSelector(); }
321
322  QualType getReturnType() const { return MethodDeclType; }
323  void setReturnType(QualType T) { MethodDeclType = T; }
324  SourceRange getReturnTypeSourceRange() const;
325
326  /// Determine the type of an expression that sends a message to this
327  /// function. This replaces the type parameters with the types they would
328  /// get if the receiver was parameterless (e.g. it may replace the type
329  /// parameter with 'id').
330  QualType getSendResultType() const;
331
332  /// Determine the type of an expression that sends a message to this
333  /// function with the given receiver type.
334  QualType getSendResultType(QualType receiverType) const;
335
336  TypeSourceInfo *getReturnTypeSourceInfo() const { return ReturnTInfo; }
337  void setReturnTypeSourceInfo(TypeSourceInfo *TInfo) { ReturnTInfo = TInfo; }
338
339  // Iterator access to formal parameters.
340  unsigned param_size() const { return NumParams; }
341
342  using param_const_iterator = const ParmVarDecl *const *;
343  using param_iterator = ParmVarDecl *const *;
344  using param_range = llvm::iterator_range<param_iterator>;
345  using param_const_range = llvm::iterator_range<param_const_iterator>;
346
347  param_const_iterator param_begin() const {
348    return param_const_iterator(getParams());
349  }
350
351  param_const_iterator param_end() const {
352    return param_const_iterator(getParams() + NumParams);
353  }
354
355  param_iterator param_begin() { return param_iterator(getParams()); }
356  param_iterator param_end() { return param_iterator(getParams() + NumParams); }
357
358  // This method returns and of the parameters which are part of the selector
359  // name mangling requirements.
360  param_const_iterator sel_param_end() const {
361    return param_begin() + getSelector().getNumArgs();
362  }
363
364  // ArrayRef access to formal parameters.  This should eventually
365  // replace the iterator interface above.
366  ArrayRef<ParmVarDecl*> parameters() const {
367    return llvm::makeArrayRef(const_cast<ParmVarDecl**>(getParams()),
368                              NumParams);
369  }
370
371  ParmVarDecl *getParamDecl(unsigned Idx) {
372     (0) . __assert_fail ("Idx < NumParams && \"Index out of bounds!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 372, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Idx < NumParams && "Index out of bounds!");
373    return getParams()[Idx];
374  }
375  const ParmVarDecl *getParamDecl(unsigned Idx) const {
376    return const_cast<ObjCMethodDecl *>(this)->getParamDecl(Idx);
377  }
378
379  /// Sets the method's parameters and selector source locations.
380  /// If the method is implicit (not coming from source) \p SelLocs is
381  /// ignored.
382  void setMethodParams(ASTContext &C,
383                       ArrayRef<ParmVarDecl*> Params,
384                       ArrayRef<SourceLocation> SelLocs = llvm::None);
385
386  // Iterator access to parameter types.
387  struct GetTypeFn {
388    QualType operator()(const ParmVarDecl *PD) const { return PD->getType(); }
389  };
390
391  using param_type_iterator =
392      llvm::mapped_iterator<param_const_iterator, GetTypeFn>;
393
394  param_type_iterator param_type_begin() const {
395    return llvm::map_iterator(param_begin(), GetTypeFn());
396  }
397
398  param_type_iterator param_type_end() const {
399    return llvm::map_iterator(param_end(), GetTypeFn());
400  }
401
402  /// createImplicitParams - Used to lazily create the self and cmd
403  /// implict parameters. This must be called prior to using getSelfDecl()
404  /// or getCmdDecl(). The call is ignored if the implicit parameters
405  /// have already been created.
406  void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID);
407
408  /// \return the type for \c self and set \arg selfIsPseudoStrong and
409  /// \arg selfIsConsumed accordingly.
410  QualType getSelfType(ASTContext &Context, const ObjCInterfaceDecl *OID,
411                       bool &selfIsPseudoStrong, bool &selfIsConsumed);
412
413  ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }
414  void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; }
415  ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }
416  void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; }
417
418  /// Determines the family of this method.
419  ObjCMethodFamily getMethodFamily() const;
420
421  bool isInstanceMethod() const { return ObjCMethodDeclBits.IsInstance; }
422  void setInstanceMethod(bool isInst) {
423    ObjCMethodDeclBits.IsInstance = isInst;
424  }
425
426  bool isVariadic() const { return ObjCMethodDeclBits.IsVariadic; }
427  void setVariadic(bool isVar) { ObjCMethodDeclBits.IsVariadic = isVar; }
428
429  bool isClassMethod() const { return !isInstanceMethod(); }
430
431  bool isPropertyAccessor() const {
432    return ObjCMethodDeclBits.IsPropertyAccessor;
433  }
434
435  void setPropertyAccessor(bool isAccessor) {
436    ObjCMethodDeclBits.IsPropertyAccessor = isAccessor;
437  }
438
439  bool isDefined() const { return ObjCMethodDeclBits.IsDefined; }
440  void setDefined(bool isDefined) { ObjCMethodDeclBits.IsDefined = isDefined; }
441
442  /// Whether this method overrides any other in the class hierarchy.
443  ///
444  /// A method is said to override any method in the class's
445  /// base classes, its protocols, or its categories' protocols, that has
446  /// the same selector and is of the same kind (class or instance).
447  /// A method in an implementation is not considered as overriding the same
448  /// method in the interface or its categories.
449  bool isOverriding() const { return ObjCMethodDeclBits.IsOverriding; }
450  void setOverriding(bool IsOver) { ObjCMethodDeclBits.IsOverriding = IsOver; }
451
452  /// Return overridden methods for the given \p Method.
453  ///
454  /// An ObjC method is considered to override any method in the class's
455  /// base classes (and base's categories), its protocols, or its categories'
456  /// protocols, that has
457  /// the same selector and is of the same kind (class or instance).
458  /// A method in an implementation is not considered as overriding the same
459  /// method in the interface or its categories.
460  void getOverriddenMethods(
461                     SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const;
462
463  /// True if the method was a definition but its body was skipped.
464  bool hasSkippedBody() const { return ObjCMethodDeclBits.HasSkippedBody; }
465  void setHasSkippedBody(bool Skipped = true) {
466    ObjCMethodDeclBits.HasSkippedBody = Skipped;
467  }
468
469  /// Returns the property associated with this method's selector.
470  ///
471  /// Note that even if this particular method is not marked as a property
472  /// accessor, it is still possible for it to match a property declared in a
473  /// superclass. Pass \c false if you only want to check the current class.
474  const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const;
475
476  // Related to protocols declared in  \@protocol
477  void setDeclImplementation(ImplementationControl ic) {
478    ObjCMethodDeclBits.DeclImplementation = ic;
479  }
480
481  ImplementationControl getImplementationControl() const {
482    return ImplementationControl(ObjCMethodDeclBits.DeclImplementation);
483  }
484
485  bool isOptional() const {
486    return getImplementationControl() == Optional;
487  }
488
489  /// Returns true if this specific method declaration is marked with the
490  /// designated initializer attribute.
491  bool isThisDeclarationADesignatedInitializer() const;
492
493  /// Returns true if the method selector resolves to a designated initializer
494  /// in the class's interface.
495  ///
496  /// \param InitMethod if non-null and the function returns true, it receives
497  /// the method declaration that was marked with the designated initializer
498  /// attribute.
499  bool isDesignatedInitializerForTheInterface(
500      const ObjCMethodDecl **InitMethod = nullptr) const;
501
502  /// Determine whether this method has a body.
503  bool hasBody() const override { return Body.isValid(); }
504
505  /// Retrieve the body of this method, if it has one.
506  Stmt *getBody() const override;
507
508  void setLazyBody(uint64_t Offset) { Body = Offset; }
509
510  CompoundStmt *getCompoundBody() { return (CompoundStmt*)getBody(); }
511  void setBody(Stmt *B) { Body = B; }
512
513  /// Returns whether this specific method is a definition.
514  bool isThisDeclarationADefinition() const { return hasBody(); }
515
516  /// Is this method defined in the NSObject base class?
517  bool definedInNSObject(const ASTContext &) const;
518
519  // Implement isa/cast/dyncast/etc.
520  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
521  static bool classofKind(Kind K) { return K == ObjCMethod; }
522
523  static DeclContext *castToDeclContext(const ObjCMethodDecl *D) {
524    return static_cast<DeclContext *>(const_cast<ObjCMethodDecl*>(D));
525  }
526
527  static ObjCMethodDecl *castFromDeclContext(const DeclContext *DC) {
528    return static_cast<ObjCMethodDecl *>(const_cast<DeclContext*>(DC));
529  }
530};
531
532/// Describes the variance of a given generic parameter.
533enum class ObjCTypeParamVariance : uint8_t {
534  /// The parameter is invariant: must match exactly.
535  Invariant,
536
537  /// The parameter is covariant, e.g., X<T> is a subtype of X<U> when
538  /// the type parameter is covariant and T is a subtype of U.
539  Covariant,
540
541  /// The parameter is contravariant, e.g., X<T> is a subtype of X<U>
542  /// when the type parameter is covariant and U is a subtype of T.
543  Contravariant,
544};
545
546/// Represents the declaration of an Objective-C type parameter.
547///
548/// \code
549/// @interface NSDictionary<Key : id<NSCopying>, Value>
550/// @end
551/// \endcode
552///
553/// In the example above, both \c Key and \c Value are represented by
554/// \c ObjCTypeParamDecl. \c Key has an explicit bound of \c id<NSCopying>,
555/// while \c Value gets an implicit bound of \c id.
556///
557/// Objective-C type parameters are typedef-names in the grammar,
558class ObjCTypeParamDecl : public TypedefNameDecl {
559  /// Index of this type parameter in the type parameter list.
560  unsigned Index : 14;
561
562  /// The variance of the type parameter.
563  unsigned Variance : 2;
564
565  /// The location of the variance, if any.
566  SourceLocation VarianceLoc;
567
568  /// The location of the ':', which will be valid when the bound was
569  /// explicitly specified.
570  SourceLocation ColonLoc;
571
572  ObjCTypeParamDecl(ASTContext &ctx, DeclContext *dc,
573                    ObjCTypeParamVariance variance, SourceLocation varianceLoc,
574                    unsigned index,
575                    SourceLocation nameLoc, IdentifierInfo *name,
576                    SourceLocation colonLoc, TypeSourceInfo *boundInfo)
577      : TypedefNameDecl(ObjCTypeParam, ctx, dc, nameLoc, nameLoc, name,
578                        boundInfo),
579        Index(index), Variance(static_cast<unsigned>(variance)),
580        VarianceLoc(varianceLoc), ColonLoc(colonLoc) {}
581
582  void anchor() override;
583
584public:
585  friend class ASTDeclReader;
586  friend class ASTDeclWriter;
587
588  static ObjCTypeParamDecl *Create(ASTContext &ctx, DeclContext *dc,
589                                   ObjCTypeParamVariance variance,
590                                   SourceLocation varianceLoc,
591                                   unsigned index,
592                                   SourceLocation nameLoc,
593                                   IdentifierInfo *name,
594                                   SourceLocation colonLoc,
595                                   TypeSourceInfo *boundInfo);
596  static ObjCTypeParamDecl *CreateDeserialized(ASTContext &ctx, unsigned ID);
597
598  SourceRange getSourceRange() const override LLVM_READONLY;
599
600  /// Determine the variance of this type parameter.
601  ObjCTypeParamVariance getVariance() const {
602    return static_cast<ObjCTypeParamVariance>(Variance);
603  }
604
605  /// Set the variance of this type parameter.
606  void setVariance(ObjCTypeParamVariance variance) {
607    Variance = static_cast<unsigned>(variance);
608  }
609
610  /// Retrieve the location of the variance keyword.
611  SourceLocation getVarianceLoc() const { return VarianceLoc; }
612
613  /// Retrieve the index into its type parameter list.
614  unsigned getIndex() const { return Index; }
615
616  /// Whether this type parameter has an explicitly-written type bound, e.g.,
617  /// "T : NSView".
618  bool hasExplicitBound() const { return ColonLoc.isValid(); }
619
620  /// Retrieve the location of the ':' separating the type parameter name
621  /// from the explicitly-specified bound.
622  SourceLocation getColonLoc() const { return ColonLoc; }
623
624  // Implement isa/cast/dyncast/etc.
625  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
626  static bool classofKind(Kind K) { return K == ObjCTypeParam; }
627};
628
629/// Stores a list of Objective-C type parameters for a parameterized class
630/// or a category/extension thereof.
631///
632/// \code
633/// @interface NSArray<T> // stores the <T>
634/// @end
635/// \endcode
636class ObjCTypeParamList final
637    : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> {
638  /// Stores the components of a SourceRange as a POD.
639  struct PODSourceRange {
640    unsigned Begin;
641    unsigned End;
642  };
643
644  union {
645    /// Location of the left and right angle brackets.
646    PODSourceRange Brackets;
647
648    // Used only for alignment.
649    ObjCTypeParamDecl *AlignmentHack;
650  };
651
652  /// The number of parameters in the list, which are tail-allocated.
653  unsigned NumParams;
654
655  ObjCTypeParamList(SourceLocation lAngleLoc,
656                    ArrayRef<ObjCTypeParamDecl *> typeParams,
657                    SourceLocation rAngleLoc);
658
659public:
660  friend TrailingObjects;
661
662  /// Create a new Objective-C type parameter list.
663  static ObjCTypeParamList *create(ASTContext &ctx,
664                                   SourceLocation lAngleLoc,
665                                   ArrayRef<ObjCTypeParamDecl *> typeParams,
666                                   SourceLocation rAngleLoc);
667
668  /// Iterate through the type parameters in the list.
669  using iterator = ObjCTypeParamDecl **;
670
671  iterator begin() { return getTrailingObjects<ObjCTypeParamDecl *>(); }
672
673  iterator end() { return begin() + size(); }
674
675  /// Determine the number of type parameters in this list.
676  unsigned size() const { return NumParams; }
677
678  // Iterate through the type parameters in the list.
679  using const_iterator = ObjCTypeParamDecl * const *;
680
681  const_iterator begin() const {
682    return getTrailingObjects<ObjCTypeParamDecl *>();
683  }
684
685  const_iterator end() const {
686    return begin() + size();
687  }
688
689  ObjCTypeParamDecl *front() const {
690     (0) . __assert_fail ("size() > 0 && \"empty Objective-C type parameter list\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 690, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(size() > 0 && "empty Objective-C type parameter list");
691    return *begin();
692  }
693
694  ObjCTypeParamDecl *back() const {
695     (0) . __assert_fail ("size() > 0 && \"empty Objective-C type parameter list\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 695, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(size() > 0 && "empty Objective-C type parameter list");
696    return *(end() - 1);
697  }
698
699  SourceLocation getLAngleLoc() const {
700    return SourceLocation::getFromRawEncoding(Brackets.Begin);
701  }
702
703  SourceLocation getRAngleLoc() const {
704    return SourceLocation::getFromRawEncoding(Brackets.End);
705  }
706
707  SourceRange getSourceRange() const {
708    return SourceRange(getLAngleLoc(), getRAngleLoc());
709  }
710
711  /// Gather the default set of type arguments to be substituted for
712  /// these type parameters when dealing with an unspecialized type.
713  void gatherDefaultTypeArgs(SmallVectorImpl<QualType> &typeArgs) const;
714};
715
716enum class ObjCPropertyQueryKind : uint8_t {
717  OBJC_PR_query_unknown = 0x00,
718  OBJC_PR_query_instance,
719  OBJC_PR_query_class
720};
721
722/// Represents one property declaration in an Objective-C interface.
723///
724/// For example:
725/// \code{.mm}
726/// \@property (assign, readwrite) int MyProperty;
727/// \endcode
728class ObjCPropertyDecl : public NamedDecl {
729  void anchor() override;
730
731public:
732  enum PropertyAttributeKind {
733    OBJC_PR_noattr    = 0x00,
734    OBJC_PR_readonly  = 0x01,
735    OBJC_PR_getter    = 0x02,
736    OBJC_PR_assign    = 0x04,
737    OBJC_PR_readwrite = 0x08,
738    OBJC_PR_retain    = 0x10,
739    OBJC_PR_copy      = 0x20,
740    OBJC_PR_nonatomic = 0x40,
741    OBJC_PR_setter    = 0x80,
742    OBJC_PR_atomic    = 0x100,
743    OBJC_PR_weak      = 0x200,
744    OBJC_PR_strong    = 0x400,
745    OBJC_PR_unsafe_unretained = 0x800,
746    /// Indicates that the nullability of the type was spelled with a
747    /// property attribute rather than a type qualifier.
748    OBJC_PR_nullability = 0x1000,
749    OBJC_PR_null_resettable = 0x2000,
750    OBJC_PR_class = 0x4000
751    // Adding a property should change NumPropertyAttrsBits
752  };
753
754  enum {
755    /// Number of bits fitting all the property attributes.
756    NumPropertyAttrsBits = 15
757  };
758
759  enum SetterKind { Assign, Retain, Copy, Weak };
760  enum PropertyControl { None, Required, Optional };
761
762private:
763  // location of \@property
764  SourceLocation AtLoc;
765
766  // location of '(' starting attribute list or null.
767  SourceLocation LParenLoc;
768
769  QualType DeclType;
770  TypeSourceInfo *DeclTypeSourceInfo;
771  unsigned PropertyAttributes : NumPropertyAttrsBits;
772  unsigned PropertyAttributesAsWritten : NumPropertyAttrsBits;
773
774  // \@required/\@optional
775  unsigned PropertyImplementation : 2;
776
777  // getter name of NULL if no getter
778  Selector GetterName;
779
780  // setter name of NULL if no setter
781  Selector SetterName;
782
783  // location of the getter attribute's value
784  SourceLocation GetterNameLoc;
785
786  // location of the setter attribute's value
787  SourceLocation SetterNameLoc;
788
789  // Declaration of getter instance method
790  ObjCMethodDecl *GetterMethodDecl = nullptr;
791
792  // Declaration of setter instance method
793  ObjCMethodDecl *SetterMethodDecl = nullptr;
794
795  // Synthesize ivar for this property
796  ObjCIvarDecl *PropertyIvarDecl = nullptr;
797
798  ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
799                   SourceLocation AtLocation,  SourceLocation LParenLocation,
800                   QualType T, TypeSourceInfo *TSI,
801                   PropertyControl propControl)
802    : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation),
803      LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI),
804      PropertyAttributes(OBJC_PR_noattr),
805      PropertyAttributesAsWritten(OBJC_PR_noattr),
806      PropertyImplementation(propControl), GetterName(Selector()),
807      SetterName(Selector()) {}
808
809public:
810  static ObjCPropertyDecl *Create(ASTContext &C, DeclContext *DC,
811                                  SourceLocation L,
812                                  IdentifierInfo *Id, SourceLocation AtLocation,
813                                  SourceLocation LParenLocation,
814                                  QualType T,
815                                  TypeSourceInfo *TSI,
816                                  PropertyControl propControl = None);
817
818  static ObjCPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
819
820  SourceLocation getAtLoc() const { return AtLoc; }
821  void setAtLoc(SourceLocation L) { AtLoc = L; }
822
823  SourceLocation getLParenLoc() const { return LParenLoc; }
824  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
825
826  TypeSourceInfo *getTypeSourceInfo() const { return DeclTypeSourceInfo; }
827
828  QualType getType() const { return DeclType; }
829
830  void setType(QualType T, TypeSourceInfo *TSI) {
831    DeclType = T;
832    DeclTypeSourceInfo = TSI;
833  }
834
835  /// Retrieve the type when this property is used with a specific base object
836  /// type.
837  QualType getUsageType(QualType objectType) const;
838
839  PropertyAttributeKind getPropertyAttributes() const {
840    return PropertyAttributeKind(PropertyAttributes);
841  }
842
843  void setPropertyAttributes(PropertyAttributeKind PRVal) {
844    PropertyAttributes |= PRVal;
845  }
846
847  void overwritePropertyAttributes(unsigned PRVal) {
848    PropertyAttributes = PRVal;
849  }
850
851  PropertyAttributeKind getPropertyAttributesAsWritten() const {
852    return PropertyAttributeKind(PropertyAttributesAsWritten);
853  }
854
855  void setPropertyAttributesAsWritten(PropertyAttributeKind PRVal) {
856    PropertyAttributesAsWritten = PRVal;
857  }
858
859  // Helper methods for accessing attributes.
860
861  /// isReadOnly - Return true iff the property has a setter.
862  bool isReadOnly() const {
863    return (PropertyAttributes & OBJC_PR_readonly);
864  }
865
866  /// isAtomic - Return true if the property is atomic.
867  bool isAtomic() const {
868    return (PropertyAttributes & OBJC_PR_atomic);
869  }
870
871  /// isRetaining - Return true if the property retains its value.
872  bool isRetaining() const {
873    return (PropertyAttributes &
874            (OBJC_PR_retain | OBJC_PR_strong | OBJC_PR_copy));
875  }
876
877  bool isInstanceProperty() const { return !isClassProperty(); }
878  bool isClassProperty() const { return PropertyAttributes & OBJC_PR_class; }
879
880  ObjCPropertyQueryKind getQueryKind() const {
881    return isClassProperty() ? ObjCPropertyQueryKind::OBJC_PR_query_class :
882                               ObjCPropertyQueryKind::OBJC_PR_query_instance;
883  }
884
885  static ObjCPropertyQueryKind getQueryKind(bool isClassProperty) {
886    return isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class :
887                             ObjCPropertyQueryKind::OBJC_PR_query_instance;
888  }
889
890  /// getSetterKind - Return the method used for doing assignment in
891  /// the property setter. This is only valid if the property has been
892  /// defined to have a setter.
893  SetterKind getSetterKind() const {
894    if (PropertyAttributes & OBJC_PR_strong)
895      return getType()->isBlockPointerType() ? Copy : Retain;
896    if (PropertyAttributes & OBJC_PR_retain)
897      return Retain;
898    if (PropertyAttributes & OBJC_PR_copy)
899      return Copy;
900    if (PropertyAttributes & OBJC_PR_weak)
901      return Weak;
902    return Assign;
903  }
904
905  Selector getGetterName() const { return GetterName; }
906  SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
907
908  void setGetterName(Selector Sel, SourceLocation Loc = SourceLocation()) {
909    GetterName = Sel;
910    GetterNameLoc = Loc;
911  }
912
913  Selector getSetterName() const { return SetterName; }
914  SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
915
916  void setSetterName(Selector Sel, SourceLocation Loc = SourceLocation()) {
917    SetterName = Sel;
918    SetterNameLoc = Loc;
919  }
920
921  ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; }
922  void setGetterMethodDecl(ObjCMethodDecl *gDecl) { GetterMethodDecl = gDecl; }
923
924  ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; }
925  void setSetterMethodDecl(ObjCMethodDecl *gDecl) { SetterMethodDecl = gDecl; }
926
927  // Related to \@optional/\@required declared in \@protocol
928  void setPropertyImplementation(PropertyControl pc) {
929    PropertyImplementation = pc;
930  }
931
932  PropertyControl getPropertyImplementation() const {
933    return PropertyControl(PropertyImplementation);
934  }
935
936  bool isOptional() const {
937    return getPropertyImplementation() == PropertyControl::Optional;
938  }
939
940  void setPropertyIvarDecl(ObjCIvarDecl *Ivar) {
941    PropertyIvarDecl = Ivar;
942  }
943
944  ObjCIvarDecl *getPropertyIvarDecl() const {
945    return PropertyIvarDecl;
946  }
947
948  SourceRange getSourceRange() const override LLVM_READONLY {
949    return SourceRange(AtLoc, getLocation());
950  }
951
952  /// Get the default name of the synthesized ivar.
953  IdentifierInfo *getDefaultSynthIvarName(ASTContext &Ctx) const;
954
955  /// Lookup a property by name in the specified DeclContext.
956  static ObjCPropertyDecl *findPropertyDecl(const DeclContext *DC,
957                                            const IdentifierInfo *propertyID,
958                                            ObjCPropertyQueryKind queryKind);
959
960  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
961  static bool classofKind(Kind K) { return K == ObjCProperty; }
962};
963
964/// ObjCContainerDecl - Represents a container for method declarations.
965/// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl,
966/// ObjCProtocolDecl, and ObjCImplDecl.
967///
968class ObjCContainerDecl : public NamedDecl, public DeclContext {
969  // This class stores some data in DeclContext::ObjCContainerDeclBits
970  // to save some space. Use the provided accessors to access it.
971
972  // These two locations in the range mark the end of the method container.
973  // The first points to the '@' token, and the second to the 'end' token.
974  SourceRange AtEnd;
975
976  void anchor() override;
977
978public:
979  ObjCContainerDecl(Kind DK, DeclContext *DC, IdentifierInfo *Id,
980                    SourceLocation nameLoc, SourceLocation atStartLoc);
981
982  // Iterator access to instance/class properties.
983  using prop_iterator = specific_decl_iterator<ObjCPropertyDecl>;
984  using prop_range =
985      llvm::iterator_range<specific_decl_iterator<ObjCPropertyDecl>>;
986
987  prop_range properties() const { return prop_range(prop_begin(), prop_end()); }
988
989  prop_iterator prop_begin() const {
990    return prop_iterator(decls_begin());
991  }
992
993  prop_iterator prop_end() const {
994    return prop_iterator(decls_end());
995  }
996
997  using instprop_iterator =
998      filtered_decl_iterator<ObjCPropertyDecl,
999                             &ObjCPropertyDecl::isInstanceProperty>;
1000  using instprop_range = llvm::iterator_range<instprop_iterator>;
1001
1002  instprop_range instance_properties() const {
1003    return instprop_range(instprop_begin(), instprop_end());
1004  }
1005
1006  instprop_iterator instprop_begin() const {
1007    return instprop_iterator(decls_begin());
1008  }
1009
1010  instprop_iterator instprop_end() const {
1011    return instprop_iterator(decls_end());
1012  }
1013
1014  using classprop_iterator =
1015      filtered_decl_iterator<ObjCPropertyDecl,
1016                             &ObjCPropertyDecl::isClassProperty>;
1017  using classprop_range = llvm::iterator_range<classprop_iterator>;
1018
1019  classprop_range class_properties() const {
1020    return classprop_range(classprop_begin(), classprop_end());
1021  }
1022
1023  classprop_iterator classprop_begin() const {
1024    return classprop_iterator(decls_begin());
1025  }
1026
1027  classprop_iterator classprop_end() const {
1028    return classprop_iterator(decls_end());
1029  }
1030
1031  // Iterator access to instance/class methods.
1032  using method_iterator = specific_decl_iterator<ObjCMethodDecl>;
1033  using method_range =
1034      llvm::iterator_range<specific_decl_iterator<ObjCMethodDecl>>;
1035
1036  method_range methods() const {
1037    return method_range(meth_begin(), meth_end());
1038  }
1039
1040  method_iterator meth_begin() const {
1041    return method_iterator(decls_begin());
1042  }
1043
1044  method_iterator meth_end() const {
1045    return method_iterator(decls_end());
1046  }
1047
1048  using instmeth_iterator =
1049      filtered_decl_iterator<ObjCMethodDecl,
1050                             &ObjCMethodDecl::isInstanceMethod>;
1051  using instmeth_range = llvm::iterator_range<instmeth_iterator>;
1052
1053  instmeth_range instance_methods() const {
1054    return instmeth_range(instmeth_begin(), instmeth_end());
1055  }
1056
1057  instmeth_iterator instmeth_begin() const {
1058    return instmeth_iterator(decls_begin());
1059  }
1060
1061  instmeth_iterator instmeth_end() const {
1062    return instmeth_iterator(decls_end());
1063  }
1064
1065  using classmeth_iterator =
1066      filtered_decl_iterator<ObjCMethodDecl,
1067                             &ObjCMethodDecl::isClassMethod>;
1068  using classmeth_range = llvm::iterator_range<classmeth_iterator>;
1069
1070  classmeth_range class_methods() const {
1071    return classmeth_range(classmeth_begin(), classmeth_end());
1072  }
1073
1074  classmeth_iterator classmeth_begin() const {
1075    return classmeth_iterator(decls_begin());
1076  }
1077
1078  classmeth_iterator classmeth_end() const {
1079    return classmeth_iterator(decls_end());
1080  }
1081
1082  // Get the local instance/class method declared in this interface.
1083  ObjCMethodDecl *getMethod(Selector Sel, bool isInstance,
1084                            bool AllowHidden = false) const;
1085
1086  ObjCMethodDecl *getInstanceMethod(Selector Sel,
1087                                    bool AllowHidden = false) const {
1088    return getMethod(Sel, true/*isInstance*/, AllowHidden);
1089  }
1090
1091  ObjCMethodDecl *getClassMethod(Selector Sel, bool AllowHidden = false) const {
1092    return getMethod(Sel, false/*isInstance*/, AllowHidden);
1093  }
1094
1095  bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P) const;
1096  ObjCIvarDecl *getIvarDecl(IdentifierInfo *Id) const;
1097
1098  ObjCPropertyDecl *
1099  FindPropertyDeclaration(const IdentifierInfo *PropertyId,
1100                          ObjCPropertyQueryKind QueryKind) const;
1101
1102  using PropertyMap =
1103      llvm::DenseMap<std::pair<IdentifierInfo *, unsigned/*isClassProperty*/>,
1104                     ObjCPropertyDecl *>;
1105  using ProtocolPropertySet = llvm::SmallDenseSet<const ObjCProtocolDecl *, 8>;
1106  using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>;
1107
1108  /// This routine collects list of properties to be implemented in the class.
1109  /// This includes, class's and its conforming protocols' properties.
1110  /// Note, the superclass's properties are not included in the list.
1111  virtual void collectPropertiesToImplement(PropertyMap &PM,
1112                                            PropertyDeclOrder &PO) const {}
1113
1114  SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; }
1115
1116  void setAtStartLoc(SourceLocation Loc) {
1117    ObjCContainerDeclBits.AtStart = Loc;
1118  }
1119
1120  // Marks the end of the container.
1121  SourceRange getAtEndRange() const { return AtEnd; }
1122
1123  void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; }
1124
1125  SourceRange getSourceRange() const override LLVM_READONLY {
1126    return SourceRange(getAtStartLoc(), getAtEndRange().getEnd());
1127  }
1128
1129  // Implement isa/cast/dyncast/etc.
1130  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1131
1132  static bool classofKind(Kind K) {
1133    return K >= firstObjCContainer &&
1134           K <= lastObjCContainer;
1135  }
1136
1137  static DeclContext *castToDeclContext(const ObjCContainerDecl *D) {
1138    return static_cast<DeclContext *>(const_cast<ObjCContainerDecl*>(D));
1139  }
1140
1141  static ObjCContainerDecl *castFromDeclContext(const DeclContext *DC) {
1142    return static_cast<ObjCContainerDecl *>(const_cast<DeclContext*>(DC));
1143  }
1144};
1145
1146/// Represents an ObjC class declaration.
1147///
1148/// For example:
1149///
1150/// \code
1151///   // MostPrimitive declares no super class (not particularly useful).
1152///   \@interface MostPrimitive
1153///     // no instance variables or methods.
1154///   \@end
1155///
1156///   // NSResponder inherits from NSObject & implements NSCoding (a protocol).
1157///   \@interface NSResponder : NSObject \<NSCoding>
1158///   { // instance variables are represented by ObjCIvarDecl.
1159///     id nextResponder; // nextResponder instance variable.
1160///   }
1161///   - (NSResponder *)nextResponder; // return a pointer to NSResponder.
1162///   - (void)mouseMoved:(NSEvent *)theEvent; // return void, takes a pointer
1163///   \@end                                    // to an NSEvent.
1164/// \endcode
1165///
1166///   Unlike C/C++, forward class declarations are accomplished with \@class.
1167///   Unlike C/C++, \@class allows for a list of classes to be forward declared.
1168///   Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes
1169///   typically inherit from NSObject (an exception is NSProxy).
1170///
1171class ObjCInterfaceDecl : public ObjCContainerDecl
1172                        , public Redeclarable<ObjCInterfaceDecl> {
1173  friend class ASTContext;
1174
1175  /// TypeForDecl - This indicates the Type object that represents this
1176  /// TypeDecl.  It is a cache maintained by ASTContext::getObjCInterfaceType
1177  mutable const Type *TypeForDecl = nullptr;
1178
1179  struct DefinitionData {
1180    /// The definition of this class, for quick access from any
1181    /// declaration.
1182    ObjCInterfaceDecl *Definition = nullptr;
1183
1184    /// When non-null, this is always an ObjCObjectType.
1185    TypeSourceInfo *SuperClassTInfo = nullptr;
1186
1187    /// Protocols referenced in the \@interface  declaration
1188    ObjCProtocolList ReferencedProtocols;
1189
1190    /// Protocols reference in both the \@interface and class extensions.
1191    ObjCList<ObjCProtocolDecl> AllReferencedProtocols;
1192
1193    /// List of categories and class extensions defined for this class.
1194    ///
1195    /// Categories are stored as a linked list in the AST, since the categories
1196    /// and class extensions come long after the initial interface declaration,
1197    /// and we avoid dynamically-resized arrays in the AST wherever possible.
1198    ObjCCategoryDecl *CategoryList = nullptr;
1199
1200    /// IvarList - List of all ivars defined by this class; including class
1201    /// extensions and implementation. This list is built lazily.
1202    ObjCIvarDecl *IvarList = nullptr;
1203
1204    /// Indicates that the contents of this Objective-C class will be
1205    /// completed by the external AST source when required.
1206    mutable unsigned ExternallyCompleted : 1;
1207
1208    /// Indicates that the ivar cache does not yet include ivars
1209    /// declared in the implementation.
1210    mutable unsigned IvarListMissingImplementation : 1;
1211
1212    /// Indicates that this interface decl contains at least one initializer
1213    /// marked with the 'objc_designated_initializer' attribute.
1214    unsigned HasDesignatedInitializers : 1;
1215
1216    enum InheritedDesignatedInitializersState {
1217      /// We didn't calculate whether the designated initializers should be
1218      /// inherited or not.
1219      IDI_Unknown = 0,
1220
1221      /// Designated initializers are inherited for the super class.
1222      IDI_Inherited = 1,
1223
1224      /// The class does not inherit designated initializers.
1225      IDI_NotInherited = 2
1226    };
1227
1228    /// One of the \c InheritedDesignatedInitializersState enumeratos.
1229    mutable unsigned InheritedDesignatedInitializers : 2;
1230
1231    /// The location of the last location in this declaration, before
1232    /// the properties/methods. For example, this will be the '>', '}', or
1233    /// identifier,
1234    SourceLocation EndLoc;
1235
1236    DefinitionData()
1237        : ExternallyCompleted(false), IvarListMissingImplementation(true),
1238          HasDesignatedInitializers(false),
1239          InheritedDesignatedInitializers(IDI_Unknown) {}
1240  };
1241
1242  /// The type parameters associated with this class, if any.
1243  ObjCTypeParamList *TypeParamList = nullptr;
1244
1245  /// Contains a pointer to the data associated with this class,
1246  /// which will be NULL if this class has not yet been defined.
1247  ///
1248  /// The bit indicates when we don't need to check for out-of-date
1249  /// declarations. It will be set unless modules are enabled.
1250  llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
1251
1252  ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC, SourceLocation AtLoc,
1253                    IdentifierInfo *Id, ObjCTypeParamList *typeParamList,
1254                    SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
1255                    bool IsInternal);
1256
1257  void anchor() override;
1258
1259  void LoadExternalDefinition() const;
1260
1261  DefinitionData &data() const {
1262     (0) . __assert_fail ("Data.getPointer() && \"Declaration has no definition!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 1262, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Data.getPointer() && "Declaration has no definition!");
1263    return *Data.getPointer();
1264  }
1265
1266  /// Allocate the definition data for this class.
1267  void allocateDefinitionData();
1268
1269  using redeclarable_base = Redeclarable<ObjCInterfaceDecl>;
1270
1271  ObjCInterfaceDecl *getNextRedeclarationImpl() override {
1272    return getNextRedeclaration();
1273  }
1274
1275  ObjCInterfaceDecl *getPreviousDeclImpl() override {
1276    return getPreviousDecl();
1277  }
1278
1279  ObjCInterfaceDecl *getMostRecentDeclImpl() override {
1280    return getMostRecentDecl();
1281  }
1282
1283public:
1284  static ObjCInterfaceDecl *Create(const ASTContext &C, DeclContext *DC,
1285                                   SourceLocation atLoc,
1286                                   IdentifierInfo *Id,
1287                                   ObjCTypeParamList *typeParamList,
1288                                   ObjCInterfaceDecl *PrevDecl,
1289                                   SourceLocation ClassLoc = SourceLocation(),
1290                                   bool isInternal = false);
1291
1292  static ObjCInterfaceDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
1293
1294  /// Retrieve the type parameters of this class.
1295  ///
1296  /// This function looks for a type parameter list for the given
1297  /// class; if the class has been declared (with \c \@class) but not
1298  /// defined (with \c \@interface), it will search for a declaration that
1299  /// has type parameters, skipping any declarations that do not.
1300  ObjCTypeParamList *getTypeParamList() const;
1301
1302  /// Set the type parameters of this class.
1303  ///
1304  /// This function is used by the AST importer, which must import the type
1305  /// parameters after creating their DeclContext to avoid loops.
1306  void setTypeParamList(ObjCTypeParamList *TPL);
1307
1308  /// Retrieve the type parameters written on this particular declaration of
1309  /// the class.
1310  ObjCTypeParamList *getTypeParamListAsWritten() const {
1311    return TypeParamList;
1312  }
1313
1314  SourceRange getSourceRange() const override LLVM_READONLY {
1315    if (isThisDeclarationADefinition())
1316      return ObjCContainerDecl::getSourceRange();
1317
1318    return SourceRange(getAtStartLoc(), getLocation());
1319  }
1320
1321  /// Indicate that this Objective-C class is complete, but that
1322  /// the external AST source will be responsible for filling in its contents
1323  /// when a complete class is required.
1324  void setExternallyCompleted();
1325
1326  /// Indicate that this interface decl contains at least one initializer
1327  /// marked with the 'objc_designated_initializer' attribute.
1328  void setHasDesignatedInitializers();
1329
1330  /// Returns true if this interface decl contains at least one initializer
1331  /// marked with the 'objc_designated_initializer' attribute.
1332  bool hasDesignatedInitializers() const;
1333
1334  /// Returns true if this interface decl declares a designated initializer
1335  /// or it inherites one from its super class.
1336  bool declaresOrInheritsDesignatedInitializers() const {
1337    return hasDesignatedInitializers() || inheritsDesignatedInitializers();
1338  }
1339
1340  const ObjCProtocolList &getReferencedProtocols() const {
1341     (0) . __assert_fail ("hasDefinition() && \"Caller did not check for forward reference!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 1341, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(hasDefinition() && "Caller did not check for forward reference!");
1342    if (data().ExternallyCompleted)
1343      LoadExternalDefinition();
1344
1345    return data().ReferencedProtocols;
1346  }
1347
1348  ObjCImplementationDecl *getImplementation() const;
1349  void setImplementation(ObjCImplementationDecl *ImplD);
1350
1351  ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const;
1352
1353  // Get the local instance/class method declared in a category.
1354  ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel) const;
1355  ObjCMethodDecl *getCategoryClassMethod(Selector Sel) const;
1356
1357  ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance) const {
1358    return isInstance ? getCategoryInstanceMethod(Sel)
1359                      : getCategoryClassMethod(Sel);
1360  }
1361
1362  using protocol_iterator = ObjCProtocolList::iterator;
1363  using protocol_range = llvm::iterator_range<protocol_iterator>;
1364
1365  protocol_range protocols() const {
1366    return protocol_range(protocol_begin(), protocol_end());
1367  }
1368
1369  protocol_iterator protocol_begin() const {
1370    // FIXME: Should make sure no callers ever do this.
1371    if (!hasDefinition())
1372      return protocol_iterator();
1373
1374    if (data().ExternallyCompleted)
1375      LoadExternalDefinition();
1376
1377    return data().ReferencedProtocols.begin();
1378  }
1379
1380  protocol_iterator protocol_end() const {
1381    // FIXME: Should make sure no callers ever do this.
1382    if (!hasDefinition())
1383      return protocol_iterator();
1384
1385    if (data().ExternallyCompleted)
1386      LoadExternalDefinition();
1387
1388    return data().ReferencedProtocols.end();
1389  }
1390
1391  using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
1392  using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;
1393
1394  protocol_loc_range protocol_locs() const {
1395    return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
1396  }
1397
1398  protocol_loc_iterator protocol_loc_begin() const {
1399    // FIXME: Should make sure no callers ever do this.
1400    if (!hasDefinition())
1401      return protocol_loc_iterator();
1402
1403    if (data().ExternallyCompleted)
1404      LoadExternalDefinition();
1405
1406    return data().ReferencedProtocols.loc_begin();
1407  }
1408
1409  protocol_loc_iterator protocol_loc_end() const {
1410    // FIXME: Should make sure no callers ever do this.
1411    if (!hasDefinition())
1412      return protocol_loc_iterator();
1413
1414    if (data().ExternallyCompleted)
1415      LoadExternalDefinition();
1416
1417    return data().ReferencedProtocols.loc_end();
1418  }
1419
1420  using all_protocol_iterator = ObjCList<ObjCProtocolDecl>::iterator;
1421  using all_protocol_range = llvm::iterator_range<all_protocol_iterator>;
1422
1423  all_protocol_range all_referenced_protocols() const {
1424    return all_protocol_range(all_referenced_protocol_begin(),
1425                              all_referenced_protocol_end());
1426  }
1427
1428  all_protocol_iterator all_referenced_protocol_begin() const {
1429    // FIXME: Should make sure no callers ever do this.
1430    if (!hasDefinition())
1431      return all_protocol_iterator();
1432
1433    if (data().ExternallyCompleted)
1434      LoadExternalDefinition();
1435
1436    return data().AllReferencedProtocols.empty()
1437             ? protocol_begin()
1438             : data().AllReferencedProtocols.begin();
1439  }
1440
1441  all_protocol_iterator all_referenced_protocol_end() const {
1442    // FIXME: Should make sure no callers ever do this.
1443    if (!hasDefinition())
1444      return all_protocol_iterator();
1445
1446    if (data().ExternallyCompleted)
1447      LoadExternalDefinition();
1448
1449    return data().AllReferencedProtocols.empty()
1450             ? protocol_end()
1451             : data().AllReferencedProtocols.end();
1452  }
1453
1454  using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
1455  using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;
1456
1457  ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }
1458
1459  ivar_iterator ivar_begin() const {
1460    if (const ObjCInterfaceDecl *Def = getDefinition())
1461      return ivar_iterator(Def->decls_begin());
1462
1463    // FIXME: Should make sure no callers ever do this.
1464    return ivar_iterator();
1465  }
1466
1467  ivar_iterator ivar_end() const {
1468    if (const ObjCInterfaceDecl *Def = getDefinition())
1469      return ivar_iterator(Def->decls_end());
1470
1471    // FIXME: Should make sure no callers ever do this.
1472    return ivar_iterator();
1473  }
1474
1475  unsigned ivar_size() const {
1476    return std::distance(ivar_begin(), ivar_end());
1477  }
1478
1479  bool ivar_empty() const { return ivar_begin() == ivar_end(); }
1480
1481  ObjCIvarDecl *all_declared_ivar_begin();
1482  const ObjCIvarDecl *all_declared_ivar_begin() const {
1483    // Even though this modifies IvarList, it's conceptually const:
1484    // the ivar chain is essentially a cached property of ObjCInterfaceDecl.
1485    return const_cast<ObjCInterfaceDecl *>(this)->all_declared_ivar_begin();
1486  }
1487  void setIvarList(ObjCIvarDecl *ivar) { data().IvarList = ivar; }
1488
1489  /// setProtocolList - Set the list of protocols that this interface
1490  /// implements.
1491  void setProtocolList(ObjCProtocolDecl *const* List, unsigned Num,
1492                       const SourceLocation *Locs, ASTContext &C) {
1493    data().ReferencedProtocols.set(List, Num, Locs, C);
1494  }
1495
1496  /// mergeClassExtensionProtocolList - Merge class extension's protocol list
1497  /// into the protocol list for this class.
1498  void mergeClassExtensionProtocolList(ObjCProtocolDecl *const* List,
1499                                       unsigned Num,
1500                                       ASTContext &C);
1501
1502  /// Produce a name to be used for class's metadata. It comes either via
1503  /// objc_runtime_name attribute or class name.
1504  StringRef getObjCRuntimeNameAsString() const;
1505
1506  /// Returns the designated initializers for the interface.
1507  ///
1508  /// If this declaration does not have methods marked as designated
1509  /// initializers then the interface inherits the designated initializers of
1510  /// its super class.
1511  void getDesignatedInitializers(
1512                  llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const;
1513
1514  /// Returns true if the given selector is a designated initializer for the
1515  /// interface.
1516  ///
1517  /// If this declaration does not have methods marked as designated
1518  /// initializers then the interface inherits the designated initializers of
1519  /// its super class.
1520  ///
1521  /// \param InitMethod if non-null and the function returns true, it receives
1522  /// the method that was marked as a designated initializer.
1523  bool
1524  isDesignatedInitializer(Selector Sel,
1525                          const ObjCMethodDecl **InitMethod = nullptr) const;
1526
1527  /// Determine whether this particular declaration of this class is
1528  /// actually also a definition.
1529  bool isThisDeclarationADefinition() const {
1530    return getDefinition() == this;
1531  }
1532
1533  /// Determine whether this class has been defined.
1534  bool hasDefinition() const {
1535    // If the name of this class is out-of-date, bring it up-to-date, which
1536    // might bring in a definition.
1537    // Note: a null value indicates that we don't have a definition and that
1538    // modules are enabled.
1539    if (!Data.getOpaqueValue())
1540      getMostRecentDecl();
1541
1542    return Data.getPointer();
1543  }
1544
1545  /// Retrieve the definition of this class, or NULL if this class
1546  /// has been forward-declared (with \@class) but not yet defined (with
1547  /// \@interface).
1548  ObjCInterfaceDecl *getDefinition() {
1549    return hasDefinition()? Data.getPointer()->Definition : nullptr;
1550  }
1551
1552  /// Retrieve the definition of this class, or NULL if this class
1553  /// has been forward-declared (with \@class) but not yet defined (with
1554  /// \@interface).
1555  const ObjCInterfaceDecl *getDefinition() const {
1556    return hasDefinition()? Data.getPointer()->Definition : nullptr;
1557  }
1558
1559  /// Starts the definition of this Objective-C class, taking it from
1560  /// a forward declaration (\@class) to a definition (\@interface).
1561  void startDefinition();
1562
1563  /// Retrieve the superclass type.
1564  const ObjCObjectType *getSuperClassType() const {
1565    if (TypeSourceInfo *TInfo = getSuperClassTInfo())
1566      return TInfo->getType()->castAs<ObjCObjectType>();
1567
1568    return nullptr;
1569  }
1570
1571  // Retrieve the type source information for the superclass.
1572  TypeSourceInfo *getSuperClassTInfo() const {
1573    // FIXME: Should make sure no callers ever do this.
1574    if (!hasDefinition())
1575      return nullptr;
1576
1577    if (data().ExternallyCompleted)
1578      LoadExternalDefinition();
1579
1580    return data().SuperClassTInfo;
1581  }
1582
1583  // Retrieve the declaration for the superclass of this class, which
1584  // does not include any type arguments that apply to the superclass.
1585  ObjCInterfaceDecl *getSuperClass() const;
1586
1587  void setSuperClass(TypeSourceInfo *superClass) {
1588    data().SuperClassTInfo = superClass;
1589  }
1590
1591  /// Iterator that walks over the list of categories, filtering out
1592  /// those that do not meet specific criteria.
1593  ///
1594  /// This class template is used for the various permutations of category
1595  /// and extension iterators.
1596  template<bool (*Filter)(ObjCCategoryDecl *)>
1597  class filtered_category_iterator {
1598    ObjCCategoryDecl *Current = nullptr;
1599
1600    void findAcceptableCategory();
1601
1602  public:
1603    using value_type = ObjCCategoryDecl *;
1604    using reference = value_type;
1605    using pointer = value_type;
1606    using difference_type = std::ptrdiff_t;
1607    using iterator_category = std::input_iterator_tag;
1608
1609    filtered_category_iterator() = default;
1610    explicit filtered_category_iterator(ObjCCategoryDecl *Current)
1611        : Current(Current) {
1612      findAcceptableCategory();
1613    }
1614
1615    reference operator*() const { return Current; }
1616    pointer operator->() const { return Current; }
1617
1618    filtered_category_iterator &operator++();
1619
1620    filtered_category_iterator operator++(int) {
1621      filtered_category_iterator Tmp = *this;
1622      ++(*this);
1623      return Tmp;
1624    }
1625
1626    friend bool operator==(filtered_category_iterator X,
1627                           filtered_category_iterator Y) {
1628      return X.Current == Y.Current;
1629    }
1630
1631    friend bool operator!=(filtered_category_iterator X,
1632                           filtered_category_iterator Y) {
1633      return X.Current != Y.Current;
1634    }
1635  };
1636
1637private:
1638  /// Test whether the given category is visible.
1639  ///
1640  /// Used in the \c visible_categories_iterator.
1641  static bool isVisibleCategory(ObjCCategoryDecl *Cat);
1642
1643public:
1644  /// Iterator that walks over the list of categories and extensions
1645  /// that are visible, i.e., not hidden in a non-imported submodule.
1646  using visible_categories_iterator =
1647      filtered_category_iterator<isVisibleCategory>;
1648
1649  using visible_categories_range =
1650      llvm::iterator_range<visible_categories_iterator>;
1651
1652  visible_categories_range visible_categories() const {
1653    return visible_categories_range(visible_categories_begin(),
1654                                    visible_categories_end());
1655  }
1656
1657  /// Retrieve an iterator to the beginning of the visible-categories
1658  /// list.
1659  visible_categories_iterator visible_categories_begin() const {
1660    return visible_categories_iterator(getCategoryListRaw());
1661  }
1662
1663  /// Retrieve an iterator to the end of the visible-categories list.
1664  visible_categories_iterator visible_categories_end() const {
1665    return visible_categories_iterator();
1666  }
1667
1668  /// Determine whether the visible-categories list is empty.
1669  bool visible_categories_empty() const {
1670    return visible_categories_begin() == visible_categories_end();
1671  }
1672
1673private:
1674  /// Test whether the given category... is a category.
1675  ///
1676  /// Used in the \c known_categories_iterator.
1677  static bool isKnownCategory(ObjCCategoryDecl *) { return true; }
1678
1679public:
1680  /// Iterator that walks over all of the known categories and
1681  /// extensions, including those that are hidden.
1682  using known_categories_iterator = filtered_category_iterator<isKnownCategory>;
1683  using known_categories_range =
1684     llvm::iterator_range<known_categories_iterator>;
1685
1686  known_categories_range known_categories() const {
1687    return known_categories_range(known_categories_begin(),
1688                                  known_categories_end());
1689  }
1690
1691  /// Retrieve an iterator to the beginning of the known-categories
1692  /// list.
1693  known_categories_iterator known_categories_begin() const {
1694    return known_categories_iterator(getCategoryListRaw());
1695  }
1696
1697  /// Retrieve an iterator to the end of the known-categories list.
1698  known_categories_iterator known_categories_end() const {
1699    return known_categories_iterator();
1700  }
1701
1702  /// Determine whether the known-categories list is empty.
1703  bool known_categories_empty() const {
1704    return known_categories_begin() == known_categories_end();
1705  }
1706
1707private:
1708  /// Test whether the given category is a visible extension.
1709  ///
1710  /// Used in the \c visible_extensions_iterator.
1711  static bool isVisibleExtension(ObjCCategoryDecl *Cat);
1712
1713public:
1714  /// Iterator that walks over all of the visible extensions, skipping
1715  /// any that are known but hidden.
1716  using visible_extensions_iterator =
1717      filtered_category_iterator<isVisibleExtension>;
1718
1719  using visible_extensions_range =
1720      llvm::iterator_range<visible_extensions_iterator>;
1721
1722  visible_extensions_range visible_extensions() const {
1723    return visible_extensions_range(visible_extensions_begin(),
1724                                    visible_extensions_end());
1725  }
1726
1727  /// Retrieve an iterator to the beginning of the visible-extensions
1728  /// list.
1729  visible_extensions_iterator visible_extensions_begin() const {
1730    return visible_extensions_iterator(getCategoryListRaw());
1731  }
1732
1733  /// Retrieve an iterator to the end of the visible-extensions list.
1734  visible_extensions_iterator visible_extensions_end() const {
1735    return visible_extensions_iterator();
1736  }
1737
1738  /// Determine whether the visible-extensions list is empty.
1739  bool visible_extensions_empty() const {
1740    return visible_extensions_begin() == visible_extensions_end();
1741  }
1742
1743private:
1744  /// Test whether the given category is an extension.
1745  ///
1746  /// Used in the \c known_extensions_iterator.
1747  static bool isKnownExtension(ObjCCategoryDecl *Cat);
1748
1749public:
1750  friend class ASTDeclReader;
1751  friend class ASTDeclWriter;
1752  friend class ASTReader;
1753
1754  /// Iterator that walks over all of the known extensions.
1755  using known_extensions_iterator =
1756      filtered_category_iterator<isKnownExtension>;
1757  using known_extensions_range =
1758      llvm::iterator_range<known_extensions_iterator>;
1759
1760  known_extensions_range known_extensions() const {
1761    return known_extensions_range(known_extensions_begin(),
1762                                  known_extensions_end());
1763  }
1764
1765  /// Retrieve an iterator to the beginning of the known-extensions
1766  /// list.
1767  known_extensions_iterator known_extensions_begin() const {
1768    return known_extensions_iterator(getCategoryListRaw());
1769  }
1770
1771  /// Retrieve an iterator to the end of the known-extensions list.
1772  known_extensions_iterator known_extensions_end() const {
1773    return known_extensions_iterator();
1774  }
1775
1776  /// Determine whether the known-extensions list is empty.
1777  bool known_extensions_empty() const {
1778    return known_extensions_begin() == known_extensions_end();
1779  }
1780
1781  /// Retrieve the raw pointer to the start of the category/extension
1782  /// list.
1783  ObjCCategoryDecl* getCategoryListRaw() const {
1784    // FIXME: Should make sure no callers ever do this.
1785    if (!hasDefinition())
1786      return nullptr;
1787
1788    if (data().ExternallyCompleted)
1789      LoadExternalDefinition();
1790
1791    return data().CategoryList;
1792  }
1793
1794  /// Set the raw pointer to the start of the category/extension
1795  /// list.
1796  void setCategoryListRaw(ObjCCategoryDecl *category) {
1797    data().CategoryList = category;
1798  }
1799
1800  ObjCPropertyDecl
1801    *FindPropertyVisibleInPrimaryClass(IdentifierInfo *PropertyId,
1802                                       ObjCPropertyQueryKind QueryKind) const;
1803
1804  void collectPropertiesToImplement(PropertyMap &PM,
1805                                    PropertyDeclOrder &PO) const override;
1806
1807  /// isSuperClassOf - Return true if this class is the specified class or is a
1808  /// super class of the specified interface class.
1809  bool isSuperClassOf(const ObjCInterfaceDecl *I) const {
1810    // If RHS is derived from LHS it is OK; else it is not OK.
1811    while (I != nullptr) {
1812      if (declaresSameEntity(this, I))
1813        return true;
1814
1815      I = I->getSuperClass();
1816    }
1817    return false;
1818  }
1819
1820  /// isArcWeakrefUnavailable - Checks for a class or one of its super classes
1821  /// to be incompatible with __weak references. Returns true if it is.
1822  bool isArcWeakrefUnavailable() const;
1823
1824  /// isObjCRequiresPropertyDefs - Checks that a class or one of its super
1825  /// classes must not be auto-synthesized. Returns class decl. if it must not
1826  /// be; 0, otherwise.
1827  const ObjCInterfaceDecl *isObjCRequiresPropertyDefs() const;
1828
1829  ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName,
1830                                       ObjCInterfaceDecl *&ClassDeclared);
1831  ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName) {
1832    ObjCInterfaceDecl *ClassDeclared;
1833    return lookupInstanceVariable(IVarName, ClassDeclared);
1834  }
1835
1836  ObjCProtocolDecl *lookupNestedProtocol(IdentifierInfo *Name);
1837
1838  // Lookup a method. First, we search locally. If a method isn't
1839  // found, we search referenced protocols and class categories.
1840  ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance,
1841                               bool shallowCategoryLookup = false,
1842                               bool followSuper = true,
1843                               const ObjCCategoryDecl *C = nullptr) const;
1844
1845  /// Lookup an instance method for a given selector.
1846  ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
1847    return lookupMethod(Sel, true/*isInstance*/);
1848  }
1849
1850  /// Lookup a class method for a given selector.
1851  ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
1852    return lookupMethod(Sel, false/*isInstance*/);
1853  }
1854
1855  ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);
1856
1857  /// Lookup a method in the classes implementation hierarchy.
1858  ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
1859                                      bool Instance=true) const;
1860
1861  ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) {
1862    return lookupPrivateMethod(Sel, false);
1863  }
1864
1865  /// Lookup a setter or getter in the class hierarchy,
1866  /// including in all categories except for category passed
1867  /// as argument.
1868  ObjCMethodDecl *lookupPropertyAccessor(const Selector Sel,
1869                                         const ObjCCategoryDecl *Cat,
1870                                         bool IsClassProperty) const {
1871    return lookupMethod(Sel, !IsClassProperty/*isInstance*/,
1872                        false/*shallowCategoryLookup*/,
1873                        true /* followsSuper */,
1874                        Cat);
1875  }
1876
1877  SourceLocation getEndOfDefinitionLoc() const {
1878    if (!hasDefinition())
1879      return getLocation();
1880
1881    return data().EndLoc;
1882  }
1883
1884  void setEndOfDefinitionLoc(SourceLocation LE) { data().EndLoc = LE; }
1885
1886  /// Retrieve the starting location of the superclass.
1887  SourceLocation getSuperClassLoc() const;
1888
1889  /// isImplicitInterfaceDecl - check that this is an implicitly declared
1890  /// ObjCInterfaceDecl node. This is for legacy objective-c \@implementation
1891  /// declaration without an \@interface declaration.
1892  bool isImplicitInterfaceDecl() const {
1893    return hasDefinition() ? data().Definition->isImplicit() : isImplicit();
1894  }
1895
1896  /// ClassImplementsProtocol - Checks that 'lProto' protocol
1897  /// has been implemented in IDecl class, its super class or categories (if
1898  /// lookupCategory is true).
1899  bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
1900                               bool lookupCategory,
1901                               bool RHSIsQualifiedID = false);
1902
1903  using redecl_range = redeclarable_base::redecl_range;
1904  using redecl_iterator = redeclarable_base::redecl_iterator;
1905
1906  using redeclarable_base::redecls_begin;
1907  using redeclarable_base::redecls_end;
1908  using redeclarable_base::redecls;
1909  using redeclarable_base::getPreviousDecl;
1910  using redeclarable_base::getMostRecentDecl;
1911  using redeclarable_base::isFirstDecl;
1912
1913  /// Retrieves the canonical declaration of this Objective-C class.
1914  ObjCInterfaceDecl *getCanonicalDecl() override { return getFirstDecl(); }
1915  const ObjCInterfaceDecl *getCanonicalDecl() const { return getFirstDecl(); }
1916
1917  // Low-level accessor
1918  const Type *getTypeForDecl() const { return TypeForDecl; }
1919  void setTypeForDecl(const Type *TD) const { TypeForDecl = TD; }
1920
1921  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1922  static bool classofKind(Kind K) { return K == ObjCInterface; }
1923
1924private:
1925  const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const;
1926  bool inheritsDesignatedInitializers() const;
1927};
1928
1929/// ObjCIvarDecl - Represents an ObjC instance variable. In general, ObjC
1930/// instance variables are identical to C. The only exception is Objective-C
1931/// supports C++ style access control. For example:
1932///
1933///   \@interface IvarExample : NSObject
1934///   {
1935///     id defaultToProtected;
1936///   \@public:
1937///     id canBePublic; // same as C++.
1938///   \@protected:
1939///     id canBeProtected; // same as C++.
1940///   \@package:
1941///     id canBePackage; // framework visibility (not available in C++).
1942///   }
1943///
1944class ObjCIvarDecl : public FieldDecl {
1945  void anchor() override;
1946
1947public:
1948  enum AccessControl {
1949    None, Private, Protected, Public, Package
1950  };
1951
1952private:
1953  ObjCIvarDecl(ObjCContainerDecl *DC, SourceLocation StartLoc,
1954               SourceLocation IdLoc, IdentifierInfo *Id,
1955               QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW,
1956               bool synthesized)
1957      : FieldDecl(ObjCIvar, DC, StartLoc, IdLoc, Id, T, TInfo, BW,
1958                  /*Mutable=*/false, /*HasInit=*/ICIS_NoInit),
1959        DeclAccess(ac), Synthesized(synthesized) {}
1960
1961public:
1962  static ObjCIvarDecl *Create(ASTContext &C, ObjCContainerDecl *DC,
1963                              SourceLocation StartLoc, SourceLocation IdLoc,
1964                              IdentifierInfo *Id, QualType T,
1965                              TypeSourceInfo *TInfo,
1966                              AccessControl ac, Expr *BW = nullptr,
1967                              bool synthesized=false);
1968
1969  static ObjCIvarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1970
1971  /// Return the class interface that this ivar is logically contained
1972  /// in; this is either the interface where the ivar was declared, or the
1973  /// interface the ivar is conceptually a part of in the case of synthesized
1974  /// ivars.
1975  const ObjCInterfaceDecl *getContainingInterface() const;
1976
1977  ObjCIvarDecl *getNextIvar() { return NextIvar; }
1978  const ObjCIvarDecl *getNextIvar() const { return NextIvar; }
1979  void setNextIvar(ObjCIvarDecl *ivar) { NextIvar = ivar; }
1980
1981  void setAccessControl(AccessControl ac) { DeclAccess = ac; }
1982
1983  AccessControl getAccessControl() const { return AccessControl(DeclAccess); }
1984
1985  AccessControl getCanonicalAccessControl() const {
1986    return DeclAccess == None ? Protected : AccessControl(DeclAccess);
1987  }
1988
1989  void setSynthesize(bool synth) { Synthesized = synth; }
1990  bool getSynthesize() const { return Synthesized; }
1991
1992  /// Retrieve the type of this instance variable when viewed as a member of a
1993  /// specific object type.
1994  QualType getUsageType(QualType objectType) const;
1995
1996  // Implement isa/cast/dyncast/etc.
1997  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1998  static bool classofKind(Kind K) { return K == ObjCIvar; }
1999
2000private:
2001  /// NextIvar - Next Ivar in the list of ivars declared in class; class's
2002  /// extensions and class's implementation
2003  ObjCIvarDecl *NextIvar = nullptr;
2004
2005  // NOTE: VC++ treats enums as signed, avoid using the AccessControl enum
2006  unsigned DeclAccess : 3;
2007  unsigned Synthesized : 1;
2008};
2009
2010/// Represents a field declaration created by an \@defs(...).
2011class ObjCAtDefsFieldDecl : public FieldDecl {
2012  ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc,
2013                      SourceLocation IdLoc, IdentifierInfo *Id,
2014                      QualType T, Expr *BW)
2015      : FieldDecl(ObjCAtDefsField, DC, StartLoc, IdLoc, Id, T,
2016                  /*TInfo=*/nullptr, // FIXME: Do ObjCAtDefs have declarators ?
2017                  BW, /*Mutable=*/false, /*HasInit=*/ICIS_NoInit) {}
2018
2019  void anchor() override;
2020
2021public:
2022  static ObjCAtDefsFieldDecl *Create(ASTContext &C, DeclContext *DC,
2023                                     SourceLocation StartLoc,
2024                                     SourceLocation IdLoc, IdentifierInfo *Id,
2025                                     QualType T, Expr *BW);
2026
2027  static ObjCAtDefsFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2028
2029  // Implement isa/cast/dyncast/etc.
2030  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2031  static bool classofKind(Kind K) { return K == ObjCAtDefsField; }
2032};
2033
2034/// Represents an Objective-C protocol declaration.
2035///
2036/// Objective-C protocols declare a pure abstract type (i.e., no instance
2037/// variables are permitted).  Protocols originally drew inspiration from
2038/// C++ pure virtual functions (a C++ feature with nice semantics and lousy
2039/// syntax:-). Here is an example:
2040///
2041/// \code
2042/// \@protocol NSDraggingInfo <refproto1, refproto2>
2043/// - (NSWindow *)draggingDestinationWindow;
2044/// - (NSImage *)draggedImage;
2045/// \@end
2046/// \endcode
2047///
2048/// This says that NSDraggingInfo requires two methods and requires everything
2049/// that the two "referenced protocols" 'refproto1' and 'refproto2' require as
2050/// well.
2051///
2052/// \code
2053/// \@interface ImplementsNSDraggingInfo : NSObject \<NSDraggingInfo>
2054/// \@end
2055/// \endcode
2056///
2057/// ObjC protocols inspired Java interfaces. Unlike Java, ObjC classes and
2058/// protocols are in distinct namespaces. For example, Cocoa defines both
2059/// an NSObject protocol and class (which isn't allowed in Java). As a result,
2060/// protocols are referenced using angle brackets as follows:
2061///
2062/// id \<NSDraggingInfo> anyObjectThatImplementsNSDraggingInfo;
2063class ObjCProtocolDecl : public ObjCContainerDecl,
2064                         public Redeclarable<ObjCProtocolDecl> {
2065  struct DefinitionData {
2066    // The declaration that defines this protocol.
2067    ObjCProtocolDecl *Definition;
2068
2069    /// Referenced protocols
2070    ObjCProtocolList ReferencedProtocols;
2071  };
2072
2073  /// Contains a pointer to the data associated with this class,
2074  /// which will be NULL if this class has not yet been defined.
2075  ///
2076  /// The bit indicates when we don't need to check for out-of-date
2077  /// declarations. It will be set unless modules are enabled.
2078  llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
2079
2080  ObjCProtocolDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
2081                   SourceLocation nameLoc, SourceLocation atStartLoc,
2082                   ObjCProtocolDecl *PrevDecl);
2083
2084  void anchor() override;
2085
2086  DefinitionData &data() const {
2087     (0) . __assert_fail ("Data.getPointer() && \"Objective-C protocol has no definition!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 2087, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Data.getPointer() && "Objective-C protocol has no definition!");
2088    return *Data.getPointer();
2089  }
2090
2091  void allocateDefinitionData();
2092
2093  using redeclarable_base = Redeclarable<ObjCProtocolDecl>;
2094
2095  ObjCProtocolDecl *getNextRedeclarationImpl() override {
2096    return getNextRedeclaration();
2097  }
2098
2099  ObjCProtocolDecl *getPreviousDeclImpl() override {
2100    return getPreviousDecl();
2101  }
2102
2103  ObjCProtocolDecl *getMostRecentDeclImpl() override {
2104    return getMostRecentDecl();
2105  }
2106
2107public:
2108  friend class ASTDeclReader;
2109  friend class ASTDeclWriter;
2110  friend class ASTReader;
2111
2112  static ObjCProtocolDecl *Create(ASTContext &C, DeclContext *DC,
2113                                  IdentifierInfo *Id,
2114                                  SourceLocation nameLoc,
2115                                  SourceLocation atStartLoc,
2116                                  ObjCProtocolDecl *PrevDecl);
2117
2118  static ObjCProtocolDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2119
2120  const ObjCProtocolList &getReferencedProtocols() const {
2121     (0) . __assert_fail ("hasDefinition() && \"No definition available!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 2121, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(hasDefinition() && "No definition available!");
2122    return data().ReferencedProtocols;
2123  }
2124
2125  using protocol_iterator = ObjCProtocolList::iterator;
2126  using protocol_range = llvm::iterator_range<protocol_iterator>;
2127
2128  protocol_range protocols() const {
2129    return protocol_range(protocol_begin(), protocol_end());
2130  }
2131
2132  protocol_iterator protocol_begin() const {
2133    if (!hasDefinition())
2134      return protocol_iterator();
2135
2136    return data().ReferencedProtocols.begin();
2137  }
2138
2139  protocol_iterator protocol_end() const {
2140    if (!hasDefinition())
2141      return protocol_iterator();
2142
2143    return data().ReferencedProtocols.end();
2144  }
2145
2146  using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
2147  using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;
2148
2149  protocol_loc_range protocol_locs() const {
2150    return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
2151  }
2152
2153  protocol_loc_iterator protocol_loc_begin() const {
2154    if (!hasDefinition())
2155      return protocol_loc_iterator();
2156
2157    return data().ReferencedProtocols.loc_begin();
2158  }
2159
2160  protocol_loc_iterator protocol_loc_end() const {
2161    if (!hasDefinition())
2162      return protocol_loc_iterator();
2163
2164    return data().ReferencedProtocols.loc_end();
2165  }
2166
2167  unsigned protocol_size() const {
2168    if (!hasDefinition())
2169      return 0;
2170
2171    return data().ReferencedProtocols.size();
2172  }
2173
2174  /// setProtocolList - Set the list of protocols that this interface
2175  /// implements.
2176  void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
2177                       const SourceLocation *Locs, ASTContext &C) {
2178     (0) . __assert_fail ("hasDefinition() && \"Protocol is not defined\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 2178, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(hasDefinition() && "Protocol is not defined");
2179    data().ReferencedProtocols.set(List, Num, Locs, C);
2180  }
2181
2182  ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName);
2183
2184  // Lookup a method. First, we search locally. If a method isn't
2185  // found, we search referenced protocols and class categories.
2186  ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const;
2187
2188  ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
2189    return lookupMethod(Sel, true/*isInstance*/);
2190  }
2191
2192  ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
2193    return lookupMethod(Sel, false/*isInstance*/);
2194  }
2195
2196  /// Determine whether this protocol has a definition.
2197  bool hasDefinition() const {
2198    // If the name of this protocol is out-of-date, bring it up-to-date, which
2199    // might bring in a definition.
2200    // Note: a null value indicates that we don't have a definition and that
2201    // modules are enabled.
2202    if (!Data.getOpaqueValue())
2203      getMostRecentDecl();
2204
2205    return Data.getPointer();
2206  }
2207
2208  /// Retrieve the definition of this protocol, if any.
2209  ObjCProtocolDecl *getDefinition() {
2210    return hasDefinition()? Data.getPointer()->Definition : nullptr;
2211  }
2212
2213  /// Retrieve the definition of this protocol, if any.
2214  const ObjCProtocolDecl *getDefinition() const {
2215    return hasDefinition()? Data.getPointer()->Definition : nullptr;
2216  }
2217
2218  /// Determine whether this particular declaration is also the
2219  /// definition.
2220  bool isThisDeclarationADefinition() const {
2221    return getDefinition() == this;
2222  }
2223
2224  /// Starts the definition of this Objective-C protocol.
2225  void startDefinition();
2226
2227  /// Produce a name to be used for protocol's metadata. It comes either via
2228  /// objc_runtime_name attribute or protocol name.
2229  StringRef getObjCRuntimeNameAsString() const;
2230
2231  SourceRange getSourceRange() const override LLVM_READONLY {
2232    if (isThisDeclarationADefinition())
2233      return ObjCContainerDecl::getSourceRange();
2234
2235    return SourceRange(getAtStartLoc(), getLocation());
2236  }
2237
2238  using redecl_range = redeclarable_base::redecl_range;
2239  using redecl_iterator = redeclarable_base::redecl_iterator;
2240
2241  using redeclarable_base::redecls_begin;
2242  using redeclarable_base::redecls_end;
2243  using redeclarable_base::redecls;
2244  using redeclarable_base::getPreviousDecl;
2245  using redeclarable_base::getMostRecentDecl;
2246  using redeclarable_base::isFirstDecl;
2247
2248  /// Retrieves the canonical declaration of this Objective-C protocol.
2249  ObjCProtocolDecl *getCanonicalDecl() override { return getFirstDecl(); }
2250  const ObjCProtocolDecl *getCanonicalDecl() const { return getFirstDecl(); }
2251
2252  void collectPropertiesToImplement(PropertyMap &PM,
2253                                    PropertyDeclOrder &PO) const override;
2254
2255  void collectInheritedProtocolProperties(const ObjCPropertyDecl *Property,
2256                                          ProtocolPropertySet &PS,
2257                                          PropertyDeclOrder &PO) const;
2258
2259  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2260  static bool classofKind(Kind K) { return K == ObjCProtocol; }
2261};
2262
2263/// ObjCCategoryDecl - Represents a category declaration. A category allows
2264/// you to add methods to an existing class (without subclassing or modifying
2265/// the original class interface or implementation:-). Categories don't allow
2266/// you to add instance data. The following example adds "myMethod" to all
2267/// NSView's within a process:
2268///
2269/// \@interface NSView (MyViewMethods)
2270/// - myMethod;
2271/// \@end
2272///
2273/// Categories also allow you to split the implementation of a class across
2274/// several files (a feature more naturally supported in C++).
2275///
2276/// Categories were originally inspired by dynamic languages such as Common
2277/// Lisp and Smalltalk.  More traditional class-based languages (C++, Java)
2278/// don't support this level of dynamism, which is both powerful and dangerous.
2279class ObjCCategoryDecl : public ObjCContainerDecl {
2280  /// Interface belonging to this category
2281  ObjCInterfaceDecl *ClassInterface;
2282
2283  /// The type parameters associated with this category, if any.
2284  ObjCTypeParamList *TypeParamList = nullptr;
2285
2286  /// referenced protocols in this category.
2287  ObjCProtocolList ReferencedProtocols;
2288
2289  /// Next category belonging to this class.
2290  /// FIXME: this should not be a singly-linked list.  Move storage elsewhere.
2291  ObjCCategoryDecl *NextClassCategory = nullptr;
2292
2293  /// The location of the category name in this declaration.
2294  SourceLocation CategoryNameLoc;
2295
2296  /// class extension may have private ivars.
2297  SourceLocation IvarLBraceLoc;
2298  SourceLocation IvarRBraceLoc;
2299
2300  ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc,
2301                   SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc,
2302                   IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
2303                   ObjCTypeParamList *typeParamList,
2304                   SourceLocation IvarLBraceLoc = SourceLocation(),
2305                   SourceLocation IvarRBraceLoc = SourceLocation());
2306
2307  void anchor() override;
2308
2309public:
2310  friend class ASTDeclReader;
2311  friend class ASTDeclWriter;
2312
2313  static ObjCCategoryDecl *Create(ASTContext &C, DeclContext *DC,
2314                                  SourceLocation AtLoc,
2315                                  SourceLocation ClassNameLoc,
2316                                  SourceLocation CategoryNameLoc,
2317                                  IdentifierInfo *Id,
2318                                  ObjCInterfaceDecl *IDecl,
2319                                  ObjCTypeParamList *typeParamList,
2320                                  SourceLocation IvarLBraceLoc=SourceLocation(),
2321                                  SourceLocation IvarRBraceLoc=SourceLocation());
2322  static ObjCCategoryDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2323
2324  ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
2325  const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }
2326
2327  /// Retrieve the type parameter list associated with this category or
2328  /// extension.
2329  ObjCTypeParamList *getTypeParamList() const { return TypeParamList; }
2330
2331  /// Set the type parameters of this category.
2332  ///
2333  /// This function is used by the AST importer, which must import the type
2334  /// parameters after creating their DeclContext to avoid loops.
2335  void setTypeParamList(ObjCTypeParamList *TPL);
2336
2337
2338  ObjCCategoryImplDecl *getImplementation() const;
2339  void setImplementation(ObjCCategoryImplDecl *ImplD);
2340
2341  /// setProtocolList - Set the list of protocols that this interface
2342  /// implements.
2343  void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
2344                       const SourceLocation *Locs, ASTContext &C) {
2345    ReferencedProtocols.set(List, Num, Locs, C);
2346  }
2347
2348  const ObjCProtocolList &getReferencedProtocols() const {
2349    return ReferencedProtocols;
2350  }
2351
2352  using protocol_iterator = ObjCProtocolList::iterator;
2353  using protocol_range = llvm::iterator_range<protocol_iterator>;
2354
2355  protocol_range protocols() const {
2356    return protocol_range(protocol_begin(), protocol_end());
2357  }
2358
2359  protocol_iterator protocol_begin() const {
2360    return ReferencedProtocols.begin();
2361  }
2362
2363  protocol_iterator protocol_end() const { return ReferencedProtocols.end(); }
2364  unsigned protocol_size() const { return ReferencedProtocols.size(); }
2365
2366  using protocol_loc_iterator = ObjCProtocolList::loc_iterator;
2367  using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>;
2368
2369  protocol_loc_range protocol_locs() const {
2370    return protocol_loc_range(protocol_loc_begin(), protocol_loc_end());
2371  }
2372
2373  protocol_loc_iterator protocol_loc_begin() const {
2374    return ReferencedProtocols.loc_begin();
2375  }
2376
2377  protocol_loc_iterator protocol_loc_end() const {
2378    return ReferencedProtocols.loc_end();
2379  }
2380
2381  ObjCCategoryDecl *getNextClassCategory() const { return NextClassCategory; }
2382
2383  /// Retrieve the pointer to the next stored category (or extension),
2384  /// which may be hidden.
2385  ObjCCategoryDecl *getNextClassCategoryRaw() const {
2386    return NextClassCategory;
2387  }
2388
2389  bool IsClassExtension() const { return getIdentifier() == nullptr; }
2390
2391  using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
2392  using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;
2393
2394  ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }
2395
2396  ivar_iterator ivar_begin() const {
2397    return ivar_iterator(decls_begin());
2398  }
2399
2400  ivar_iterator ivar_end() const {
2401    return ivar_iterator(decls_end());
2402  }
2403
2404  unsigned ivar_size() const {
2405    return std::distance(ivar_begin(), ivar_end());
2406  }
2407
2408  bool ivar_empty() const {
2409    return ivar_begin() == ivar_end();
2410  }
2411
2412  SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }
2413  void setCategoryNameLoc(SourceLocation Loc) { CategoryNameLoc = Loc; }
2414
2415  void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
2416  SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
2417  void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
2418  SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }
2419
2420  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2421  static bool classofKind(Kind K) { return K == ObjCCategory; }
2422};
2423
2424class ObjCImplDecl : public ObjCContainerDecl {
2425  /// Class interface for this class/category implementation
2426  ObjCInterfaceDecl *ClassInterface;
2427
2428  void anchor() override;
2429
2430protected:
2431  ObjCImplDecl(Kind DK, DeclContext *DC,
2432               ObjCInterfaceDecl *classInterface,
2433               IdentifierInfo *Id,
2434               SourceLocation nameLoc, SourceLocation atStartLoc)
2435      : ObjCContainerDecl(DK, DC, Id, nameLoc, atStartLoc),
2436        ClassInterface(classInterface) {}
2437
2438public:
2439  const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }
2440  ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
2441  void setClassInterface(ObjCInterfaceDecl *IFace);
2442
2443  void addInstanceMethod(ObjCMethodDecl *method) {
2444    // FIXME: Context should be set correctly before we get here.
2445    method->setLexicalDeclContext(this);
2446    addDecl(method);
2447  }
2448
2449  void addClassMethod(ObjCMethodDecl *method) {
2450    // FIXME: Context should be set correctly before we get here.
2451    method->setLexicalDeclContext(this);
2452    addDecl(method);
2453  }
2454
2455  void addPropertyImplementation(ObjCPropertyImplDecl *property);
2456
2457  ObjCPropertyImplDecl *FindPropertyImplDecl(IdentifierInfo *propertyId,
2458                            ObjCPropertyQueryKind queryKind) const;
2459  ObjCPropertyImplDecl *FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const;
2460
2461  // Iterator access to properties.
2462  using propimpl_iterator = specific_decl_iterator<ObjCPropertyImplDecl>;
2463  using propimpl_range =
2464      llvm::iterator_range<specific_decl_iterator<ObjCPropertyImplDecl>>;
2465
2466  propimpl_range property_impls() const {
2467    return propimpl_range(propimpl_begin(), propimpl_end());
2468  }
2469
2470  propimpl_iterator propimpl_begin() const {
2471    return propimpl_iterator(decls_begin());
2472  }
2473
2474  propimpl_iterator propimpl_end() const {
2475    return propimpl_iterator(decls_end());
2476  }
2477
2478  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2479
2480  static bool classofKind(Kind K) {
2481    return K >= firstObjCImpl && K <= lastObjCImpl;
2482  }
2483};
2484
2485/// ObjCCategoryImplDecl - An object of this class encapsulates a category
2486/// \@implementation declaration. If a category class has declaration of a
2487/// property, its implementation must be specified in the category's
2488/// \@implementation declaration. Example:
2489/// \@interface I \@end
2490/// \@interface I(CATEGORY)
2491///    \@property int p1, d1;
2492/// \@end
2493/// \@implementation I(CATEGORY)
2494///  \@dynamic p1,d1;
2495/// \@end
2496///
2497/// ObjCCategoryImplDecl
2498class ObjCCategoryImplDecl : public ObjCImplDecl {
2499  // Category name location
2500  SourceLocation CategoryNameLoc;
2501
2502  ObjCCategoryImplDecl(DeclContext *DC, IdentifierInfo *Id,
2503                       ObjCInterfaceDecl *classInterface,
2504                       SourceLocation nameLoc, SourceLocation atStartLoc,
2505                       SourceLocation CategoryNameLoc)
2506      : ObjCImplDecl(ObjCCategoryImpl, DC, classInterface, Id,
2507                     nameLoc, atStartLoc),
2508        CategoryNameLoc(CategoryNameLoc) {}
2509
2510  void anchor() override;
2511
2512public:
2513  friend class ASTDeclReader;
2514  friend class ASTDeclWriter;
2515
2516  static ObjCCategoryImplDecl *Create(ASTContext &C, DeclContext *DC,
2517                                      IdentifierInfo *Id,
2518                                      ObjCInterfaceDecl *classInterface,
2519                                      SourceLocation nameLoc,
2520                                      SourceLocation atStartLoc,
2521                                      SourceLocation CategoryNameLoc);
2522  static ObjCCategoryImplDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2523
2524  ObjCCategoryDecl *getCategoryDecl() const;
2525
2526  SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }
2527
2528  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2529  static bool classofKind(Kind K) { return K == ObjCCategoryImpl;}
2530};
2531
2532raw_ostream &operator<<(raw_ostream &OS, const ObjCCategoryImplDecl &CID);
2533
2534/// ObjCImplementationDecl - Represents a class definition - this is where
2535/// method definitions are specified. For example:
2536///
2537/// @code
2538/// \@implementation MyClass
2539/// - (void)myMethod { /* do something */ }
2540/// \@end
2541/// @endcode
2542///
2543/// In a non-fragile runtime, instance variables can appear in the class
2544/// interface, class extensions (nameless categories), and in the implementation
2545/// itself, as well as being synthesized as backing storage for properties.
2546///
2547/// In a fragile runtime, instance variables are specified in the class
2548/// interface, \em not in the implementation. Nevertheless (for legacy reasons),
2549/// we allow instance variables to be specified in the implementation. When
2550/// specified, they need to be \em identical to the interface.
2551class ObjCImplementationDecl : public ObjCImplDecl {
2552  /// Implementation Class's super class.
2553  ObjCInterfaceDecl *SuperClass;
2554  SourceLocation SuperLoc;
2555
2556  /// \@implementation may have private ivars.
2557  SourceLocation IvarLBraceLoc;
2558  SourceLocation IvarRBraceLoc;
2559
2560  /// Support for ivar initialization.
2561  /// The arguments used to initialize the ivars
2562  LazyCXXCtorInitializersPtr IvarInitializers;
2563  unsigned NumIvarInitializers = 0;
2564
2565  /// Do the ivars of this class require initialization other than
2566  /// zero-initialization?
2567  bool HasNonZeroConstructors : 1;
2568
2569  /// Do the ivars of this class require non-trivial destruction?
2570  bool HasDestructors : 1;
2571
2572  ObjCImplementationDecl(DeclContext *DC,
2573                         ObjCInterfaceDecl *classInterface,
2574                         ObjCInterfaceDecl *superDecl,
2575                         SourceLocation nameLoc, SourceLocation atStartLoc,
2576                         SourceLocation superLoc = SourceLocation(),
2577                         SourceLocation IvarLBraceLoc=SourceLocation(),
2578                         SourceLocation IvarRBraceLoc=SourceLocation())
2579      : ObjCImplDecl(ObjCImplementation, DC, classInterface,
2580                     classInterface ? classInterface->getIdentifier()
2581                                    : nullptr,
2582                     nameLoc, atStartLoc),
2583         SuperClass(superDecl), SuperLoc(superLoc),
2584         IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc),
2585         HasNonZeroConstructors(false), HasDestructors(false) {}
2586
2587  void anchor() override;
2588
2589public:
2590  friend class ASTDeclReader;
2591  friend class ASTDeclWriter;
2592
2593  static ObjCImplementationDecl *Create(ASTContext &C, DeclContext *DC,
2594                                        ObjCInterfaceDecl *classInterface,
2595                                        ObjCInterfaceDecl *superDecl,
2596                                        SourceLocation nameLoc,
2597                                        SourceLocation atStartLoc,
2598                                     SourceLocation superLoc = SourceLocation(),
2599                                        SourceLocation IvarLBraceLoc=SourceLocation(),
2600                                        SourceLocation IvarRBraceLoc=SourceLocation());
2601
2602  static ObjCImplementationDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2603
2604  /// init_iterator - Iterates through the ivar initializer list.
2605  using init_iterator = CXXCtorInitializer **;
2606
2607  /// init_const_iterator - Iterates through the ivar initializer list.
2608  using init_const_iterator = CXXCtorInitializer * const *;
2609
2610  using init_range = llvm::iterator_range<init_iterator>;
2611  using init_const_range = llvm::iterator_range<init_const_iterator>;
2612
2613  init_range inits() { return init_range(init_begin(), init_end()); }
2614
2615  init_const_range inits() const {
2616    return init_const_range(init_begin(), init_end());
2617  }
2618
2619  /// init_begin() - Retrieve an iterator to the first initializer.
2620  init_iterator init_begin() {
2621    const auto *ConstThis = this;
2622    return const_cast<init_iterator>(ConstThis->init_begin());
2623  }
2624
2625  /// begin() - Retrieve an iterator to the first initializer.
2626  init_const_iterator init_begin() const;
2627
2628  /// init_end() - Retrieve an iterator past the last initializer.
2629  init_iterator       init_end()       {
2630    return init_begin() + NumIvarInitializers;
2631  }
2632
2633  /// end() - Retrieve an iterator past the last initializer.
2634  init_const_iterator init_end() const {
2635    return init_begin() + NumIvarInitializers;
2636  }
2637
2638  /// getNumArgs - Number of ivars which must be initialized.
2639  unsigned getNumIvarInitializers() const {
2640    return NumIvarInitializers;
2641  }
2642
2643  void setNumIvarInitializers(unsigned numNumIvarInitializers) {
2644    NumIvarInitializers = numNumIvarInitializers;
2645  }
2646
2647  void setIvarInitializers(ASTContext &C,
2648                           CXXCtorInitializer ** initializers,
2649                           unsigned numInitializers);
2650
2651  /// Do any of the ivars of this class (not counting its base classes)
2652  /// require construction other than zero-initialization?
2653  bool hasNonZeroConstructors() const { return HasNonZeroConstructors; }
2654  void setHasNonZeroConstructors(bool val) { HasNonZeroConstructors = val; }
2655
2656  /// Do any of the ivars of this class (not counting its base classes)
2657  /// require non-trivial destruction?
2658  bool hasDestructors() const { return HasDestructors; }
2659  void setHasDestructors(bool val) { HasDestructors = val; }
2660
2661  /// getIdentifier - Get the identifier that names the class
2662  /// interface associated with this implementation.
2663  IdentifierInfo *getIdentifier() const {
2664    return getClassInterface()->getIdentifier();
2665  }
2666
2667  /// getName - Get the name of identifier for the class interface associated
2668  /// with this implementation as a StringRef.
2669  //
2670  // FIXME: This is a bad API, we are hiding NamedDecl::getName with a different
2671  // meaning.
2672  StringRef getName() const {
2673     (0) . __assert_fail ("getIdentifier() && \"Name is not a simple identifier\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/DeclObjC.h", 2673, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(getIdentifier() && "Name is not a simple identifier");
2674    return getIdentifier()->getName();
2675  }
2676
2677  /// Get the name of the class associated with this interface.
2678  //
2679  // FIXME: Move to StringRef API.
2680  std::string getNameAsString() const {
2681    return getName();
2682  }
2683
2684  /// Produce a name to be used for class's metadata. It comes either via
2685  /// class's objc_runtime_name attribute or class name.
2686  StringRef getObjCRuntimeNameAsString() const;
2687
2688  const ObjCInterfaceDecl *getSuperClass() const { return SuperClass; }
2689  ObjCInterfaceDecl *getSuperClass() { return SuperClass; }
2690  SourceLocation getSuperClassLoc() const { return SuperLoc; }
2691
2692  void setSuperClass(ObjCInterfaceDecl * superCls) { SuperClass = superCls; }
2693
2694  void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
2695  SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
2696  void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
2697  SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }
2698
2699  using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>;
2700  using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>;
2701
2702  ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); }
2703
2704  ivar_iterator ivar_begin() const {
2705    return ivar_iterator(decls_begin());
2706  }
2707
2708  ivar_iterator ivar_end() const {
2709    return ivar_iterator(decls_end());
2710  }
2711
2712  unsigned ivar_size() const {
2713    return std::distance(ivar_begin(), ivar_end());
2714  }
2715
2716  bool ivar_empty() const {
2717    return ivar_begin() == ivar_end();
2718  }
2719
2720  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2721  static bool classofKind(Kind K) { return K == ObjCImplementation; }
2722};
2723
2724raw_ostream &operator<<(raw_ostream &OS, const ObjCImplementationDecl &ID);
2725
2726/// ObjCCompatibleAliasDecl - Represents alias of a class. This alias is
2727/// declared as \@compatibility_alias alias class.
2728class ObjCCompatibleAliasDecl : public NamedDecl {
2729  /// Class that this is an alias of.
2730  ObjCInterfaceDecl *AliasedClass;
2731
2732  ObjCCompatibleAliasDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
2733                          ObjCInterfaceDecl* aliasedClass)
2734      : NamedDecl(ObjCCompatibleAlias, DC, L, Id), AliasedClass(aliasedClass) {}
2735
2736  void anchor() override;
2737
2738public:
2739  static ObjCCompatibleAliasDecl *Create(ASTContext &C, DeclContext *DC,
2740                                         SourceLocation L, IdentifierInfo *Id,
2741                                         ObjCInterfaceDecl* aliasedClass);
2742
2743  static ObjCCompatibleAliasDecl *CreateDeserialized(ASTContext &C,
2744                                                     unsigned ID);
2745
2746  const ObjCInterfaceDecl *getClassInterface() const { return AliasedClass; }
2747  ObjCInterfaceDecl *getClassInterface() { return AliasedClass; }
2748  void setClassInterface(ObjCInterfaceDecl *D) { AliasedClass = D; }
2749
2750  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2751  static bool classofKind(Kind K) { return K == ObjCCompatibleAlias; }
2752};
2753
2754/// ObjCPropertyImplDecl - Represents implementation declaration of a property
2755/// in a class or category implementation block. For example:
2756/// \@synthesize prop1 = ivar1;
2757///
2758class ObjCPropertyImplDecl : public Decl {
2759public:
2760  enum Kind {
2761    Synthesize,
2762    Dynamic
2763  };
2764
2765private:
2766  SourceLocation AtLoc;   // location of \@synthesize or \@dynamic
2767
2768  /// For \@synthesize, the location of the ivar, if it was written in
2769  /// the source code.
2770  ///
2771  /// \code
2772  /// \@synthesize int a = b
2773  /// \endcode
2774  SourceLocation IvarLoc;
2775
2776  /// Property declaration being implemented
2777  ObjCPropertyDecl *PropertyDecl;
2778
2779  /// Null for \@dynamic. Required for \@synthesize.
2780  ObjCIvarDecl *PropertyIvarDecl;
2781
2782  /// Null for \@dynamic. Non-null if property must be copy-constructed in
2783  /// getter.
2784  Expr *GetterCXXConstructor = nullptr;
2785
2786  /// Null for \@dynamic. Non-null if property has assignment operator to call
2787  /// in Setter synthesis.
2788  Expr *SetterCXXAssignment = nullptr;
2789
2790  ObjCPropertyImplDecl(DeclContext *DC, SourceLocation atLoc, SourceLocation L,
2791                       ObjCPropertyDecl *property,
2792                       Kind PK,
2793                       ObjCIvarDecl *ivarDecl,
2794                       SourceLocation ivarLoc)
2795      : Decl(ObjCPropertyImpl, DC, L), AtLoc(atLoc),
2796        IvarLoc(ivarLoc), PropertyDecl(property), PropertyIvarDecl(ivarDecl) {
2797    assert(PK == Dynamic || PropertyIvarDecl);
2798  }
2799
2800public:
2801  friend class ASTDeclReader;
2802
2803  static ObjCPropertyImplDecl *Create(ASTContext &C, DeclContext *DC,
2804                                      SourceLocation atLoc, SourceLocation L,
2805                                      ObjCPropertyDecl *property,
2806                                      Kind PK,
2807                                      ObjCIvarDecl *ivarDecl,
2808                                      SourceLocation ivarLoc);
2809
2810  static ObjCPropertyImplDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2811
2812  SourceRange getSourceRange() const override LLVM_READONLY;
2813
2814  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
2815  void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }
2816
2817  ObjCPropertyDecl *getPropertyDecl() const {
2818    return PropertyDecl;
2819  }
2820  void setPropertyDecl(ObjCPropertyDecl *Prop) { PropertyDecl = Prop; }
2821
2822  Kind getPropertyImplementation() const {
2823    return PropertyIvarDecl ? Synthesize : Dynamic;
2824  }
2825
2826  ObjCIvarDecl *getPropertyIvarDecl() const {
2827    return PropertyIvarDecl;
2828  }
2829  SourceLocation getPropertyIvarDeclLoc() const { return IvarLoc; }
2830
2831  void setPropertyIvarDecl(ObjCIvarDecl *Ivar,
2832                           SourceLocation IvarLoc) {
2833    PropertyIvarDecl = Ivar;
2834    this->IvarLoc = IvarLoc;
2835  }
2836
2837  /// For \@synthesize, returns true if an ivar name was explicitly
2838  /// specified.
2839  ///
2840  /// \code
2841  /// \@synthesize int a = b; // true
2842  /// \@synthesize int a; // false
2843  /// \endcode
2844  bool isIvarNameSpecified() const {
2845    return IvarLoc.isValid() && IvarLoc != getLocation();
2846  }
2847
2848  Expr *getGetterCXXConstructor() const {
2849    return GetterCXXConstructor;
2850  }
2851
2852  void setGetterCXXConstructor(Expr *getterCXXConstructor) {
2853    GetterCXXConstructor = getterCXXConstructor;
2854  }
2855
2856  Expr *getSetterCXXAssignment() const {
2857    return SetterCXXAssignment;
2858  }
2859
2860  void setSetterCXXAssignment(Expr *setterCXXAssignment) {
2861    SetterCXXAssignment = setterCXXAssignment;
2862  }
2863
2864  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2865  static bool classofKind(Decl::Kind K) { return K == ObjCPropertyImpl; }
2866};
2867
2868template<bool (*Filter)(ObjCCategoryDecl *)>
2869void
2870ObjCInterfaceDecl::filtered_category_iterator<Filter>::
2871findAcceptableCategory() {
2872  while (Current && !Filter(Current))
2873    Current = Current->getNextClassCategoryRaw();
2874}
2875
2876template<bool (*Filter)(ObjCCategoryDecl *)>
2877inline ObjCInterfaceDecl::filtered_category_iterator<Filter> &
2878ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() {
2879  Current = Current->getNextClassCategoryRaw();
2880  findAcceptableCategory();
2881  return *this;
2882}
2883
2884inline bool ObjCInterfaceDecl::isVisibleCategory(ObjCCategoryDecl *Cat) {
2885  return !Cat->isHidden();
2886}
2887
2888inline bool ObjCInterfaceDecl::isVisibleExtension(ObjCCategoryDecl *Cat) {
2889  return Cat->IsClassExtension() && !Cat->isHidden();
2890}
2891
2892inline bool ObjCInterfaceDecl::isKnownExtension(ObjCCategoryDecl *Cat) {
2893  return Cat->IsClassExtension();
2894}
2895
2896} // namespace clang
2897
2898#endif // LLVM_CLANG_AST_DECLOBJC_H
2899
clang::ObjCListBase::List
clang::ObjCListBase::NumElts
clang::ObjCListBase::size
clang::ObjCListBase::empty
clang::ObjCListBase::set
clang::ObjCList::set
clang::ObjCList::begin
clang::ObjCList::end
clang::ObjCProtocolList::Locations
clang::ObjCProtocolList::loc_begin
clang::ObjCProtocolList::loc_end
clang::ObjCProtocolList::set
clang::ObjCMethodDecl::ImplementationControl
clang::ObjCMethodDecl::MethodDeclType
clang::ObjCMethodDecl::ReturnTInfo
clang::ObjCMethodDecl::ParamsAndSelLocs
clang::ObjCMethodDecl::NumParams
clang::ObjCMethodDecl::DeclEndLoc
clang::ObjCMethodDecl::Body
clang::ObjCMethodDecl::SelfDecl
clang::ObjCMethodDecl::CmdDecl
clang::ObjCMethodDecl::getSelLocsKind
clang::ObjCMethodDecl::setSelLocsKind
clang::ObjCMethodDecl::hasStandardSelLocs
clang::ObjCMethodDecl::getStoredSelLocs
clang::ObjCMethodDecl::getStoredSelLocs
clang::ObjCMethodDecl::getParams
clang::ObjCMethodDecl::getParams
clang::ObjCMethodDecl::getNumStoredSelLocs
clang::ObjCMethodDecl::setParamsAndSelLocs
clang::ObjCMethodDecl::getNextRedeclarationImpl
clang::ObjCMethodDecl::Create
clang::ObjCMethodDecl::CreateDeserialized
clang::ObjCMethodDecl::getCanonicalDecl
clang::ObjCMethodDecl::getCanonicalDecl
clang::ObjCMethodDecl::getObjCDeclQualifier
clang::ObjCMethodDecl::setObjCDeclQualifier
clang::ObjCMethodDecl::hasRelatedResultType
clang::ObjCMethodDecl::setRelatedResultType
clang::ObjCMethodDecl::isRedeclaration
clang::ObjCMethodDecl::setIsRedeclaration
clang::ObjCMethodDecl::setAsRedeclaration
clang::ObjCMethodDecl::hasRedeclaration
clang::ObjCMethodDecl::setHasRedeclaration
clang::ObjCMethodDecl::getDeclaratorEndLoc
clang::ObjCMethodDecl::getBeginLoc
clang::ObjCMethodDecl::getSourceRange
clang::ObjCMethodDecl::getNumSelectorLocs
clang::ObjCMethodDecl::getClassInterface
clang::ObjCMethodDecl::getClassInterface
clang::ObjCMethodDecl::getSelector
clang::ObjCMethodDecl::getReturnType
clang::ObjCMethodDecl::setReturnType
clang::ObjCMethodDecl::getReturnTypeSourceRange
clang::ObjCMethodDecl::getSendResultType
clang::ObjCMethodDecl::getSendResultType
clang::ObjCMethodDecl::getReturnTypeSourceInfo
clang::ObjCMethodDecl::setReturnTypeSourceInfo
clang::ObjCMethodDecl::param_size
clang::ObjCMethodDecl::param_begin
clang::ObjCMethodDecl::param_end
clang::ObjCMethodDecl::param_begin
clang::ObjCMethodDecl::param_end
clang::ObjCMethodDecl::sel_param_end
clang::ObjCMethodDecl::parameters
clang::ObjCMethodDecl::getParamDecl
clang::ObjCMethodDecl::getParamDecl
clang::ObjCMethodDecl::setMethodParams
clang::ObjCMethodDecl::GetTypeFn
clang::ObjCMethodDecl::param_type_begin
clang::ObjCMethodDecl::param_type_end
clang::ObjCMethodDecl::createImplicitParams
clang::ObjCMethodDecl::getSelfType
clang::ObjCMethodDecl::getSelfDecl
clang::ObjCMethodDecl::setSelfDecl
clang::ObjCMethodDecl::getCmdDecl
clang::ObjCMethodDecl::setCmdDecl
clang::ObjCMethodDecl::getMethodFamily
clang::ObjCMethodDecl::isInstanceMethod
clang::ObjCMethodDecl::setInstanceMethod
clang::ObjCMethodDecl::isVariadic
clang::ObjCMethodDecl::setVariadic
clang::ObjCMethodDecl::isClassMethod
clang::ObjCMethodDecl::isPropertyAccessor
clang::ObjCMethodDecl::setPropertyAccessor
clang::ObjCMethodDecl::isDefined
clang::ObjCMethodDecl::setDefined
clang::ObjCMethodDecl::isOverriding
clang::ObjCMethodDecl::setOverriding
clang::ObjCMethodDecl::getOverriddenMethods
clang::ObjCMethodDecl::hasSkippedBody
clang::ObjCMethodDecl::setHasSkippedBody
clang::ObjCMethodDecl::findPropertyDecl
clang::ObjCMethodDecl::setDeclImplementation
clang::ObjCMethodDecl::getImplementationControl
clang::ObjCMethodDecl::isOptional
clang::ObjCMethodDecl::isThisDeclarationADesignatedInitializer
clang::ObjCMethodDecl::isDesignatedInitializerForTheInterface
clang::ObjCMethodDecl::hasBody
clang::ObjCMethodDecl::getBody
clang::ObjCMethodDecl::setLazyBody
clang::ObjCMethodDecl::getCompoundBody
clang::ObjCMethodDecl::setBody
clang::ObjCMethodDecl::isThisDeclarationADefinition
clang::ObjCMethodDecl::definedInNSObject
clang::ObjCMethodDecl::classof
clang::ObjCMethodDecl::classofKind
clang::ObjCMethodDecl::castToDeclContext
clang::ObjCMethodDecl::castFromDeclContext
clang::ObjCTypeParamDecl::Index
clang::ObjCTypeParamDecl::Variance
clang::ObjCTypeParamDecl::VarianceLoc
clang::ObjCTypeParamDecl::ColonLoc
clang::ObjCTypeParamDecl::anchor
clang::ObjCTypeParamDecl::Create
clang::ObjCTypeParamDecl::CreateDeserialized
clang::ObjCTypeParamDecl::getSourceRange
clang::ObjCTypeParamDecl::getVariance
clang::ObjCTypeParamDecl::setVariance
clang::ObjCTypeParamDecl::getVarianceLoc
clang::ObjCTypeParamDecl::getIndex
clang::ObjCTypeParamDecl::hasExplicitBound
clang::ObjCTypeParamDecl::getColonLoc
clang::ObjCTypeParamDecl::classof
clang::ObjCTypeParamDecl::classofKind
clang::ObjCTypeParamList::PODSourceRange
clang::ObjCTypeParamList::PODSourceRange::Begin
clang::ObjCTypeParamList::PODSourceRange::End
clang::ObjCTypeParamList::(anonymous union)::Brackets
clang::ObjCTypeParamList::(anonymous union)::AlignmentHack
clang::ObjCTypeParamList::NumParams
clang::ObjCTypeParamList::create
clang::ObjCTypeParamList::begin
clang::ObjCTypeParamList::end
clang::ObjCTypeParamList::size
clang::ObjCTypeParamList::begin
clang::ObjCTypeParamList::end
clang::ObjCTypeParamList::front
clang::ObjCTypeParamList::back
clang::ObjCTypeParamList::getLAngleLoc
clang::ObjCTypeParamList::getRAngleLoc
clang::ObjCTypeParamList::getSourceRange
clang::ObjCTypeParamList::gatherDefaultTypeArgs
clang::ObjCPropertyDecl::anchor
clang::ObjCPropertyDecl::PropertyAttributeKind
clang::ObjCPropertyDecl::SetterKind
clang::ObjCPropertyDecl::PropertyControl
clang::ObjCPropertyDecl::AtLoc
clang::ObjCPropertyDecl::LParenLoc
clang::ObjCPropertyDecl::DeclType
clang::ObjCPropertyDecl::DeclTypeSourceInfo
clang::ObjCPropertyDecl::PropertyAttributes
clang::ObjCPropertyDecl::PropertyAttributesAsWritten
clang::ObjCPropertyDecl::PropertyImplementation
clang::ObjCPropertyDecl::GetterName
clang::ObjCPropertyDecl::SetterName
clang::ObjCPropertyDecl::GetterNameLoc
clang::ObjCPropertyDecl::SetterNameLoc
clang::ObjCPropertyDecl::GetterMethodDecl
clang::ObjCPropertyDecl::SetterMethodDecl
clang::ObjCPropertyDecl::PropertyIvarDecl
clang::ObjCPropertyDecl::Create
clang::ObjCPropertyDecl::CreateDeserialized
clang::ObjCPropertyDecl::getAtLoc
clang::ObjCPropertyDecl::setAtLoc
clang::ObjCPropertyDecl::getLParenLoc
clang::ObjCPropertyDecl::setLParenLoc
clang::ObjCPropertyDecl::getTypeSourceInfo
clang::ObjCPropertyDecl::getType
clang::ObjCPropertyDecl::setType
clang::ObjCPropertyDecl::getUsageType
clang::ObjCPropertyDecl::getPropertyAttributes
clang::ObjCPropertyDecl::setPropertyAttributes
clang::ObjCPropertyDecl::overwritePropertyAttributes
clang::ObjCPropertyDecl::getPropertyAttributesAsWritten
clang::ObjCPropertyDecl::setPropertyAttributesAsWritten
clang::ObjCPropertyDecl::isReadOnly
clang::ObjCPropertyDecl::isAtomic
clang::ObjCPropertyDecl::isRetaining
clang::ObjCPropertyDecl::isInstanceProperty
clang::ObjCPropertyDecl::isClassProperty
clang::ObjCPropertyDecl::getQueryKind
clang::ObjCPropertyDecl::getQueryKind
clang::ObjCPropertyDecl::getSetterKind
clang::ObjCPropertyDecl::getGetterName
clang::ObjCPropertyDecl::getGetterNameLoc
clang::ObjCPropertyDecl::setGetterName
clang::ObjCPropertyDecl::getSetterName
clang::ObjCPropertyDecl::getSetterNameLoc
clang::ObjCPropertyDecl::setSetterName
clang::ObjCPropertyDecl::getGetterMethodDecl
clang::ObjCPropertyDecl::setGetterMethodDecl
clang::ObjCPropertyDecl::getSetterMethodDecl
clang::ObjCPropertyDecl::setSetterMethodDecl
clang::ObjCPropertyDecl::setPropertyImplementation
clang::ObjCPropertyDecl::getPropertyImplementation
clang::ObjCPropertyDecl::isOptional
clang::ObjCPropertyDecl::setPropertyIvarDecl
clang::ObjCPropertyDecl::getPropertyIvarDecl
clang::ObjCPropertyDecl::getSourceRange
clang::ObjCPropertyDecl::findPropertyDecl
clang::ObjCPropertyDecl::classof
clang::ObjCPropertyDecl::classofKind
clang::ObjCContainerDecl::AtEnd
clang::ObjCContainerDecl::anchor
clang::ObjCContainerDecl::properties
clang::ObjCContainerDecl::prop_begin
clang::ObjCContainerDecl::prop_end
clang::ObjCContainerDecl::instance_properties
clang::ObjCContainerDecl::instprop_begin
clang::ObjCContainerDecl::instprop_end
clang::ObjCContainerDecl::class_properties
clang::ObjCContainerDecl::classprop_begin
clang::ObjCContainerDecl::classprop_end
clang::ObjCContainerDecl::methods
clang::ObjCContainerDecl::meth_begin
clang::ObjCContainerDecl::meth_end
clang::ObjCContainerDecl::instance_methods
clang::ObjCContainerDecl::instmeth_begin
clang::ObjCContainerDecl::instmeth_end
clang::ObjCContainerDecl::class_methods
clang::ObjCContainerDecl::classmeth_begin
clang::ObjCContainerDecl::classmeth_end
clang::ObjCContainerDecl::getMethod
clang::ObjCContainerDecl::getInstanceMethod
clang::ObjCContainerDecl::getClassMethod
clang::ObjCContainerDecl::HasUserDeclaredSetterMethod
clang::ObjCContainerDecl::getIvarDecl
clang::ObjCContainerDecl::FindPropertyDeclaration
clang::ObjCContainerDecl::collectPropertiesToImplement
clang::ObjCContainerDecl::getAtStartLoc
clang::ObjCContainerDecl::setAtStartLoc
clang::ObjCContainerDecl::getAtEndRange
clang::ObjCContainerDecl::setAtEndRange
clang::ObjCContainerDecl::getSourceRange
clang::ObjCInterfaceDecl::TypeForDecl
clang::ObjCInterfaceDecl::DefinitionData
clang::ObjCInterfaceDecl::DefinitionData::Definition
clang::ObjCInterfaceDecl::DefinitionData::SuperClassTInfo
clang::ObjCInterfaceDecl::DefinitionData::ReferencedProtocols
clang::ObjCInterfaceDecl::DefinitionData::AllReferencedProtocols
clang::ObjCInterfaceDecl::DefinitionData::CategoryList
clang::ObjCInterfaceDecl::DefinitionData::IvarList
clang::ObjCInterfaceDecl::DefinitionData::ExternallyCompleted
clang::ObjCInterfaceDecl::DefinitionData::IvarListMissingImplementation
clang::ObjCInterfaceDecl::DefinitionData::HasDesignatedInitializers
clang::ObjCInterfaceDecl::DefinitionData::InheritedDesignatedInitializersState
clang::ObjCInterfaceDecl::DefinitionData::InheritedDesignatedInitializers
clang::ObjCInterfaceDecl::DefinitionData::EndLoc
clang::ObjCInterfaceDecl::TypeParamList
clang::ObjCInterfaceDecl::Data
clang::ObjCInterfaceDecl::anchor
clang::ObjCInterfaceDecl::LoadExternalDefinition
clang::ObjCInterfaceDecl::data
clang::ObjCInterfaceDecl::allocateDefinitionData
clang::ObjCInterfaceDecl::getNextRedeclarationImpl
clang::ObjCInterfaceDecl::getPreviousDeclImpl
clang::ObjCInterfaceDecl::getMostRecentDeclImpl
clang::ObjCInterfaceDecl::Create
clang::ObjCInterfaceDecl::CreateDeserialized
clang::ObjCInterfaceDecl::getTypeParamList
clang::ObjCInterfaceDecl::setTypeParamList
clang::ObjCInterfaceDecl::getTypeParamListAsWritten
clang::ObjCInterfaceDecl::getSourceRange
clang::ObjCInterfaceDecl::setHasDesignatedInitializers
clang::ObjCInterfaceDecl::hasDesignatedInitializers
clang::ObjCInterfaceDecl::declaresOrInheritsDesignatedInitializers
clang::ObjCInterfaceDecl::getReferencedProtocols
clang::ObjCInterfaceDecl::getImplementation
clang::ObjCInterfaceDecl::setImplementation
clang::ObjCInterfaceDecl::FindCategoryDeclaration
clang::ObjCInterfaceDecl::getCategoryInstanceMethod
clang::ObjCInterfaceDecl::getCategoryClassMethod
clang::ObjCInterfaceDecl::getCategoryMethod
clang::ObjCInterfaceDecl::protocols
clang::ObjCInterfaceDecl::protocol_begin
clang::ObjCInterfaceDecl::protocol_end
clang::ObjCInterfaceDecl::protocol_locs
clang::ObjCInterfaceDecl::protocol_loc_begin
clang::ObjCInterfaceDecl::protocol_loc_end
clang::ObjCInterfaceDecl::all_referenced_protocols
clang::ObjCInterfaceDecl::all_referenced_protocol_begin
clang::ObjCInterfaceDecl::all_referenced_protocol_end
clang::ObjCInterfaceDecl::ivars
clang::ObjCInterfaceDecl::ivar_begin
clang::ObjCInterfaceDecl::ivar_end
clang::ObjCInterfaceDecl::ivar_size
clang::ObjCInterfaceDecl::ivar_empty
clang::ObjCInterfaceDecl::all_declared_ivar_begin
clang::ObjCInterfaceDecl::all_declared_ivar_begin
clang::ObjCInterfaceDecl::setIvarList
clang::ObjCInterfaceDecl::setProtocolList
clang::ObjCInterfaceDecl::mergeClassExtensionProtocolList
clang::ObjCInterfaceDecl::getObjCRuntimeNameAsString
clang::ObjCInterfaceDecl::getDesignatedInitializers
clang::ObjCInterfaceDecl::isDesignatedInitializer
clang::ObjCInterfaceDecl::isThisDeclarationADefinition
clang::ObjCInterfaceDecl::hasDefinition
clang::ObjCInterfaceDecl::getDefinition
clang::ObjCInterfaceDecl::getDefinition
clang::ObjCInterfaceDecl::startDefinition
clang::ObjCInterfaceDecl::getSuperClassType
clang::ObjCInterfaceDecl::getSuperClassTInfo
clang::ObjCInterfaceDecl::getSuperClass
clang::ObjCInterfaceDecl::setSuperClass
clang::ObjCInterfaceDecl::filtered_category_iterator
clang::ObjCInterfaceDecl::filtered_category_iterator::Current
clang::ObjCInterfaceDecl::filtered_category_iterator::findAcceptableCategory
clang::ObjCInterfaceDecl::isVisibleCategory
clang::ObjCInterfaceDecl::visible_categories
clang::ObjCInterfaceDecl::visible_categories_begin
clang::ObjCInterfaceDecl::visible_categories_end
clang::ObjCInterfaceDecl::visible_categories_empty
clang::ObjCInterfaceDecl::isKnownCategory
clang::ObjCInterfaceDecl::known_categories
clang::ObjCInterfaceDecl::known_categories_begin
clang::ObjCInterfaceDecl::known_categories_end
clang::ObjCInterfaceDecl::known_categories_empty
clang::ObjCInterfaceDecl::isVisibleExtension
clang::ObjCInterfaceDecl::visible_extensions
clang::ObjCInterfaceDecl::visible_extensions_begin
clang::ObjCInterfaceDecl::visible_extensions_end
clang::ObjCInterfaceDecl::visible_extensions_empty
clang::ObjCInterfaceDecl::isKnownExtension
clang::ObjCInterfaceDecl::known_extensions
clang::ObjCInterfaceDecl::known_extensions_begin
clang::ObjCInterfaceDecl::known_extensions_end
clang::ObjCInterfaceDecl::known_extensions_empty
clang::ObjCInterfaceDecl::getCategoryListRaw
clang::ObjCInterfaceDecl::setCategoryListRaw
clang::ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass
clang::ObjCInterfaceDecl::collectPropertiesToImplement
clang::ObjCInterfaceDecl::isSuperClassOf
clang::ObjCInterfaceDecl::isArcWeakrefUnavailable
clang::ObjCInterfaceDecl::isObjCRequiresPropertyDefs
clang::ObjCInterfaceDecl::lookupInstanceVariable
clang::ObjCInterfaceDecl::lookupInstanceVariable
clang::ObjCInterfaceDecl::lookupNestedProtocol
clang::ObjCInterfaceDecl::lookupMethod
clang::ObjCInterfaceDecl::lookupInstanceMethod
clang::ObjCInterfaceDecl::lookupClassMethod
clang::ObjCInterfaceDecl::lookupInheritedClass
clang::ObjCInterfaceDecl::lookupPrivateMethod
clang::ObjCInterfaceDecl::lookupPrivateClassMethod
clang::ObjCInterfaceDecl::lookupPropertyAccessor
clang::ObjCInterfaceDecl::getEndOfDefinitionLoc
clang::ObjCInterfaceDecl::setEndOfDefinitionLoc
clang::ObjCInterfaceDecl::getSuperClassLoc
clang::ObjCInterfaceDecl::isImplicitInterfaceDecl
clang::ObjCInterfaceDecl::ClassImplementsProtocol
clang::ObjCInterfaceDecl::getCanonicalDecl
clang::ObjCInterfaceDecl::getCanonicalDecl
clang::ObjCInterfaceDecl::getTypeForDecl
clang::ObjCInterfaceDecl::setTypeForDecl
clang::ObjCInterfaceDecl::classof
clang::ObjCInterfaceDecl::classofKind
clang::ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers
clang::ObjCInterfaceDecl::inheritsDesignatedInitializers
clang::ObjCIvarDecl::anchor
clang::ObjCIvarDecl::AccessControl
clang::ObjCIvarDecl::Create
clang::ObjCIvarDecl::CreateDeserialized
clang::ObjCIvarDecl::getContainingInterface
clang::ObjCIvarDecl::getNextIvar
clang::ObjCIvarDecl::getNextIvar
clang::ObjCIvarDecl::setNextIvar
clang::ObjCIvarDecl::setAccessControl
clang::ObjCIvarDecl::getAccessControl
clang::ObjCIvarDecl::getCanonicalAccessControl
clang::ObjCIvarDecl::setSynthesize
clang::ObjCIvarDecl::getSynthesize
clang::ObjCIvarDecl::getUsageType
clang::ObjCIvarDecl::classof
clang::ObjCIvarDecl::classofKind
clang::ObjCIvarDecl::NextIvar
clang::ObjCIvarDecl::DeclAccess
clang::ObjCIvarDecl::Synthesized
clang::ObjCAtDefsFieldDecl::anchor
clang::ObjCAtDefsFieldDecl::Create
clang::ObjCAtDefsFieldDecl::CreateDeserialized
clang::ObjCAtDefsFieldDecl::classof
clang::ObjCAtDefsFieldDecl::classofKind
clang::ObjCProtocolDecl::DefinitionData
clang::ObjCProtocolDecl::DefinitionData::Definition
clang::ObjCProtocolDecl::DefinitionData::ReferencedProtocols
clang::ObjCProtocolDecl::Data
clang::ObjCProtocolDecl::anchor
clang::ObjCProtocolDecl::data
clang::ObjCProtocolDecl::allocateDefinitionData
clang::ObjCProtocolDecl::getNextRedeclarationImpl
clang::ObjCProtocolDecl::getPreviousDeclImpl
clang::ObjCProtocolDecl::getMostRecentDeclImpl
clang::ObjCProtocolDecl::Create
clang::ObjCProtocolDecl::CreateDeserialized
clang::ObjCProtocolDecl::getReferencedProtocols
clang::ObjCProtocolDecl::protocols
clang::ObjCProtocolDecl::protocol_begin
clang::ObjCProtocolDecl::protocol_end
clang::ObjCProtocolDecl::protocol_locs
clang::ObjCProtocolDecl::protocol_loc_begin
clang::ObjCProtocolDecl::protocol_loc_end
clang::ObjCProtocolDecl::protocol_size
clang::ObjCProtocolDecl::setProtocolList
clang::ObjCProtocolDecl::lookupProtocolNamed
clang::ObjCProtocolDecl::lookupMethod
clang::ObjCProtocolDecl::lookupInstanceMethod
clang::ObjCProtocolDecl::lookupClassMethod
clang::ObjCProtocolDecl::hasDefinition
clang::ObjCProtocolDecl::getDefinition
clang::ObjCProtocolDecl::getDefinition
clang::ObjCProtocolDecl::isThisDeclarationADefinition
clang::ObjCProtocolDecl::startDefinition
clang::ObjCProtocolDecl::getObjCRuntimeNameAsString
clang::ObjCProtocolDecl::getSourceRange
clang::ObjCProtocolDecl::getCanonicalDecl
clang::ObjCProtocolDecl::getCanonicalDecl
clang::ObjCProtocolDecl::collectPropertiesToImplement
clang::ObjCProtocolDecl::collectInheritedProtocolProperties
clang::ObjCProtocolDecl::classof
clang::ObjCProtocolDecl::classofKind
clang::ObjCCategoryDecl::ClassInterface
clang::ObjCCategoryDecl::TypeParamList
clang::ObjCCategoryDecl::ReferencedProtocols
clang::ObjCCategoryDecl::NextClassCategory
clang::ObjCCategoryDecl::CategoryNameLoc
clang::ObjCCategoryDecl::IvarLBraceLoc
clang::ObjCCategoryDecl::IvarRBraceLoc
clang::ObjCCategoryDecl::anchor
clang::ObjCCategoryDecl::Create
clang::ObjCCategoryDecl::CreateDeserialized
clang::ObjCCategoryDecl::getClassInterface
clang::ObjCCategoryDecl::getClassInterface
clang::ObjCCategoryDecl::getTypeParamList
clang::ObjCCategoryDecl::setTypeParamList
clang::ObjCCategoryDecl::getImplementation
clang::ObjCCategoryDecl::setImplementation
clang::ObjCCategoryDecl::setProtocolList
clang::ObjCCategoryDecl::getReferencedProtocols
clang::ObjCCategoryDecl::protocols
clang::ObjCCategoryDecl::protocol_begin
clang::ObjCCategoryDecl::protocol_end
clang::ObjCCategoryDecl::protocol_size
clang::ObjCCategoryDecl::protocol_locs
clang::ObjCCategoryDecl::protocol_loc_begin
clang::ObjCCategoryDecl::protocol_loc_end
clang::ObjCCategoryDecl::getNextClassCategory
clang::ObjCCategoryDecl::getNextClassCategoryRaw
clang::ObjCCategoryDecl::IsClassExtension
clang::ObjCCategoryDecl::ivars
clang::ObjCCategoryDecl::ivar_begin
clang::ObjCCategoryDecl::ivar_end
clang::ObjCCategoryDecl::ivar_size
clang::ObjCCategoryDecl::ivar_empty
clang::ObjCCategoryDecl::getCategoryNameLoc
clang::ObjCCategoryDecl::setCategoryNameLoc
clang::ObjCCategoryDecl::setIvarLBraceLoc
clang::ObjCCategoryDecl::getIvarLBraceLoc
clang::ObjCCategoryDecl::setIvarRBraceLoc
clang::ObjCCategoryDecl::getIvarRBraceLoc
clang::ObjCCategoryDecl::classof
clang::ObjCCategoryDecl::classofKind
clang::ObjCImplDecl::ClassInterface
clang::ObjCImplDecl::anchor
clang::ObjCImplDecl::getClassInterface
clang::ObjCImplDecl::getClassInterface
clang::ObjCImplDecl::setClassInterface
clang::ObjCImplDecl::addInstanceMethod
clang::ObjCImplDecl::addClassMethod
clang::ObjCImplDecl::addPropertyImplementation
clang::ObjCImplDecl::FindPropertyImplDecl
clang::ObjCImplDecl::FindPropertyImplIvarDecl
clang::ObjCImplDecl::property_impls
clang::ObjCImplDecl::propimpl_begin
clang::ObjCImplDecl::propimpl_end
clang::ObjCImplDecl::classof
clang::ObjCImplDecl::classofKind
clang::ObjCCategoryImplDecl::CategoryNameLoc
clang::ObjCCategoryImplDecl::anchor
clang::ObjCCategoryImplDecl::Create
clang::ObjCCategoryImplDecl::CreateDeserialized
clang::ObjCCategoryImplDecl::getCategoryDecl
clang::ObjCCategoryImplDecl::getCategoryNameLoc
clang::ObjCCategoryImplDecl::classof
clang::ObjCCategoryImplDecl::classofKind
clang::ObjCImplementationDecl::SuperClass
clang::ObjCImplementationDecl::SuperLoc
clang::ObjCImplementationDecl::IvarLBraceLoc
clang::ObjCImplementationDecl::IvarRBraceLoc
clang::ObjCImplementationDecl::IvarInitializers
clang::ObjCImplementationDecl::NumIvarInitializers
clang::ObjCImplementationDecl::HasNonZeroConstructors
clang::ObjCImplementationDecl::HasDestructors
clang::ObjCImplementationDecl::anchor
clang::ObjCImplementationDecl::Create
clang::ObjCImplementationDecl::CreateDeserialized
clang::ObjCImplementationDecl::inits
clang::ObjCImplementationDecl::inits
clang::ObjCImplementationDecl::init_begin
clang::ObjCImplementationDecl::init_begin
clang::ObjCImplementationDecl::init_end
clang::ObjCImplementationDecl::init_end
clang::ObjCImplementationDecl::getNumIvarInitializers
clang::ObjCImplementationDecl::setNumIvarInitializers
clang::ObjCImplementationDecl::setIvarInitializers
clang::ObjCImplementationDecl::hasNonZeroConstructors
clang::ObjCImplementationDecl::setHasNonZeroConstructors
clang::ObjCImplementationDecl::hasDestructors
clang::ObjCImplementationDecl::setHasDestructors
clang::ObjCImplementationDecl::getIdentifier
clang::ObjCImplementationDecl::getName
clang::ObjCImplementationDecl::getNameAsString
clang::ObjCImplementationDecl::getObjCRuntimeNameAsString
clang::ObjCImplementationDecl::getSuperClass
clang::ObjCImplementationDecl::getSuperClass
clang::ObjCImplementationDecl::getSuperClassLoc
clang::ObjCImplementationDecl::setSuperClass
clang::ObjCImplementationDecl::setIvarLBraceLoc
clang::ObjCImplementationDecl::getIvarLBraceLoc
clang::ObjCImplementationDecl::setIvarRBraceLoc
clang::ObjCImplementationDecl::getIvarRBraceLoc
clang::ObjCImplementationDecl::ivars
clang::ObjCImplementationDecl::ivar_begin
clang::ObjCImplementationDecl::ivar_end
clang::ObjCImplementationDecl::ivar_size
clang::ObjCImplementationDecl::ivar_empty
clang::ObjCImplementationDecl::classof
clang::ObjCImplementationDecl::classofKind
clang::ObjCCompatibleAliasDecl::AliasedClass
clang::ObjCCompatibleAliasDecl::anchor
clang::ObjCCompatibleAliasDecl::Create
clang::ObjCCompatibleAliasDecl::CreateDeserialized
clang::ObjCCompatibleAliasDecl::getClassInterface
clang::ObjCCompatibleAliasDecl::getClassInterface
clang::ObjCCompatibleAliasDecl::setClassInterface
clang::ObjCCompatibleAliasDecl::classof
clang::ObjCCompatibleAliasDecl::classofKind
clang::ObjCPropertyImplDecl::Kind
clang::ObjCPropertyImplDecl::AtLoc
clang::ObjCPropertyImplDecl::IvarLoc
clang::ObjCPropertyImplDecl::PropertyDecl
clang::ObjCPropertyImplDecl::PropertyIvarDecl
clang::ObjCPropertyImplDecl::GetterCXXConstructor
clang::ObjCPropertyImplDecl::SetterCXXAssignment
clang::ObjCPropertyImplDecl::Create
clang::ObjCPropertyImplDecl::CreateDeserialized
clang::ObjCPropertyImplDecl::getSourceRange
clang::ObjCPropertyImplDecl::getBeginLoc
clang::ObjCInterfaceDecl::filtered_category_iterator::findAcceptableCategory
clang::ObjCInterfaceDecl::isVisibleCategory
clang::ObjCInterfaceDecl::isVisibleExtension
clang::ObjCInterfaceDecl::isKnownExtension
CodeThinker, Enjoy your reading code