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