[AST][4/4] Move the bit-fields from ObjCMethodDecl and ObjCContainerDecl into DeclContext

[bricci]

Summary

This patch follows https://reviews.llvm.org/D49729,
https://reviews.llvm.org/D49732 and
https://reviews.llvm.org/D49733.

Move the bits from ObjCMethodDecl and ObjCContainerDecl
into DeclContext.

[erichkeane]

Same comment as the other 3.

include/clang/AST/DeclObjC.h

190 ↗

(On Diff #157039)

I'd again omit these.

[bricci]

• clang-format on the changes
• remove the unnecessary getFamilyImpl and setFamilyImpl

[bricci]

rebased after the great whitespace trimming

cfe/trunk/include/clang/AST/DeclObjC.h

 /// A selector represents a unique name for a method. The selector names for
 /// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
 ///
 class ObjCMethodDecl : public NamedDecl, public DeclContext {
 public:
   enum ImplementationControl { None, Required, Optional };
 
 private:
-  // The conventional meaning of this method; an ObjCMethodFamily.
-  // This is not serialized; instead, it is computed on demand and
-  // cached.
-  mutable unsigned Family : ObjCMethodFamilyBitWidth;
-
-  /// instance (true) or class (false) method.
-  unsigned IsInstance : 1;
-  unsigned IsVariadic : 1;
-
-  /// True if this method is the getter or setter for an explicit property.
-  unsigned IsPropertyAccessor : 1;
-
-  // Method has a definition.
-  unsigned IsDefined : 1;
-
-  /// Method redeclaration in the same interface.
-  unsigned IsRedeclaration : 1;
-
-  /// Is redeclared in the same interface.
-  mutable unsigned HasRedeclaration : 1;
-
-  // NOTE: VC++ treats enums as signed, avoid using ImplementationControl enum
-  /// \@required/\@optional
-  unsigned DeclImplementation : 2;
-
-  // NOTE: VC++ treats enums as signed, avoid using the ObjCDeclQualifier enum
-  /// in, inout, etc.
-  unsigned objcDeclQualifier : 7;
-
-  /// Indicates whether this method has a related result type.
-  unsigned RelatedResultType : 1;
-
-  /// Whether the locations of the selector identifiers are in a
-  /// "standard" position, a enum SelectorLocationsKind.
-  unsigned SelLocsKind : 2;
-
-  /// Whether this method overrides any other in the class hierarchy.
-  ///
-  /// A method is said to override any method in the class's
-  /// base classes, its protocols, or its categories' protocols, that has
-  /// the same selector and is of the same kind (class or instance).
-  /// A method in an implementation is not considered as overriding the same
-  /// method in the interface or its categories.
-  unsigned IsOverriding : 1;
-
-  /// Indicates if the method was a definition but its body was skipped.
-  unsigned HasSkippedBody : 1;
-
-  // Return type of this method.
+  /// Return type of this method.
   QualType MethodDeclType;
 
-  // Type source information for the return type.
+  /// Type source information for the return type.
   TypeSourceInfo *ReturnTInfo;
 
   /// Array of ParmVarDecls for the formal parameters of this method
   /// and optionally followed by selector locations.
   void *ParamsAndSelLocs = nullptr;
   unsigned NumParams = 0;
 
   /// List of attributes for this method declaration.
   SourceLocation DeclEndLoc; // the location of the ';' or '{'.
 
-  // The following are only used for method definitions, null otherwise.
+  /// The following are only used for method definitions, null otherwise.
   LazyDeclStmtPtr Body;
 
   /// SelfDecl - Decl for the implicit self parameter. This is lazily
   /// constructed by createImplicitParams.
   ImplicitParamDecl *SelfDecl = nullptr;
 
   /// CmdDecl - Decl for the implicit _cmd parameter. This is lazily
   /// constructed by createImplicitParams.
   ImplicitParamDecl *CmdDecl = nullptr;
 
   ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
                  Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
                  DeclContext *contextDecl, bool isInstance = true,
                  bool isVariadic = false, bool isPropertyAccessor = false,
                  bool isImplicitlyDeclared = false, bool isDefined = false,
                  ImplementationControl impControl = None,
-                 bool HasRelatedResultType = false)
-      : NamedDecl(ObjCMethod, contextDecl, beginLoc, SelInfo),
-        DeclContext(ObjCMethod), Family(InvalidObjCMethodFamily),
-        IsInstance(isInstance), IsVariadic(isVariadic),
-        IsPropertyAccessor(isPropertyAccessor), IsDefined(isDefined),
-        IsRedeclaration(0), HasRedeclaration(0), DeclImplementation(impControl),
-        objcDeclQualifier(OBJC_TQ_None),
-        RelatedResultType(HasRelatedResultType),
-        SelLocsKind(SelLoc_StandardNoSpace), IsOverriding(0), HasSkippedBody(0),
-        MethodDeclType(T), ReturnTInfo(ReturnTInfo), DeclEndLoc(endLoc) {
-    setImplicit(isImplicitlyDeclared);
-  }
+                 bool HasRelatedResultType = false);
 
   SelectorLocationsKind getSelLocsKind() const {
-    return (SelectorLocationsKind)SelLocsKind;
+    return static_cast<SelectorLocationsKind>(ObjCMethodDeclBits.SelLocsKind);
+  }
+
+  void setSelLocsKind(SelectorLocationsKind Kind) {
+    ObjCMethodDeclBits.SelLocsKind = Kind;
   }
 
   bool hasStandardSelLocs() const {
     return getSelLocsKind() != SelLoc_NonStandard;
   }
 
   /// Get a pointer to the stored selector identifiers locations array.
   /// No locations will be stored if HasStandardSelLocs is true.
   SourceLocation *getStoredSelLocs() {
-    return reinterpret_cast<SourceLocation*>(getParams() + NumParams);
+    return reinterpret_cast<SourceLocation *>(getParams() + NumParams);
   }
   const SourceLocation *getStoredSelLocs() const {
-    return reinterpret_cast<const SourceLocation*>(getParams() + NumParams);
+    return reinterpret_cast<const SourceLocation *>(getParams() + NumParams);
   }
 
   /// Get a pointer to the stored selector identifiers locations array.
   /// No locations will be stored if HasStandardSelLocs is true.
   ParmVarDecl **getParams() {
     return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs);
   }
   const ParmVarDecl *const *getParams() const {
public:
   static ObjCMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   ObjCMethodDecl *getCanonicalDecl() override;
   const ObjCMethodDecl *getCanonicalDecl() const {
     return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl();
   }
 
   ObjCDeclQualifier getObjCDeclQualifier() const {
-    return ObjCDeclQualifier(objcDeclQualifier);
+    return static_cast<ObjCDeclQualifier>(ObjCMethodDeclBits.objcDeclQualifier);
+  }
+
+  void setObjCDeclQualifier(ObjCDeclQualifier QV) {
+    ObjCMethodDeclBits.objcDeclQualifier = QV;
   }
-  void setObjCDeclQualifier(ObjCDeclQualifier QV) { objcDeclQualifier = QV; }
 
   /// Determine whether this method has a result type that is related
   /// to the message receiver's type.
-  bool hasRelatedResultType() const { return RelatedResultType; }
+  bool hasRelatedResultType() const {
+    return ObjCMethodDeclBits.RelatedResultType;
+  }
 
   /// Note whether this method has a related result type.
-  void SetRelatedResultType(bool RRT = true) { RelatedResultType = RRT; }
+  void setRelatedResultType(bool RRT = true) {
+    ObjCMethodDeclBits.RelatedResultType = RRT;
+  }
 
   /// True if this is a method redeclaration in the same interface.
-  bool isRedeclaration() const { return IsRedeclaration; }
+  bool isRedeclaration() const { return ObjCMethodDeclBits.IsRedeclaration; }
+  void setIsRedeclaration(bool RD) { ObjCMethodDeclBits.IsRedeclaration = RD; }
   void setAsRedeclaration(const ObjCMethodDecl *PrevMethod);
 
+  /// True if redeclared in the same interface.
+  bool hasRedeclaration() const { return ObjCMethodDeclBits.HasRedeclaration; }
+  void setHasRedeclaration(bool HRD) const {
+    ObjCMethodDeclBits.HasRedeclaration = HRD;
+  }
+
   /// Returns the location where the declarator ends. It will be
   /// the location of ';' for a method declaration and the location of '{'
   /// for a method definition.
   SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; }
 
   // Location information, modeled after the Stmt API.
   SourceLocation getLocStart() const LLVM_READONLY { return getLocation(); }
   SourceLocation getLocEnd() const LLVM_READONLY;
