Coverage Report

Created: 2022-05-17 06:19

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