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