public:
   ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }
   void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; }
   ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }
   void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; }
 
   /// Determines the family of this method.
   ObjCMethodFamily getMethodFamily() const;
 
-  bool isInstanceMethod() const { return IsInstance; }
-  void setInstanceMethod(bool isInst) { IsInstance = isInst; }
-  bool isVariadic() const { return IsVariadic; }
-  void setVariadic(bool isVar) { IsVariadic = isVar; }
+  bool isInstanceMethod() const { return ObjCMethodDeclBits.IsInstance; }
+  void setInstanceMethod(bool isInst) {
+    ObjCMethodDeclBits.IsInstance = isInst;
+  }
+
+  bool isVariadic() const { return ObjCMethodDeclBits.IsVariadic; }
+  void setVariadic(bool isVar) { ObjCMethodDeclBits.IsVariadic = isVar; }
 
-  bool isClassMethod() const { return !IsInstance; }
+  bool isClassMethod() const { return !isInstanceMethod(); }
 
-  bool isPropertyAccessor() const { return IsPropertyAccessor; }
-  void setPropertyAccessor(bool isAccessor) { IsPropertyAccessor = isAccessor; }
+  bool isPropertyAccessor() const {
+    return ObjCMethodDeclBits.IsPropertyAccessor;
+  }
 
-  bool isDefined() const { return IsDefined; }
-  void setDefined(bool isDefined) { IsDefined = isDefined; }
+  void setPropertyAccessor(bool isAccessor) {
+    ObjCMethodDeclBits.IsPropertyAccessor = isAccessor;
+  }
+
+  bool isDefined() const { return ObjCMethodDeclBits.IsDefined; }
+  void setDefined(bool isDefined) { ObjCMethodDeclBits.IsDefined = isDefined; }
 
   /// Whether this method overrides any other in the class hierarchy.
   ///
   /// A method is said to override any method in the class's
   /// base classes, its protocols, or its categories' protocols, that has
   /// the same selector and is of the same kind (class or instance).
   /// A method in an implementation is not considered as overriding the same
   /// method in the interface or its categories.
