Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

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