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