-  bool isOverriding() const { return IsOverriding; }
-  void setOverriding(bool isOverriding) { IsOverriding = isOverriding; }
+  bool isOverriding() const { return ObjCMethodDeclBits.IsOverriding; }
+  void setOverriding(bool IsOver) { ObjCMethodDeclBits.IsOverriding = IsOver; }
 
   /// Return overridden methods for the given \p Method.
   ///
   /// An ObjC method is considered to override any method in the class's
   /// base classes (and base's categories), its protocols, or its categories'
   /// protocols, that has
   /// the same selector and is of the same kind (class or instance).
   /// A method in an implementation is not considered as overriding the same
   /// method in the interface or its categories.
   void getOverriddenMethods(
                      SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const;
 
   /// True if the method was a definition but its body was skipped.
-  bool hasSkippedBody() const { return HasSkippedBody; }
-  void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
+  bool hasSkippedBody() const { return ObjCMethodDeclBits.HasSkippedBody; }
+  void setHasSkippedBody(bool Skipped = true) {
+    ObjCMethodDeclBits.HasSkippedBody = Skipped;
+  }
 
   /// Returns the property associated with this method's selector.
   ///
   /// Note that even if this particular method is not marked as a property
   /// accessor, it is still possible for it to match a property declared in a
   /// superclass. Pass \c false if you only want to check the current class.
   const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const;
 
   // Related to protocols declared in  \@protocol
   void setDeclImplementation(ImplementationControl ic) {
-    DeclImplementation = ic;
+    ObjCMethodDeclBits.DeclImplementation = ic;
   }
 
   ImplementationControl getImplementationControl() const {
-    return ImplementationControl(DeclImplementation);
+    return ImplementationControl(ObjCMethodDeclBits.DeclImplementation);
   }
 
   bool isOptional() const {
     return getImplementationControl() == Optional;
   }
 
   /// Returns true if this specific method declaration is marked with the
   /// designated initializer attribute.
public:
   static bool classofKind(Kind K) { return K == ObjCProperty; }
 };
 
 /// ObjCContainerDecl - Represents a container for method declarations.
 /// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl,
 /// ObjCProtocolDecl, and ObjCImplDecl.
 ///
 class ObjCContainerDecl : public NamedDecl, public DeclContext {
-  SourceLocation AtStart;
-
   // These two locations in the range mark the end of the method container.
   // The first points to the '@' token, and the second to the 'end' token.
   SourceRange AtEnd;
 
   void anchor() override;
 
 public:
-  ObjCContainerDecl(Kind DK, DeclContext *DC,
-                    IdentifierInfo *Id, SourceLocation nameLoc,
-                    SourceLocation atStartLoc)
-      : NamedDecl(DK, DC, nameLoc, Id), DeclContext(DK), AtStart(atStartLoc) {}
+  ObjCContainerDecl(Kind DK, DeclContext *DC, IdentifierInfo *Id,
+                    SourceLocation nameLoc, SourceLocation atStartLoc);
 
   // Iterator access to instance/class properties.
   using prop_iterator = specific_decl_iterator<ObjCPropertyDecl>;
   using prop_range =
       llvm::iterator_range<specific_decl_iterator<ObjCPropertyDecl>>;
 
   prop_range properties() const { return prop_range(prop_begin(), prop_end()); }
 
public:
   using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>;
 
   /// This routine collects list of properties to be implemented in the class.
   /// This includes, class's and its conforming protocols' properties.
   /// Note, the superclass's properties are not included in the list.
   virtual void collectPropertiesToImplement(PropertyMap &PM,
                                             PropertyDeclOrder &PO) const {}
 
-  SourceLocation getAtStartLoc() const { return AtStart; }
-  void setAtStartLoc(SourceLocation Loc) { AtStart = Loc; }
+  SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; }
 
-  // Marks the end of the container.
-  SourceRange getAtEndRange() const {
-    return AtEnd;
+  void setAtStartLoc(SourceLocation Loc) {
+    ObjCContainerDeclBits.AtStart = Loc;
   }
 
-  void setAtEndRange(SourceRange atEnd) {
-    AtEnd = atEnd;
-  }
+  // Marks the end of the container.
+  SourceRange getAtEndRange() const { return AtEnd; }
+
+  void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; }
 
   SourceRange getSourceRange() const override LLVM_READONLY {
-    return SourceRange(AtStart, getAtEndRange().getEnd());
+    return SourceRange(getAtStartLoc(), getAtEndRange().getEnd());
   }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 
   static bool classofKind(Kind K) {
     return K >= firstObjCContainer &&
            K <= lastObjCContainer;

cfe/trunk/lib/AST/DeclObjC.cpp

void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
   memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
   set(InList, Elts, Ctx);
 }
 
 //===----------------------------------------------------------------------===//
 // ObjCInterfaceDecl
 //===----------------------------------------------------------------------===//
 
+ObjCContainerDecl::ObjCContainerDecl(Kind DK, DeclContext *DC,
+                                     IdentifierInfo *Id, SourceLocation nameLoc,
+                                     SourceLocation atStartLoc)
+    : NamedDecl(DK, DC, nameLoc, Id), DeclContext(DK) {
+  setAtStartLoc(atStartLoc);
+}
+
 void ObjCContainerDecl::anchor() {}
 
 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
 ///
 ObjCIvarDecl *
 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
   lookup_result R = lookup(Id);
   for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
if (!Method && getSuperClass())
     return getSuperClass()->lookupPrivateMethod(Sel, Instance);
   return Method;
 }
 
 //===----------------------------------------------------------------------===//
 // ObjCMethodDecl
 //===----------------------------------------------------------------------===//
 
+ObjCMethodDecl::ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
+                               Selector SelInfo, QualType T,
+                               TypeSourceInfo *ReturnTInfo,
+                               DeclContext *contextDecl, bool isInstance,
+                               bool isVariadic, bool isPropertyAccessor,
+                               bool isImplicitlyDeclared, bool isDefined,
+                               ImplementationControl impControl,
+                               bool HasRelatedResultType)
+    : NamedDecl(ObjCMethod, contextDecl, beginLoc, SelInfo),
+      DeclContext(ObjCMethod), MethodDeclType(T), ReturnTInfo(ReturnTInfo),
+      DeclEndLoc(endLoc) {
+  // See the comment in ObjCMethodFamilyBitfields about
+  // ObjCMethodFamilyBitWidth for why we check this.
+  static_assert(
+      static_cast<unsigned>(ObjCMethodDeclBits.ObjCMethodFamilyBitWidth) ==
+          static_cast<unsigned>(ObjCMethodFamilyBitWidth),
+      "ObjCMethodDeclBitfields::ObjCMethodFamilyBitWidth and "
+      "ObjCMethodFamilyBitWidth do not match!");
+
+  // Initialized the bits stored in DeclContext.
+  ObjCMethodDeclBits.Family =
+      static_cast<ObjCMethodFamily>(InvalidObjCMethodFamily);
+  setInstanceMethod(isInstance);
+  setVariadic(isVariadic);
+  setPropertyAccessor(isPropertyAccessor);
+  setDefined(isDefined);
+  setIsRedeclaration(false);
+  setHasRedeclaration(false);
+  setDeclImplementation(impControl);
+  setObjCDeclQualifier(OBJC_TQ_None);
+  setRelatedResultType(HasRelatedResultType);
+  setSelLocsKind(SelLoc_StandardNoSpace);
+  setOverriding(false);
+  setHasSkippedBody(false);
+
+  setImplicit(isImplicitlyDeclared);
+}
+
 ObjCMethodDecl *ObjCMethodDecl::Create(
     ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,
     Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
     DeclContext *contextDecl, bool isInstance, bool isVariadic,
     bool isPropertyAccessor, bool isImplicitlyDeclared, bool isDefined,
     ImplementationControl impControl, bool HasRelatedResultType) {
   return new (C, contextDecl) ObjCMethodDecl(
       beginLoc, endLoc, SelInfo, T, ReturnTInfo, contextDecl, isInstance,

 
 Stmt *ObjCMethodDecl::getBody() const {
   return Body.get(getASTContext().getExternalSource());
 }
 
 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
   assert(PrevMethod);
   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
-  IsRedeclaration = true;
-  PrevMethod->HasRedeclaration = true;
+  setIsRedeclaration(true);
+  PrevMethod->setHasRedeclaration(true);
 }
 
 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
                                          ArrayRef<ParmVarDecl*> Params,
                                          ArrayRef<SourceLocation> SelLocs) {
   ParamsAndSelLocs = nullptr;
   NumParams = Params.size();
   if (Params.empty() && SelLocs.empty())

 void ObjCMethodDecl::setMethodParams(ASTContext &C,
                                      ArrayRef<ParmVarDecl*> Params,
                                      ArrayRef<SourceLocation> SelLocs) {
   assert((!SelLocs.empty() || isImplicit()) &&
          "No selector locs for non-implicit method");
   if (isImplicit())
     return setParamsAndSelLocs(C, Params, llvm::None);
 
-  SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params,
-                                        DeclEndLoc);
-  if (SelLocsKind != SelLoc_NonStandard)
+  setSelLocsKind(hasStandardSelectorLocs(getSelector(), SelLocs, Params,
+                                        DeclEndLoc));
+  if (getSelLocsKind() != SelLoc_NonStandard)
     return setParamsAndSelLocs(C, Params, llvm::None);
 
   setParamsAndSelLocs(C, Params, SelLocs);
 }
 
 /// A definition will return its interface declaration.
 /// An interface declaration will return its definition.
 /// Otherwise it will return itself.
 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() {
   ASTContext &Ctx = getASTContext();
   ObjCMethodDecl *Redecl = nullptr;
-  if (HasRedeclaration)
+  if (hasRedeclaration())
     Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
   if (Redecl)
     return Redecl;
 
   auto *CtxD = cast<Decl>(getDeclContext());
 
   if (!CtxD->isInvalidDecl()) {
     if (auto *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {

 
 SourceLocation ObjCMethodDecl::getLocEnd() const {
   if (Stmt *Body = getBody())
     return Body->getLocEnd();
   return DeclEndLoc;
 }
 
 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
-  auto family = static_cast<ObjCMethodFamily>(Family);
+  auto family = static_cast<ObjCMethodFamily>(ObjCMethodDeclBits.Family);
   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
     return family;
 
   // Check for an explicit attribute.
   if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
     // The unfortunate necessity of mapping between enums here is due
     // to the attributes framework.
     switch (attr->getFamily()) {
     case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
     case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
     case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
     case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
     case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
     case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
     }
-    Family = static_cast<unsigned>(family);
+    ObjCMethodDeclBits.Family = family;
     return family;
   }
 
   family = getSelector().getMethodFamily();
   switch (family) {
   case OMF_None: break;
 
   // init only has a conventional meaning for an instance method, and
else {
         }
       }
     }
     break;
 
   }
 
   // Cache the result.
-  Family = static_cast<unsigned>(family);
+  ObjCMethodDeclBits.Family = family;
   return family;
 }
 
 QualType ObjCMethodDecl::getSelfType(ASTContext &Context,
                                      const ObjCInterfaceDecl *OID,
                                      bool &selfIsPseudoStrong,
                                      bool &selfIsConsumed) {
   QualType selfTy;

cfe/trunk/lib/Sema/SemaDeclObjC.cpp

if (!hasOverriddenMethodsInBaseOrProtocol) {
             }
           }
         }
       }
     }
 
     // Propagate down the 'related result type' bit from overridden methods.
     if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
-      ObjCMethod->SetRelatedResultType();
+      ObjCMethod->setRelatedResultType();
 
     // Then merge the declarations.
     mergeObjCMethodDecls(ObjCMethod, overridden);
 
     if (ObjCMethod->isImplicit() && overridden->isImplicit())
       continue; // Conflicting properties are detected elsewhere.
 
     // Check for overriding methods
if (!ARCError && RTC == Sema::RTC_Compatible &&
     case OMF_retain:
     case OMF_self:
       InferRelatedResultType = ObjCMethod->isInstanceMethod();
       break;
     }
 
     if (InferRelatedResultType &&
         !ObjCMethod->getReturnType()->isObjCIndependentClassType())
-      ObjCMethod->SetRelatedResultType();
+      ObjCMethod->setRelatedResultType();
   }
 
   if (MethodDefinition &&
       Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
     checkObjCMethodX86VectorTypes(*this, ObjCMethod);
 
   // + load method cannot have availability attributes. It get called on
   // startup, so it has to have the availability of the deployment target.

cfe/trunk/lib/Serialization/ASTReaderDecl.cpp

if (Record.readInt()) {
     HasPendingBody = true;
     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>());
     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>());
   }
   MD->setInstanceMethod(Record.readInt());
   MD->setVariadic(Record.readInt());
   MD->setPropertyAccessor(Record.readInt());
   MD->setDefined(Record.readInt());
-  MD->IsOverriding = Record.readInt();
-  MD->HasSkippedBody = Record.readInt();
+  MD->setOverriding(Record.readInt());
+  MD->setHasSkippedBody(Record.readInt());
 
-  MD->IsRedeclaration = Record.readInt();
-  MD->HasRedeclaration = Record.readInt();
-  if (MD->HasRedeclaration)
+  MD->setIsRedeclaration(Record.readInt());
+  MD->setHasRedeclaration(Record.readInt());
+  if (MD->hasRedeclaration())
     Reader.getContext().setObjCMethodRedeclaration(MD,
                                        ReadDeclAs<ObjCMethodDecl>());
 
   MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record.readInt());
   MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record.readInt());
-  MD->SetRelatedResultType(Record.readInt());
+  MD->setRelatedResultType(Record.readInt());
   MD->setReturnType(Record.readType());
   MD->setReturnTypeSourceInfo(GetTypeSourceInfo());
   MD->DeclEndLoc = ReadSourceLocation();
   unsigned NumParams = Record.readInt();
   SmallVector<ParmVarDecl *, 16> Params;
   Params.reserve(NumParams);
   for (unsigned I = 0; I != NumParams; ++I)
     Params.push_back(ReadDeclAs<ParmVarDecl>());
 
-  MD->SelLocsKind = Record.readInt();
+  MD->setSelLocsKind((SelectorLocationsKind)Record.readInt());
   unsigned NumStoredSelLocs = Record.readInt();
   SmallVector<SourceLocation, 16> SelLocs;
   SelLocs.reserve(NumStoredSelLocs);
   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
     SelLocs.push_back(ReadSourceLocation());
 
   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
 }

cfe/trunk/lib/Serialization/ASTWriterDecl.cpp

if (HasBodyStuff) {
     Record.AddStmt(D->getBody());
     Record.AddDeclRef(D->getSelfDecl());
     Record.AddDeclRef(D->getCmdDecl());
   }
   Record.push_back(D->isInstanceMethod());
   Record.push_back(D->isVariadic());
   Record.push_back(D->isPropertyAccessor());
   Record.push_back(D->isDefined());
-  Record.push_back(D->IsOverriding);
-  Record.push_back(D->HasSkippedBody);
+  Record.push_back(D->isOverriding());
+  Record.push_back(D->hasSkippedBody());
 
-  Record.push_back(D->IsRedeclaration);
-  Record.push_back(D->HasRedeclaration);
-  if (D->HasRedeclaration) {
+  Record.push_back(D->isRedeclaration());
+  Record.push_back(D->hasRedeclaration());
+  if (D->hasRedeclaration()) {
     assert(Context.getObjCMethodRedeclaration(D));
     Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
   }
 
   // FIXME: stable encoding for @required/@optional
   Record.push_back(D->getImplementationControl());
   // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
   Record.push_back(D->getObjCDeclQualifier());
   Record.push_back(D->hasRelatedResultType());
   Record.AddTypeRef(D->getReturnType());
   Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
   Record.AddSourceLocation(D->getLocEnd());
   Record.push_back(D->param_size());
   for (const auto *P : D->parameters())
     Record.AddDeclRef(P);
 
-  Record.push_back(D->SelLocsKind);
+  Record.push_back(D->getSelLocsKind());
   unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
   SourceLocation *SelLocs = D->getStoredSelLocs();
   Record.push_back(NumStoredSelLocs);
   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
     Record.AddSourceLocation(SelLocs[i]);
 
   Code = serialization::DECL_OBJC_METHOD;
 }