fix determination of whether declarations are visible during ObjC lookups

[rsmith]

Summary

Determining whether a declaration is visible or not requires knowledge of the context in which the question is asked: for instance, during template instantiation, additional modules might be visible, and with local submodule visibility, the set of visible declarations can shrink as well as grow throughout the compilation.

This patch explicitly passes an "is hidden" callback to all ObjC lookup functions on Decl rather than relying on the increasingly-inaccurate Hidden bit to provide useful information. (Ideally, these lookup functions would be moved to Sema instead; that change can follow if it makes sense.)

Please pay particular attention to the places where AllDeclsVisible is passed: in those places, we do not have any local visibility context. Possibly some of them should be doing something more subtle than ignoring module visibility rules.

The test from PR33552 does /not/ pass with this change, I'm still digging into what else might be wrong here.

[rsmith]

The remaining missing pieces were ObjCInterfaceDecl::visible_categories and ObjCInterfaceDecl::visible_extensions. The new revision of the patch gets a bit further down the road of passing through real visibility information into those, but that approach seems to snowball out of control. For example, ASTContext::mergeTypes now needs visibility information in order to determine whether two ObjC object types are compatible (because this depends on whether the types have compatible sets of protocols, which in turn can vary depending on which categories are visible for those two types). I have not completed this patch: there are still a lot of places that an IsHiddenFunction would need to be plumbed through to make this work.

The fact that type compatibility can vary depending on the context in which you ask seems like a significant design issue with ObjC categories; perhaps a modest and reasonable change to the language (and particularly the interaction between modules and categories) could avoid at least some of this implementation complexity, but I'm not the right person to design or champion such a change.

include/clang/AST/ASTContext.h

       : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
 };
 
+typedef llvm::function_ref<bool(const NamedDecl*)> IsHiddenFunction;
+
 /// \brief Holds long-lived AST nodes (such as types and decls) that can be
 /// referred to throughout the semantic analysis of a file.
 class ASTContext : public RefCountedBase<ASTContext> {

                                 ArrayRef<ObjCProtocolDecl *> protocols,
                                 QualType Canonical = QualType()) const;
 
-  bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl);
+  bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl,
+                                      IsHiddenFunction IsHidden);
   /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
   /// QT's qualified-id protocol list adopt all protocols in IDecl's list
   /// of protocols.
   bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
-                                            ObjCInterfaceDecl *IDecl);
+                                            ObjCInterfaceDecl *IDecl,
+                                            IsHiddenFunction IsHidden);
 
   /// \brief Return a ObjCObjectPointerType type for the given ObjCObjectType.
   QualType getObjCObjectPointerType(QualType OIT) const;

                             SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const;
 
   unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const;
-  void CollectInheritedProtocols(const Decl *CDecl,
-                          llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols);
+  void
+  CollectInheritedProtocols(const Decl *CDecl,
+                            llvm::SmallPtrSet<ObjCProtocolDecl *, 8> &Protocols,
+                            IsHiddenFunction IsHidden);
 
   //===--------------------------------------------------------------------===//
   //                            Type Operators

     return T == getObjCSelType();
   }
   bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
-                                         bool ForCompare);
+                                         bool ForCompare,
+                                         IsHiddenFunction IsHidden);
 
   bool ObjCQualifiedClassTypesAreCompatible(QualType LHS, QualType RHS);
 
   // Check the safety of assignment from LHS to RHS
   bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
-                               const ObjCObjectPointerType *RHSOPT);
+                               const ObjCObjectPointerType *RHSOPT,
+                               IsHiddenFunction IsHidden);
   bool canAssignObjCInterfaces(const ObjCObjectType *LHS,
-                               const ObjCObjectType *RHS);
+                               const ObjCObjectType *RHS,
+                               IsHiddenFunction IsHidden);
   bool canAssignObjCInterfacesInBlockPointer(
-                                          const ObjCObjectPointerType *LHSOPT,
-                                          const ObjCObjectPointerType *RHSOPT,
-                                          bool BlockReturnType);
+      const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT,
+      bool BlockReturnType, IsHiddenFunction IsHidden);
   bool areComparableObjCPointerTypes(QualType LHS, QualType RHS);
   QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT,
                                    const ObjCObjectPointerType *RHSOPT);
-  bool canBindObjCObjectType(QualType To, QualType From);
+  bool canBindObjCObjectType(QualType To, QualType From,
+                             IsHiddenFunction IsHidden);
 
   // Functions for calculating composite types
   QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false,

include/clang/AST/DeclObjC.h

            const SourceLocation *Locs, ASTContext &Ctx);
 };
 
+/// A callback used to determine which declarations should be visible to ObjC
+/// name lookups.
+// FIXME: This should not be necessary; the name lookup logic should be in Sema.
+typedef llvm::function_ref<bool(const NamedDecl*)> IsHiddenFunction;
 
+/// An IsHiddenFunction callback for the case where all declarations should be
+/// considered to be visible.
+bool AllDeclsVisible(const NamedDecl*);
+
 /// ObjCMethodDecl - Represents an instance or class method declaration.
 /// ObjC methods can be declared within 4 contexts: class interfaces,
 /// categories, protocols, and class implementations. While C++ member

   /// 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;
+  const ObjCPropertyDecl *findPropertyDecl(IsHiddenFunction IsHidden,
+                                           bool CheckOverrides = true) const;
 
   // Related to protocols declared in  \@protocol
   void setDeclImplementation(ImplementationControl ic) {

   /// the method declaration that was marked with the designated initializer
   /// attribute.
   bool isDesignatedInitializerForTheInterface(
+      IsHiddenFunction IsHidden,
       const ObjCMethodDecl **InitMethod = nullptr) const;
 
   /// \brief Determine whether this method has a body.

   /// Lookup a property by name in the specified DeclContext.
   static ObjCPropertyDecl *findPropertyDecl(const DeclContext *DC,
                                             const IdentifierInfo *propertyID,
-                                            ObjCPropertyQueryKind queryKind);
+                                            ObjCPropertyQueryKind queryKind,
+                                            IsHiddenFunction IsHidden);
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ObjCProperty; }

 
   // Get the local instance/class method declared in this interface.
   ObjCMethodDecl *getMethod(Selector Sel, bool isInstance,
-                            bool AllowHidden = false) const;
+                            IsHiddenFunction IsHidden) const;
   ObjCMethodDecl *getInstanceMethod(Selector Sel,
-                                    bool AllowHidden = false) const {
-    return getMethod(Sel, true/*isInstance*/, AllowHidden);
+                                    IsHiddenFunction IsHidden) const {
+    return getMethod(Sel, true/*isInstance*/, IsHidden);
   }
-  ObjCMethodDecl *getClassMethod(Selector Sel, bool AllowHidden = false) const {
-    return getMethod(Sel, false/*isInstance*/, AllowHidden);
+  ObjCMethodDecl *getClassMethod(Selector Sel,
+                                 IsHiddenFunction IsHidden) const {
+    return getMethod(Sel, false/*isInstance*/, IsHidden);
   }
-  bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P) const;
+  bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P,
+                                   IsHiddenFunction IsHidden) const;
   ObjCIvarDecl *getIvarDecl(IdentifierInfo *Id) const;
 
-  ObjCPropertyDecl *
-  FindPropertyDeclaration(const IdentifierInfo *PropertyId,
-                          ObjCPropertyQueryKind QueryKind) const;
+  ObjCPropertyDecl *FindPropertyDeclaration(const IdentifierInfo *PropertyId,
+                                            ObjCPropertyQueryKind QueryKind,
+                                            IsHiddenFunction IsHidden) const;
 
   typedef llvm::DenseMap<std::pair<IdentifierInfo*,
                                    unsigned/*isClassProperty*/>,

 
   /// Returns true if this interface decl declares a designated initializer
   /// or it inherites one from its super class.
-  bool declaresOrInheritsDesignatedInitializers() const {
-    return hasDesignatedInitializers() || inheritsDesignatedInitializers();
+  bool
+  declaresOrInheritsDesignatedInitializers(IsHiddenFunction IsHidden) const {
+    return hasDesignatedInitializers() ||
+           inheritsDesignatedInitializers(IsHidden);
   }
 
   const ObjCProtocolList &getReferencedProtocols() const {

   ObjCImplementationDecl *getImplementation() const;
   void setImplementation(ObjCImplementationDecl *ImplD);
 
-  ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const;
+  ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId,
+                                            IsHiddenFunction IsHidden) const;
 
   // Get the local instance/class method declared in a category.
-  ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel) const;
-  ObjCMethodDecl *getCategoryClassMethod(Selector Sel) const;
-  ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance) const {
-    return isInstance ? getCategoryInstanceMethod(Sel)
-                      : getCategoryClassMethod(Sel);
+  ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel,
+                                            IsHiddenFunction IsHidden) const;
+  ObjCMethodDecl *getCategoryClassMethod(Selector Sel,
+                                         IsHiddenFunction IsHidden) const;
+  ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance,
+                                    IsHiddenFunction IsHidden) const {
+    return isInstance ? getCategoryInstanceMethod(Sel, IsHidden)
+                      : getCategoryClassMethod(Sel, IsHidden);
   }
 
   typedef ObjCProtocolList::iterator protocol_iterator;

   /// initializers then the interface inherits the designated initializers of
   /// its super class.
   void getDesignatedInitializers(
-                  llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const;
+      llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods,
+      IsHiddenFunction IsHidden) const;
 
   /// Returns true if the given selector is a designated initializer for the
   /// interface.

   ///
   /// \param InitMethod if non-null and the function returns true, it receives
   /// the method that was marked as a designated initializer.
-  bool
-  isDesignatedInitializer(Selector Sel,
-                          const ObjCMethodDecl **InitMethod = nullptr) const;
+  bool isDesignatedInitializer(Selector Sel,
+                               const ObjCMethodDecl **InitMethod,
+                               IsHiddenFunction IsHidden) const;
+  bool isDesignatedInitializer(Selector Sel,
+                               IsHiddenFunction IsHidden) const {
+    return isDesignatedInitializer(Sel, nullptr, IsHidden);
+  }
 
   /// \brief Determine whether this particular declaration of this class is
   /// actually also a definition.

   ///
   /// This class template is used for the various permutations of category
   /// and extension iterators.
-  template<bool (*Filter)(ObjCCategoryDecl *)>
+  template<typename Filter>
   class filtered_category_iterator {
     ObjCCategoryDecl *Current;
+    Filter FilterFn;
 
     void findAcceptableCategory();
     

     typedef std::ptrdiff_t          difference_type;
     typedef std::input_iterator_tag iterator_category;
 
-    filtered_category_iterator() : Current(nullptr) { }
+    filtered_category_iterator() : filtered_category_iterator(Filter()) {}
+    filtered_category_iterator(Filter F) : Current(nullptr), FilterFn(F) {}
     explicit filtered_category_iterator(ObjCCategoryDecl *Current)
-      : Current(Current)
-    {
+      : filtered_category_iterator(Current, Filter()) {}
+    explicit filtered_category_iterator(ObjCCategoryDecl *Current, Filter F)
+        : Current(Current), FilterFn(F) {
       findAcceptableCategory();
     }
 

   /// \brief Test whether the given category is visible.
   ///
   /// Used in the \c visible_categories_iterator.
-  static bool isVisibleCategory(ObjCCategoryDecl *Cat);
+  struct IsVisibleCategoryFilter {
+    IsHiddenFunction IsHidden;
+    IsVisibleCategoryFilter(IsHiddenFunction IsHidden) : IsHidden(IsHidden) {}
+    bool operator()(ObjCCategoryDecl *Cat) const;
+  };
                         
 public:
   /// \brief Iterator that walks over the list of categories and extensions
   /// that are visible, i.e., not hidden in a non-imported submodule.
-  typedef filtered_category_iterator<isVisibleCategory>
+  typedef filtered_category_iterator<IsVisibleCategoryFilter>
     visible_categories_iterator;
 
   typedef llvm::iterator_range<visible_categories_iterator>
     visible_categories_range;
 
-  visible_categories_range visible_categories() const {
-    return visible_categories_range(visible_categories_begin(),
-                                    visible_categories_end());
+  visible_categories_range visible_categories(IsHiddenFunction IsHidden) const {
+    return visible_categories_range(visible_categories_begin(IsHidden),
+                                    visible_categories_end(IsHidden));
   }
 
   /// \brief Retrieve an iterator to the beginning of the visible-categories
   /// list.
-  visible_categories_iterator visible_categories_begin() const {
-    return visible_categories_iterator(getCategoryListRaw());
+  visible_categories_iterator
+  visible_categories_begin(IsHiddenFunction IsHidden) const {
+    return visible_categories_iterator(getCategoryListRaw(), IsHidden);
   }
 
   /// \brief Retrieve an iterator to the end of the visible-categories list.
-  visible_categories_iterator visible_categories_end() const {
-    return visible_categories_iterator();
+  visible_categories_iterator
+  visible_categories_end(IsHiddenFunction IsHidden) const {
+    return visible_categories_iterator(IsHidden);
   }
 
   /// \brief Determine whether the visible-categories list is empty.
-  bool visible_categories_empty() const {
-    return visible_categories_begin() == visible_categories_end();
+  bool visible_categories_empty(IsHiddenFunction IsHidden) const {
+    return visible_categories_begin(IsHidden) ==
+           visible_categories_end(IsHidden);
   }
 
 private:

   /// \brief Test whether the given category... is a category.
   ///
   /// Used in the \c known_categories_iterator.
-  static bool isKnownCategory(ObjCCategoryDecl *) { return true; }
+  struct IsKnownCategoryFilter {
+    bool operator()(ObjCCategoryDecl *) const { return true; }
+  };
 
 public:
   /// \brief Iterator that walks over all of the known categories and
   /// extensions, including those that are hidden.
-  typedef filtered_category_iterator<isKnownCategory> known_categories_iterator;
+  typedef filtered_category_iterator<IsKnownCategoryFilter>
+    known_categories_iterator;
   typedef llvm::iterator_range<known_categories_iterator>
     known_categories_range;
 

   /// \brief Test whether the given category is a visible extension.
   ///
   /// Used in the \c visible_extensions_iterator.
-  static bool isVisibleExtension(ObjCCategoryDecl *Cat);
+  struct IsVisibleExtensionFilter {
+    IsHiddenFunction IsHidden;
+    IsVisibleExtensionFilter(IsHiddenFunction IsHidden) : IsHidden(IsHidden) {}
+    bool operator()(ObjCCategoryDecl *Cat) const;
+  };
 
 public:
   /// \brief Iterator that walks over all of the visible extensions, skipping
   /// any that are known but hidden.
-  typedef filtered_category_iterator<isVisibleExtension>
+  typedef filtered_category_iterator<IsVisibleExtensionFilter>
     visible_extensions_iterator;
 
   typedef llvm::iterator_range<visible_extensions_iterator>
     visible_extensions_range;
 
-  visible_extensions_range visible_extensions() const {
-    return visible_extensions_range(visible_extensions_begin(),
-                                    visible_extensions_end());
+  visible_extensions_range visible_extensions(IsHiddenFunction IsHidden) const {
+    return visible_extensions_range(visible_extensions_begin(IsHidden),
+                                    visible_extensions_end(IsHidden));
   }
 
   /// \brief Retrieve an iterator to the beginning of the visible-extensions
   /// list.
-  visible_extensions_iterator visible_extensions_begin() const {
-    return visible_extensions_iterator(getCategoryListRaw());
+  visible_extensions_iterator
+  visible_extensions_begin(IsHiddenFunction IsHidden) const {
+    return visible_extensions_iterator(getCategoryListRaw(), IsHidden);
   }
 
   /// \brief Retrieve an iterator to the end of the visible-extensions list.
-  visible_extensions_iterator visible_extensions_end() const {
-    return visible_extensions_iterator();
+  visible_extensions_iterator
+  visible_extensions_end(IsHiddenFunction IsHidden) const {
+    return visible_extensions_iterator(IsHidden);
   }
 
   /// \brief Determine whether the visible-extensions list is empty.
-  bool visible_extensions_empty() const {
-    return visible_extensions_begin() == visible_extensions_end();
+  bool visible_extensions_empty(IsHiddenFunction IsHidden) const {
+    return visible_extensions_begin(IsHidden) ==
+           visible_extensions_end(IsHidden);
   }
 
 private:

   /// \brief Test whether the given category is an extension.
   ///
   /// Used in the \c known_extensions_iterator.
-  static bool isKnownExtension(ObjCCategoryDecl *Cat);
+  struct IsKnownExtensionFilter {
+    bool operator()(ObjCCategoryDecl *Cat) const;
+  };
   
 public:
   /// \brief Iterator that walks over all of the known extensions.
-  typedef filtered_category_iterator<isKnownExtension>
+  typedef filtered_category_iterator<IsKnownExtensionFilter>
     known_extensions_iterator;
   typedef llvm::iterator_range<known_extensions_iterator>
     known_extensions_range;

 
   ObjCPropertyDecl
     *FindPropertyVisibleInPrimaryClass(IdentifierInfo *PropertyId,
-                                       ObjCPropertyQueryKind QueryKind) const;
+                                       ObjCPropertyQueryKind QueryKind,
+                                       IsHiddenFunction IsHidden) const;
 
   void collectPropertiesToImplement(PropertyMap &PM,
                                     PropertyDeclOrder &PO) const override;

   const ObjCInterfaceDecl *isObjCRequiresPropertyDefs() const;
 
   ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName,
-                                       ObjCInterfaceDecl *&ClassDeclared);
-  ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName) {
+                                       ObjCInterfaceDecl *&ClassDeclared,
+                                       IsHiddenFunction IsHidden);
+  ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName,
+                                       IsHiddenFunction IsHidden) {
     ObjCInterfaceDecl *ClassDeclared;
-    return lookupInstanceVariable(IVarName, ClassDeclared);
+    return lookupInstanceVariable(IVarName, ClassDeclared, IsHidden);
   }
 
   ObjCProtocolDecl *lookupNestedProtocol(IdentifierInfo *Name);

   // Lookup a method. First, we search locally. If a method isn't
   // found, we search referenced protocols and class categories.
   ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance,
+                               IsHiddenFunction IsHidden,
                                bool shallowCategoryLookup = false,
                                bool followSuper = true,
                                const ObjCCategoryDecl *C = nullptr) const;
 
   /// Lookup an instance method for a given selector.
-  ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
-    return lookupMethod(Sel, true/*isInstance*/);
+  ObjCMethodDecl *lookupInstanceMethod(Selector Sel,
+                                       IsHiddenFunction IsHidden) const {
+    return lookupMethod(Sel, true/*isInstance*/, IsHidden);
   }
 
   /// Lookup a class method for a given selector.
-  ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
-    return lookupMethod(Sel, false/*isInstance*/);
+  ObjCMethodDecl *lookupClassMethod(Selector Sel,
+                                    IsHiddenFunction IsHidden) const {
+    return lookupMethod(Sel, false/*isInstance*/, IsHidden);
   }
   ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);
 
   /// \brief Lookup a method in the classes implementation hierarchy.
   ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
-                                      bool Instance=true) const;
-
-  ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) {
-    return lookupPrivateMethod(Sel, false);
+                                      bool Instance,
+                                      IsHiddenFunction IsHidden) const;
+  ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
+                                      IsHiddenFunction IsHidden) const {
+    return lookupPrivateMethod(Sel, true, IsHidden);
   }
+  ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel,
+                                           IsHiddenFunction IsHidden) {
+    return lookupPrivateMethod(Sel, false, IsHidden);
+  }
 
   /// \brief Lookup a setter or getter in the class hierarchy,
   /// including in all categories except for category passed
   /// as argument.
   ObjCMethodDecl *lookupPropertyAccessor(const Selector Sel,
+                                         IsHiddenFunction IsHidden,
                                          const ObjCCategoryDecl *Cat,
                                          bool IsClassProperty) const {
-    return lookupMethod(Sel, !IsClassProperty/*isInstance*/,
+    return lookupMethod(Sel, !IsClassProperty/*isInstance*/, IsHidden,
                         false/*shallowCategoryLookup*/,
                         true /* followsSuper */,
                         Cat);

   /// has been implemented in IDecl class, its super class or categories (if
   /// lookupCategory is true).
   bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
-                               bool lookupCategory,
+                               bool LookupInCategories,
+                               IsHiddenFunction IsHidden,
                                bool RHSIsQualifiedID = false);
 
   typedef redeclarable_base::redecl_range redecl_range;

   friend class ASTDeclWriter;
 
 private:
-  const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const;
-  bool inheritsDesignatedInitializers() const;
+  const ObjCInterfaceDecl *
+  findInterfaceWithDesignatedInitializers(IsHiddenFunction IsHidden) const;
+  bool inheritsDesignatedInitializers(IsHiddenFunction IsHidden) const;
 };
 
 /// ObjCIvarDecl - Represents an ObjC instance variable. In general, ObjC

 
   // Lookup a method. First, we search locally. If a method isn't
   // found, we search referenced protocols and class categories.
-  ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const;
-  ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
-    return lookupMethod(Sel, true/*isInstance*/);
+  ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance,
+                               IsHiddenFunction IsHidden) const;
+  ObjCMethodDecl *lookupInstanceMethod(Selector Sel,
+                                       IsHiddenFunction IsHidden) const {
+    return lookupMethod(Sel, true/*isInstance*/, IsHidden);
   }
-  ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
-    return lookupMethod(Sel, false/*isInstance*/);
+  ObjCMethodDecl *lookupClassMethod(Selector Sel,
+                                    IsHiddenFunction IsHidden) const {
+    return lookupMethod(Sel, false/*isInstance*/, IsHidden);
   }
 
   /// \brief Determine whether this protocol has a definition.

   friend class ASTDeclReader;
 };
 
-template<bool (*Filter)(ObjCCategoryDecl *)>
+template<typename Filter>
 void
 ObjCInterfaceDecl::filtered_category_iterator<Filter>::
 findAcceptableCategory() {
-  while (Current && !Filter(Current))
+  while (Current && !FilterFn(Current))
     Current = Current->getNextClassCategoryRaw();
 }
 
-template<bool (*Filter)(ObjCCategoryDecl *)>
+template<typename Filter>
 inline ObjCInterfaceDecl::filtered_category_iterator<Filter> &
 ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() {
   Current = Current->getNextClassCategoryRaw();

   return *this;
 }
 
-inline bool ObjCInterfaceDecl::isVisibleCategory(ObjCCategoryDecl *Cat) {
-  return !Cat->isHidden();
+inline bool ObjCInterfaceDecl::IsVisibleCategoryFilter::
+operator()(ObjCCategoryDecl *Cat) const {
+  return !IsHidden(Cat);
 }
 
-inline bool ObjCInterfaceDecl::isVisibleExtension(ObjCCategoryDecl *Cat) {
-  return Cat->IsClassExtension() && !Cat->isHidden();
+inline bool ObjCInterfaceDecl::IsVisibleExtensionFilter::
+operator()(ObjCCategoryDecl *Cat) const {
+  return Cat->IsClassExtension() && !IsHidden(Cat);
 }
 
-inline bool ObjCInterfaceDecl::isKnownExtension(ObjCCategoryDecl *Cat) {
+inline bool ObjCInterfaceDecl::IsKnownExtensionFilter::
+operator()(ObjCCategoryDecl *Cat) const {
   return Cat->IsClassExtension();
 }
 

include/clang/Sema/Sema.h

     return !D->isHidden() || isVisibleSlow(D);
   }
 
+  /// "Is this declaration hidden?" callback used for ObjC lookups.
+  struct IsHiddenCallback {
+    Sema &S;
+    IsHiddenCallback(Sema &S) : S(S) {}
+    bool operator()(const NamedDecl *D) const { return !S.isVisible(D); }
+  };
+
   /// Determine whether any declaration of an entity is visible.
   bool
   hasVisibleDeclaration(const NamedDecl *D,

   /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
   /// It also returns ivar's property on success.
   ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
-                                               const ObjCPropertyDecl *&PDecl) const;
+                                               const ObjCPropertyDecl *&PDecl);
 
   /// Called by ActOnProperty to handle \@property declarations in
   /// class extensions.

lib/ARCMigrate/ObjCMT.cpp

   SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
                                          PP.getSelectorTable(),
                                          getterName);
-  ObjCMethodDecl *SetterMethod = D->getInstanceMethod(SetterSelector);
+  ObjCMethodDecl *SetterMethod =
+      D->getInstanceMethod(SetterSelector, AllDeclsVisible);
   unsigned LengthOfPrefix = 0;
   if (!SetterMethod) {
     // try a different naming convention for getter: isXxxxx

         SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
                                                PP.getSelectorTable(),
                                                getterName);
-        SetterMethod = D->getInstanceMethod(SetterSelector);
+        SetterMethod = D->getInstanceMethod(SetterSelector, AllDeclsVisible);
       }
     }
   }

     return;
 
   for (const auto *MD : ImplD->instance_methods()) {
-    if (MD->isDeprecated() ||
-        MD->getMethodFamily() != OMF_init ||
-        MD->isDesignatedInitializerForTheInterface())
+    if (MD->isDeprecated() || MD->getMethodFamily() != OMF_init ||
+        MD->isDesignatedInitializerForTheInterface(AllDeclsVisible))
       continue;
-    const ObjCMethodDecl *IFaceM = IFace->getMethod(MD->getSelector(),
-                                                    /*isInstance=*/true);
+    const ObjCMethodDecl *IFaceM =
+        IFace->getMethod(MD->getSelector(),
+                         /*isInstance=*/true, AllDeclsVisible);
     if (!IFaceM)
       continue;
     if (hasSuperInitCall(MD)) {

lib/AST/ASTContext.cpp

     // Add redeclared method here.
     for (const auto *Ext : ID->known_extensions()) {
       if (ObjCMethodDecl *RedeclaredMethod =
               Ext->getMethod(ObjCMethod->getSelector(),
-                                  ObjCMethod->isInstanceMethod()))
+                             ObjCMethod->isInstanceMethod(), AllDeclsVisible))
         Redeclared.push_back(RedeclaredMethod);
     }
   }

       SmallVector<const NamedDecl*, 8> Overridden;
       const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D);
       if (OMD && OMD->isPropertyAccessor())
-        if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
+        if (const ObjCPropertyDecl *PDecl =
+                OMD->findPropertyDecl(AllDeclsVisible))
           if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
             return cloneFullComment(FC, D);
       if (OMD)

 
 /// CollectInheritedProtocols - Collect all protocols in current class and
 /// those inherited by it.
-void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
-                          llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
+void ASTContext::CollectInheritedProtocols(
+    const Decl *CDecl, llvm::SmallPtrSet<ObjCProtocolDecl *, 8> &Protocols,
+    IsHiddenFunction IsHidden) {
   if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
     // We can use protocol_iterator here instead of
     // all_referenced_protocol_iterator since we are walking all categories.    
     for (auto *Proto : OI->all_referenced_protocols()) {
-      CollectInheritedProtocols(Proto, Protocols);
+      CollectInheritedProtocols(Proto, Protocols, IsHidden);
     }
     
     // Categories of this Interface.
-    for (const auto *Cat : OI->visible_categories())
-      CollectInheritedProtocols(Cat, Protocols);
+    for (const auto *Cat : OI->visible_categories(IsHidden))
+      CollectInheritedProtocols(Cat, Protocols, IsHidden);
 
     if (ObjCInterfaceDecl *SD = OI->getSuperClass())
       while (SD) {
-        CollectInheritedProtocols(SD, Protocols);
+        CollectInheritedProtocols(SD, Protocols, IsHidden);
         SD = SD->getSuperClass();
       }
   } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
     for (auto *Proto : OC->protocols()) {
-      CollectInheritedProtocols(Proto, Protocols);
+      CollectInheritedProtocols(Proto, Protocols, IsHidden);
     }
   } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
     // Insert the protocol.

       return;
 
     for (auto *Proto : OP->protocols())
-      CollectInheritedProtocols(Proto, Protocols);
+      CollectInheritedProtocols(Proto, Protocols, IsHidden);
   }
 }
 

 /// protocol list adopt all protocols in QT's qualified-id protocol
 /// list.
 bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT,
-                                                ObjCInterfaceDecl *IC) {
+                                                ObjCInterfaceDecl *IC,
+                                                IsHiddenFunction IsHidden) {
   if (!QT->isObjCQualifiedIdType())
     return false;
   

   if (const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>()) {
     // If both the right and left sides have qualifiers.
     for (auto *Proto : OPT->quals()) {
-      if (!IC->ClassImplementsProtocol(Proto, false))
+      if (!IC->ClassImplementsProtocol(Proto, false, IsHidden))
         return false;
     }
     return true;

 /// QT's qualified-id protocol list adopt all protocols in IDecl's list
 /// of protocols.
 bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
-                                                ObjCInterfaceDecl *IDecl) {
+                                                ObjCInterfaceDecl *IDecl,
+                                                IsHiddenFunction IsHidden) {
   if (!QT->isObjCQualifiedIdType())
     return false;
   const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>();

   if (!IDecl->hasDefinition())
     return false;
   llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
-  CollectInheritedProtocols(IDecl, InheritedProtocols);
+  CollectInheritedProtocols(IDecl, InheritedProtocols, IsHidden);
   if (InheritedProtocols.empty())
     return false;
   // Check that if every protocol in list of id<plist> conforms to a protcol

 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
 /// ObjCQualifiedIDType.
 bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
-                                                   bool compare) {
+                                                   bool compare,
+                                                   IsHiddenFunction IsHidden) {
   // Allow id<P..> and an 'id' or void* type in all cases.
   if (lhs->isVoidPointerType() ||
       lhs->isObjCIdType() || lhs->isObjCClassType())

           // when comparing an id<P> on lhs with a static type on rhs,
           // see if static class implements all of id's protocols, directly or
           // through its super class and categories.
-          if (!rhsID->ClassImplementsProtocol(I, true))
+          if (!rhsID->ClassImplementsProtocol(I, true, IsHidden))
             return false;
         }
       }

           // when comparing an id<P> on lhs with a static type on rhs,
           // see if static class implements all of id's protocols, directly or
           // through its super class and categories.
-          if (rhsID->ClassImplementsProtocol(I, true)) {
+          if (rhsID->ClassImplementsProtocol(I, true, IsHidden)) {
             match = true;
             break;
           }

       if (!match)
         return false;
     }
-    
     // Static class's protocols, or its super class or category protocols
-    // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
+    // must be found, direct or indirect in rhs's qualifier list or it is a
+    // mismatch.
     if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
       llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
-      CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
+      CollectInheritedProtocols(lhsID, LHSInheritedProtocols, IsHidden);
       // This is rather dubious but matches gcc's behavior. If lhs has
       // no type qualifier and its class has no static protocol(s)
       // assume that it is mismatch.

 /// protocol qualifiers on the LHS or RHS.
 ///
 bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
-                                         const ObjCObjectPointerType *RHSOPT) {
+                                         const ObjCObjectPointerType *RHSOPT,
+                                         IsHiddenFunction IsHidden) {
   const ObjCObjectType* LHS = LHSOPT->getObjectType();
   const ObjCObjectType* RHS = RHSOPT->getObjectType();
 

     // Strip off __kindof and protocol qualifiers, then check whether
     // we can assign the other way.
     return canAssignObjCInterfaces(RHSOPT->stripObjCKindOfTypeAndQuals(*this),
-                                   LHSOPT->stripObjCKindOfTypeAndQuals(*this));
+                                   LHSOPT->stripObjCKindOfTypeAndQuals(*this),
+                                   IsHidden);
   };
 
   if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
     return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
                                                     QualType(RHSOPT,0),
-                                                    false));
+                                                    false,
+                                                    IsHidden));
   }
   
   if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {

   
   // If we have 2 user-defined types, fall into that path.
   if (LHS->getInterface() && RHS->getInterface()) {
-    return finish(canAssignObjCInterfaces(LHS, RHS));
+    return finish(canAssignObjCInterfaces(LHS, RHS, IsHidden));
   }
 
   return false;

 /// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
 /// not OK. For the return type, the opposite is not OK.
 bool ASTContext::canAssignObjCInterfacesInBlockPointer(
-                                         const ObjCObjectPointerType *LHSOPT,
-                                         const ObjCObjectPointerType *RHSOPT,
-                                         bool BlockReturnType) {
-
+    const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT,
+    bool BlockReturnType, IsHiddenFunction IsHidden) {
   // Function object that propagates a successful result or handles
   // __kindof types.
   auto finish = [&](bool succeeded) -> bool {

     return canAssignObjCInterfacesInBlockPointer(
              RHSOPT->stripObjCKindOfTypeAndQuals(*this),
              LHSOPT->stripObjCKindOfTypeAndQuals(*this),
-             BlockReturnType);
+             BlockReturnType, IsHidden);
   };
 
   if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())

   if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
     return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
                                                     QualType(RHSOPT,0),
-                                                    false));
+                                                    false, IsHidden));
   
   const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
   const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();

 /// the given common base.
 /// It is used to build composite qualifier list of the composite type of
 /// the conditional expression involving two objective-c pointer objects.
-static 
-void getIntersectionOfProtocols(ASTContext &Context,
-                                const ObjCInterfaceDecl *CommonBase,
-                                const ObjCObjectPointerType *LHSOPT,
-                                const ObjCObjectPointerType *RHSOPT,
-      SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
-  
+static void getIntersectionOfProtocols(
+    ASTContext &Context, const ObjCInterfaceDecl *CommonBase,
+    const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT,
+    SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet,
+    IsHiddenFunction IsHidden) {
+
   const ObjCObjectType* LHS = LHSOPT->getObjectType();
   const ObjCObjectType* RHS = RHSOPT->getObjectType();
   assert(LHS->getInterface() && "LHS must have an interface base");

 
   // Start with the protocol qualifiers.
   for (auto proto : LHS->quals()) {
-    Context.CollectInheritedProtocols(proto, LHSProtocolSet);
+    Context.CollectInheritedProtocols(proto, LHSProtocolSet, IsHidden);
   }
 
   // Also add the protocols associated with the LHS interface.
-  Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
+  Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet,
+                                    IsHidden);
 
   // Add all of the protocls for the RHS.
   llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSProtocolSet;

 
   // Start with the protocol qualifiers.
   for (auto proto : RHS->quals()) {
-    Context.CollectInheritedProtocols(proto, RHSProtocolSet);
+    Context.CollectInheritedProtocols(proto, RHSProtocolSet, IsHidden);
   }
 
   // Also add the protocols associated with the RHS interface.
-  Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
+  Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet,
+                                    IsHidden);
 
   // Compute the intersection of the collected protocol sets.
   for (auto proto : LHSProtocolSet) {

   // Compute the set of protocols that is implied by either the common type or
   // the protocols within the intersection.
   llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ImpliedProtocols;
-  Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
+  Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols, IsHidden);
 
   // Remove any implied protocols from the list of inherited protocols.
   if (!ImpliedProtocols.empty()) {

 }
 
 bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
-                                         const ObjCObjectType *RHS) {
+                                         const ObjCObjectType *RHS,
+                                         IsHiddenFunction IsHidden) {
   assert(LHS->getInterface() && "LHS is not an interface type");
   assert(RHS->getInterface() && "RHS is not an interface type");
 

     // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
     // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
     llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
-    CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
+    CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols,
+                              IsHidden);
     // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
     // qualifiers.
     for (auto *RHSPI : RHS->quals())
-      CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
+      CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols, IsHidden);
     // If there is no protocols associated with RHS, it is not a match.
     if (SuperClassInheritedProtocols.empty())
       return false;

   return true;
 }
 
-bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
+bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS,
+                                               IsHiddenFunction IsHidden) {
   // get the "pointed to" types
   const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
   const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>();

   if (!LHSOPT || !RHSOPT)
     return false;
 
-  return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
-         canAssignObjCInterfaces(RHSOPT, LHSOPT);
+  return canAssignObjCInterfaces(LHSOPT, RHSOPT, IsHidden) ||
+         canAssignObjCInterfaces(RHSOPT, LHSOPT, IsHidden);
 }
 
-bool ASTContext::canBindObjCObjectType(QualType To, QualType From) {
+bool ASTContext::canBindObjCObjectType(QualType To, QualType From,
+                                       IsHiddenFunction IsHidden) {
   return canAssignObjCInterfaces(
-                getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
-                getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
+      getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>(), IsHidden);
 }
 
 /// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,

lib/AST/ASTImporter.cpp

     return nullptr;
 
   // Determine if we've already encountered this category.
-  ObjCCategoryDecl *MergeWithCategory
-    = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
+  ObjCCategoryDecl *MergeWithCategory = ToInterface->FindCategoryDeclaration(
+      Name.getAsIdentifierInfo(), AllDeclsVisible);
   ObjCCategoryDecl *ToCategory = MergeWithCategory;
   if (!ToCategory) {
     ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,

lib/AST/DeclObjC.cpp

   return nullptr;
 }
 
+bool clang::AllDeclsVisible(const NamedDecl *ND) { return false; }
+
 // Get the local instance/class method declared in this interface.
-ObjCMethodDecl *
-ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
-                             bool AllowHidden) const {
+ObjCMethodDecl *ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
+                                             IsHiddenFunction IsHidden) const {
   // If this context is a hidden protocol definition, don't find any
   // methods there.
   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
-      if (Def->isHidden() && !AllowHidden)
+      if (IsHidden(Def))
         return nullptr;
   }
 

 /// property.  This is because, user must provide a setter method for the
 /// category's 'readwrite' property.
 bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
-    const ObjCPropertyDecl *Property) const {
+    const ObjCPropertyDecl *Property, IsHiddenFunction IsHidden) const {
   Selector Sel = Property->getSetterName();
   lookup_result R = lookup(Sel);
   for (lookup_iterator Meth = R.begin(), MethEnd = R.end();

   if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
     // Also look into categories, including class extensions, looking
     // for a user declared instance method.
-    for (const auto *Cat : ID->visible_categories()) {
-      if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel))
+    for (const auto *Cat : ID->visible_categories(IsHidden)) {
+      if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel, IsHidden))
         if (!MD->isImplicit())
           return true;
       if (Cat->IsClassExtension())

     
     // Also look into protocols, for a user declared instance method.
     for (const auto *Proto : ID->all_referenced_protocols())
-      if (Proto->HasUserDeclaredSetterMethod(Property))
+      if (Proto->HasUserDeclaredSetterMethod(Property, IsHidden))
         return true;
 
     // And in its super class.
     ObjCInterfaceDecl *OSC = ID->getSuperClass();
     while (OSC) {
-      if (OSC->HasUserDeclaredSetterMethod(Property))
+      if (OSC->HasUserDeclaredSetterMethod(Property, IsHidden))
         return true;
       OSC = OSC->getSuperClass();
     }

   }
   if (const ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(this))
     for (const auto *PI : PD->protocols())
-      if (PI->HasUserDeclaredSetterMethod(Property))
+      if (PI->HasUserDeclaredSetterMethod(Property, IsHidden))
         return true;
   return false;
 }

 ObjCPropertyDecl *
 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
                                    const IdentifierInfo *propertyID,
-                                   ObjCPropertyQueryKind queryKind) {
+                                   ObjCPropertyQueryKind queryKind,
+                                   IsHiddenFunction IsHidden) {
   // If this context is a hidden protocol definition, don't find any
   // property.
   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
-      if (Def->isHidden())
+      if (IsHidden(Def))
         return nullptr;
   }
 

   // If context is class, then lookup property in its visible extensions.
   // This comes before property is looked up in primary class.
   if (auto *IDecl = dyn_cast<ObjCInterfaceDecl>(DC)) {
-    for (const auto *Ext : IDecl->visible_extensions())
-      if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(Ext,
-                                                       propertyID,
-                                                       queryKind))
+    for (const auto *Ext : IDecl->visible_extensions(IsHidden))
+      if (ObjCPropertyDecl *PD =
+              findPropertyDecl(Ext, propertyID, queryKind, IsHidden))
         return PD;
   }
 

 
 /// FindPropertyDeclaration - Finds declaration of the property given its name
 /// in 'PropertyId' and returns it. It returns 0, if not found.
-ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
-    const IdentifierInfo *PropertyId,
-    ObjCPropertyQueryKind QueryKind) const {
+ObjCPropertyDecl *
+ObjCContainerDecl::FindPropertyDeclaration(const IdentifierInfo *PropertyId,
+                                           ObjCPropertyQueryKind QueryKind,
+                                           IsHiddenFunction IsHidden) const {
   // Don't find properties within hidden protocol definitions.
   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
-      if (Def->isHidden())
+      if (IsHidden(Def))
         return nullptr;
   }
  

   // Search the extensions of a class first; they override what's in
   // the class itself.
   if (const auto *ClassDecl = dyn_cast<ObjCInterfaceDecl>(this)) {
-    for (const auto *Ext : ClassDecl->visible_extensions()) {
-      if (auto *P = Ext->FindPropertyDeclaration(PropertyId, QueryKind))
+    for (const auto *Ext : ClassDecl->visible_extensions(IsHidden)) {
+      if (auto *P =
+              Ext->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
         return P;
     }
   }

 
   if (ObjCPropertyDecl *PD =
         ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
-                                           QueryKind))
+                                           QueryKind, IsHidden))
     return PD;
 
   switch (getKind()) {

     case Decl::ObjCProtocol: {
       const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
       for (const auto *I : PID->protocols())
-        if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                             QueryKind))
+        if (ObjCPropertyDecl *P =
+                I->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
           return P;
       break;
     }

     case Decl::ObjCInterface: {
       const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
       // Look through categories (but not extensions; they were handled above).
-      for (const auto *Cat : OID->visible_categories()) {
+      for (const auto *Cat : OID->visible_categories(IsHidden)) {
         if (!Cat->IsClassExtension())
-          if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(
-                                             PropertyId, QueryKind))
+          if (ObjCPropertyDecl *P =
+                  Cat->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
             return P;
       }
 
       // Look through protocols.
       for (const auto *I : OID->all_referenced_protocols())
-        if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                             QueryKind))
+        if (ObjCPropertyDecl *P =
+                I->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
           return P;
 
       // Finally, check the super class.
       if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
-        return superClass->FindPropertyDeclaration(PropertyId, QueryKind);
+        return superClass->FindPropertyDeclaration(PropertyId, QueryKind,
+                                                   IsHidden);
       break;
     }
     case Decl::ObjCCategory: {

       // Look through protocols.
       if (!OCD->IsClassExtension())
         for (const auto *I : OCD->protocols())
-          if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                               QueryKind))
+          if (ObjCPropertyDecl *P =
+                  I->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
             return P;
       break;
     }

 /// with name 'PropertyId' in the primary class; including those in protocols
 /// (direct or indirect) used by the primary class.
 ///
-ObjCPropertyDecl *
-ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
-                       IdentifierInfo *PropertyId,
-                       ObjCPropertyQueryKind QueryKind) const {
+ObjCPropertyDecl *ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
+    IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind,
+    IsHiddenFunction IsHidden) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;

 
   if (ObjCPropertyDecl *PD =
       ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
-                                         QueryKind))
+                                         QueryKind, IsHidden))
     return PD;
 
   // Look through protocols.
   for (const auto *I : all_referenced_protocols())
-    if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                         QueryKind))
+    if (ObjCPropertyDecl *P =
+            I->FindPropertyDeclaration(PropertyId, QueryKind, IsHidden))
       return P;
 
   return nullptr;

 }
 
 const ObjCInterfaceDecl *
-ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers() const {
+ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers(
+    IsHiddenFunction IsHidden) const {
   const ObjCInterfaceDecl *IFace = this;
   while (IFace) {
     if (IFace->hasDesignatedInitializers())
       return IFace;
-    if (!IFace->inheritsDesignatedInitializers())
+    if (!IFace->inheritsDesignatedInitializers(IsHidden))
       break;
     IFace = IFace->getSuperClass();
   }

   return nullptr;
 }
 
-static bool isIntroducingInitializers(const ObjCInterfaceDecl *D) {
+static bool isIntroducingInitializers(const ObjCInterfaceDecl *D,
+                                      IsHiddenFunction IsHidden) {
   for (const auto *MD : D->instance_methods()) {
     if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
       return true;
   }
-  for (const auto *Ext : D->visible_extensions()) {
+  for (const auto *Ext : D->visible_extensions(IsHidden)) {
     for (const auto *MD : Ext->instance_methods()) {
       if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
         return true;

   return false;
 }
 
-bool ObjCInterfaceDecl::inheritsDesignatedInitializers() const {
+bool ObjCInterfaceDecl::inheritsDesignatedInitializers(
+    IsHiddenFunction IsHidden) const {
   switch (data().InheritedDesignatedInitializers) {
   case DefinitionData::IDI_Inherited:
     return true;

     // If the class introduced initializers we conservatively assume that we
     // don't know if any of them is a designated initializer to avoid possible
     // misleading warnings.
-    if (isIntroducingInitializers(this)) {
+    if (isIntroducingInitializers(this, IsHidden)) {
       data().InheritedDesignatedInitializers = DefinitionData::IDI_NotInherited;
     } else {
       if (auto SuperD = getSuperClass()) {
         data().InheritedDesignatedInitializers =
-          SuperD->declaresOrInheritsDesignatedInitializers() ?
+          SuperD->declaresOrInheritsDesignatedInitializers(IsHidden) ?
             DefinitionData::IDI_Inherited :
             DefinitionData::IDI_NotInherited;
       } else {

 }
 
 void ObjCInterfaceDecl::getDesignatedInitializers(
-    llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const {
+    llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods,
+    IsHiddenFunction IsHidden) const {
   // Check for a complete definition and recover if not so.
   if (!isThisDeclarationADefinition())
     return;

   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
+  const ObjCInterfaceDecl *IFace =
+      findInterfaceWithDesignatedInitializers(IsHidden);
   if (!IFace)
     return;
 

   for (const auto *MD : IFace->instance_methods())
     if (MD->isThisDeclarationADesignatedInitializer())
       Methods.push_back(MD);
-  for (const auto *Ext : IFace->visible_extensions()) {
+  for (const auto *Ext : IFace->visible_extensions(IsHidden)) {
     for (const auto *MD : Ext->instance_methods())
       if (MD->isThisDeclarationADesignatedInitializer())
         Methods.push_back(MD);

   }
 }
 
-bool ObjCInterfaceDecl::isDesignatedInitializer(Selector Sel,
-                                      const ObjCMethodDecl **InitMethod) const {
+bool ObjCInterfaceDecl::isDesignatedInitializer(
+    Selector Sel, const ObjCMethodDecl **InitMethod,
+    IsHiddenFunction IsHidden) const {
   bool HasCompleteDef = isThisDeclarationADefinition();
   // During deserialization the data record for the ObjCInterfaceDecl could
   // be made invariant by reusing the canonical decl. Take this into account

   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
+  const ObjCInterfaceDecl *IFace =
+      findInterfaceWithDesignatedInitializers(IsHidden);
   if (!IFace)
     return false;
 
-  if (const ObjCMethodDecl *MD = IFace->getInstanceMethod(Sel)) {
+  if (const ObjCMethodDecl *MD = IFace->getInstanceMethod(Sel, IsHidden)) {
     if (MD->isThisDeclarationADesignatedInitializer()) {
       if (InitMethod)
         *InitMethod = MD;

       return true;
     }
   }
-  for (const auto *Ext : IFace->visible_extensions()) {
-    if (const ObjCMethodDecl *MD = Ext->getInstanceMethod(Sel)) {
+  for (const auto *Ext : IFace->visible_extensions(IsHidden)) {
+    if (const ObjCMethodDecl *MD = Ext->getInstanceMethod(Sel, IsHidden)) {
       if (MD->isThisDeclarationADesignatedInitializer()) {
         if (InitMethod)
           *InitMethod = MD;

   }
 }
 
-ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
-                                              ObjCInterfaceDecl *&clsDeclared) {
+ObjCIvarDecl *
+ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
+                                          ObjCInterfaceDecl *&clsDeclared,
+                                          IsHiddenFunction IsHidden) {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;

       return I;
     }
 
-    for (const auto *Ext : ClassDecl->visible_extensions()) {
+    for (const auto *Ext : ClassDecl->visible_extensions(IsHidden)) {
       if (ObjCIvarDecl *I = Ext->getIvarDecl(ID)) {
         clsDeclared = ClassDecl;
         return I;

 /// in this category is ignored.
 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel, 
                                                 bool isInstance,
+                                                IsHiddenFunction IsHidden,
                                                 bool shallowCategoryLookup,
                                                 bool followSuper,
                                                 const ObjCCategoryDecl *C) const

 
   while (ClassDecl) {
     // 1. Look through primary class.
-    if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
+    if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance, IsHidden)))
       return MethodDecl;
     
     // 2. Didn't find one yet - now look through categories.
-    for (const auto *Cat : ClassDecl->visible_categories())
-      if ((MethodDecl = Cat->getMethod(Sel, isInstance)))
+    for (const auto *Cat : ClassDecl->visible_categories(IsHidden))
+      if ((MethodDecl = Cat->getMethod(Sel, isInstance, IsHidden)))
         if (C != Cat || !MethodDecl->isImplicit())
           return MethodDecl;
 
     // 3. Didn't find one yet - look through primary class's protocols.
     for (const auto *I : ClassDecl->protocols())
-      if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
+      if ((MethodDecl = I->lookupMethod(Sel, isInstance, IsHidden)))
         return MethodDecl;
     
     // 4. Didn't find one yet - now look through categories' protocols
     if (!shallowCategoryLookup)
-      for (const auto *Cat : ClassDecl->visible_categories()) {
+      for (const auto *Cat : ClassDecl->visible_categories(IsHidden)) {
         // Didn't find one yet - look through protocols.
         const ObjCList<ObjCProtocolDecl> &Protocols =
           Cat->getReferencedProtocols();
         for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
              E = Protocols.end(); I != E; ++I)
-          if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
+          if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance, IsHidden)))
             if (C != Cat || !MethodDecl->isImplicit())
               return MethodDecl;
       }

 // Will search "local" class/category implementations for a method decl.
 // If failed, then we search in class's root for an instance method.
 // Returns 0 if no method is found.
-ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
-                                   const Selector &Sel,
-                                   bool Instance) const {
+ObjCMethodDecl *
+ObjCInterfaceDecl::lookupPrivateMethod(const Selector &Sel, bool Instance,
+                                       IsHiddenFunction IsHidden) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;

 
   ObjCMethodDecl *Method = nullptr;
   if (ObjCImplementationDecl *ImpDecl = getImplementation())
-    Method = Instance ? ImpDecl->getInstanceMethod(Sel) 
-                      : ImpDecl->getClassMethod(Sel);
+    Method = Instance ? ImpDecl->getInstanceMethod(Sel, IsHidden) 
+                      : ImpDecl->getClassMethod(Sel, IsHidden);
 
   // Look through local category implementations associated with the class.
   if (!Method)
-    Method = getCategoryMethod(Sel, Instance);
+    Method = getCategoryMethod(Sel, Instance, IsHidden);
 
   // Before we give up, check if the selector is an instance method.
   // But only in the root. This matches gcc's behavior and what the
   // runtime expects.
   if (!Instance && !Method && !getSuperClass()) {
-    Method = lookupInstanceMethod(Sel);
+    Method = lookupInstanceMethod(Sel, IsHidden);
     // Look through local category implementations associated
     // with the root class.
     if (!Method)
-      Method = lookupPrivateMethod(Sel, true);
+      Method = lookupPrivateMethod(Sel, true, IsHidden);
   }
 
   if (!Method && getSuperClass())
-    return getSuperClass()->lookupPrivateMethod(Sel, Instance);
+    return getSuperClass()->lookupPrivateMethod(Sel, Instance, IsHidden);
   return Method;
 }
 

 }
 
 bool ObjCMethodDecl::isDesignatedInitializerForTheInterface(
-    const ObjCMethodDecl **InitMethod) const {
+    IsHiddenFunction IsHidden, const ObjCMethodDecl **InitMethod) const {
   if (getMethodFamily() != OMF_init)
     return false;
   const DeclContext *DC = getDeclContext();

   if (isa<ObjCProtocolDecl>(DC))
     return false;
   if (const ObjCInterfaceDecl *ID = getClassInterface())
-    return ID->isDesignatedInitializer(getSelector(), InitMethod);
+    return ID->isDesignatedInitializer(getSelector(), InitMethod, IsHidden);
   return false;
 }
 

     if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
       if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
         if (!ImplD->isInvalidDecl())
-          Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
+          Redecl = ImplD->getMethod(getSelector(), isInstanceMethod(),
+                                    AllDeclsVisible);
 
     } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
       if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
         if (!ImplD->isInvalidDecl())
-          Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
+          Redecl = ImplD->getMethod(getSelector(), isInstanceMethod(),
+                                    AllDeclsVisible);
 
     } else if (ObjCImplementationDecl *ImplD =
                  dyn_cast<ObjCImplementationDecl>(CtxD)) {
       if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
         if (!IFD->isInvalidDecl())
-          Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
+          Redecl = IFD->getMethod(getSelector(), isInstanceMethod(),
+                                  AllDeclsVisible);
 
     } else if (ObjCCategoryImplDecl *CImplD =
                  dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
       if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
         if (!CatD->isInvalidDecl())
-          Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
+          Redecl = CatD->getMethod(getSelector(), isInstanceMethod(),
+                                   AllDeclsVisible);
     }
   }
 

   if (!Redecl && isRedeclaration()) {
     // This is the last redeclaration, go back to the first method.
     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
-                                                    isInstanceMethod());
+                                                    isInstanceMethod(),
+                                                    AllDeclsVisible);
   }
 
   return Redecl ? Redecl : this;

 
   if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
-      if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
-                                              isInstanceMethod()))
+      if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(), isInstanceMethod(),
+                                              AllDeclsVisible))
         return MD;
 
   } else if (ObjCCategoryImplDecl *CImplD =
                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
-      if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
-                                               isInstanceMethod()))
+      if (ObjCMethodDecl *MD = CatD->getMethod(
+              getSelector(), isInstanceMethod(), AllDeclsVisible))
         return MD;
   }
 
   if (isRedeclaration()) {
     // It is possible that we have not done deserializing the ObjCMethod yet.
-    ObjCMethodDecl *MD =
-        cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
-                                                 isInstanceMethod());
+    ObjCMethodDecl *MD = cast<ObjCContainerDecl>(CtxD)->getMethod(
+        getSelector(), isInstanceMethod(), AllDeclsVisible);
     return MD ? MD : this;
   }
 

       if (ObjCMethodDecl *
             Overridden = Container->getMethod(Method->getSelector(),
                                               Method->isInstanceMethod(),
-                                              /*AllowHidden=*/true))
+                                              AllDeclsVisible))
         if (Method != Overridden) {
           // We found an override at this category; there is no need to look
           // into its protocols.

   if (const ObjCMethodDecl *
         Overridden = Container->getMethod(Method->getSelector(),
                                           Method->isInstanceMethod(),
-                                          /*AllowHidden=*/true))
+                                          AllDeclsVisible))
     if (Method != Overridden) {
       // We found an override at this level; there is no need to look
       // into other protocols or categories.

     // interface as starting point.
     if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
                                                     Method->isInstanceMethod(),
-                                                    /*AllowHidden=*/true))
+                                                    AllDeclsVisible))
       Method = IFaceMeth;
     CollectOverriddenMethods(ID, Method, overridden);
 

     // interface as starting point.
     if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
                                                      Method->isInstanceMethod(),
-                                                     /*AllowHidden=*/true))
+                                                     AllDeclsVisible))
       Method = IFaceMeth;
     CollectOverriddenMethods(ID, Method, overridden);
 

   const ObjCMethodDecl *Method = this;
 
   if (Method->isRedeclaration()) {
-    Method = cast<ObjCContainerDecl>(Method->getDeclContext())->
-                   getMethod(Method->getSelector(), Method->isInstanceMethod());
+    Method = cast<ObjCContainerDecl>(Method->getDeclContext())
+                 ->getMethod(Method->getSelector(), Method->isInstanceMethod(),
+                             AllDeclsVisible);
   }
 
   if (Method->isOverriding()) {

 }
 
 const ObjCPropertyDecl *
-ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
+ObjCMethodDecl::findPropertyDecl(IsHiddenFunction IsHidden,
+                                 bool CheckOverrides) const {
   Selector Sel = getSelector();
   unsigned NumArgs = Sel.getNumArgs();
   if (NumArgs > 1)

 
     // If we have a class, check its visible extensions.
     if (ClassDecl) {
-      for (const auto *Ext : ClassDecl->visible_extensions()) {
+      for (const auto *Ext : ClassDecl->visible_extensions(IsHidden)) {
         if (Ext == Container)
           continue;
 

   getOverriddenMethods(Overrides);
   for (OverridesTy::const_iterator I = Overrides.begin(), E = Overrides.end();
        I != E; ++I) {
-    if (const ObjCPropertyDecl *Prop = (*I)->findPropertyDecl(false))
+    if (const ObjCPropertyDecl *Prop = (*I)->findPropertyDecl(IsHidden, false))
       return Prop;
   }
 

 /// in 'CategoryId'. If category not found, return 0;
 ///
 ObjCCategoryDecl *
-ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
+ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId,
+                                           IsHiddenFunction IsHidden) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;

   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  for (auto *Cat : visible_categories())
+  for (auto *Cat : visible_categories(IsHidden))
     if (Cat->getIdentifier() == CategoryId)
       return Cat;
 

 }
 
 ObjCMethodDecl *
-ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
-  for (const auto *Cat : visible_categories()) {
+ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel,
+                                             IsHiddenFunction IsHidden) const {
+  for (const auto *Cat : visible_categories(IsHidden)) {
     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
-      if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
+      if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel, IsHidden))
         return MD;
   }
 

   return nullptr;
 }
 
-ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
-  for (const auto *Cat : visible_categories()) {
+ObjCMethodDecl *
+ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel,
+                                          IsHiddenFunction IsHidden) const {
+  for (const auto *Cat : visible_categories(IsHidden)) {
     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
-      if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
+      if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel, IsHidden))
         return MD;
   }
 

 /// has been implemented in IDecl class, its super class or categories (if
 /// lookupCategory is true).
 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
-                                    bool lookupCategory,
-                                    bool RHSIsQualifiedID) {
+                                                bool LookupInCategories,
+                                                IsHiddenFunction IsHidden,
+                                                bool RHSIsQualifiedID) {
   if (!hasDefinition())
     return false;
   

   }
 
   // 2nd, look up the category.
-  if (lookupCategory)
-    for (const auto *Cat : visible_categories()) {
+  if (LookupInCategories)
+    for (const auto *Cat : visible_categories(IsHidden)) {
       for (auto *PI : Cat->protocols())
         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
           return true;

 
   // 3rd, look up the super class(s)
   if (IDecl->getSuperClass())
-    return
-  IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
-                                                  RHSIsQualifiedID);
+    return IDecl->getSuperClass()->ClassImplementsProtocol(
+        lProto, LookupInCategories, IsHidden, RHSIsQualifiedID);
 
   return false;
 }

 
 // lookupMethod - Lookup a instance/class method in the protocol and protocols
 // it inherited.
-ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
-                                               bool isInstance) const {
+ObjCMethodDecl *
+ObjCProtocolDecl::lookupMethod(Selector Sel, bool isInstance,
+                               IsHiddenFunction IsHidden) const {
   ObjCMethodDecl *MethodDecl = nullptr;
 
   // If there is no definition or the definition is hidden, we don't find
   // anything.
   const ObjCProtocolDecl *Def = getDefinition();
-  if (!Def || Def->isHidden())
+  if (!Def || IsHidden(Def))
     return nullptr;
 
-  if ((MethodDecl = getMethod(Sel, isInstance)))
+  if ((MethodDecl = getMethod(Sel, isInstance, IsHidden)))
     return MethodDecl;
 
   for (const auto *I : protocols())
-    if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
+    if ((MethodDecl = I->lookupMethod(Sel, isInstance, IsHidden)))
       return MethodDecl;
   return nullptr;
 }

 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
   // The class interface might be NULL if we are working with invalid code.
   if (const ObjCInterfaceDecl *ID = getClassInterface())
-    return ID->FindCategoryDeclaration(getIdentifier());
+    return ID->FindCategoryDeclaration(getIdentifier(), AllDeclsVisible);
   return nullptr;
 }
 

 
   } else if (ObjCCategoryImplDecl *ImplD =
              dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
-    if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
+    if (ObjCCategoryDecl *CD =
+            IFace->FindCategoryDeclaration(getIdentifier(), AllDeclsVisible))
       Ctx.setObjCImplementation(CD, ImplD);
   }
 

lib/Analysis/BodyFarm.cpp

   // is guaranteed to find the shadowing property, if it exists, rather than
   // the shadowed property.
   auto *ShadowingProp = PrimaryInterface->FindPropertyVisibleInPrimaryClass(
-      Prop->getIdentifier(), Prop->getQueryKind());
+      Prop->getIdentifier(), Prop->getQueryKind(), AllDeclsVisible);
   if (ShadowingProp && ShadowingProp != Prop) {
     IVar = ShadowingProp->getPropertyIvarDecl();
   }

     return Val.getValue();
   Val = nullptr;
 
-  const ObjCPropertyDecl *Prop = D->findPropertyDecl();
+  const ObjCPropertyDecl *Prop = D->findPropertyDecl(AllDeclsVisible);
   if (!Prop)
     return nullptr;
 

lib/Analysis/CallGraph.cpp

       // Find the callee definition within the same translation unit.
       Decl *D = nullptr;
       if (ME->isInstanceMessage())
-        D = IDecl->lookupPrivateMethod(Sel);
+        D = IDecl->lookupPrivateMethod(Sel, AllDeclsVisible);
       else
-        D = IDecl->lookupPrivateClassMethod(Sel);
+        D = IDecl->lookupPrivateClassMethod(Sel, AllDeclsVisible);
       if (D) {
         addCalledDecl(D);
         NumObjCCallEdges++;

lib/CodeGen/CGObjCMac.cpp

 
 bool
 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
-  return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
+  return OD->getClassMethod(GetNullarySelector("load"), AllDeclsVisible) !=
+         nullptr;
 }
 
 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,

lib/CodeGen/CodeGenModule.cpp

       // we want, that just indicates if the decl came from a
       // property. What we want to know is if the method is defined in
       // this implementation.
-      if (!D->getInstanceMethod(PD->getGetterName()))
+      if (!D->getInstanceMethod(PD->getGetterName(), AllDeclsVisible))
         CodeGenFunction(*this).GenerateObjCGetter(
                                  const_cast<ObjCImplementationDecl *>(D), PID);
       if (!PD->isReadOnly() &&
-          !D->getInstanceMethod(PD->getSetterName()))
+          !D->getInstanceMethod(PD->getSetterName(), AllDeclsVisible))
         CodeGenFunction(*this).GenerateObjCSetter(
                                  const_cast<ObjCImplementationDecl *>(D), PID);
     }

lib/Edit/RewriteObjCFoundationAPI.cpp

     return false;
   IFace = maybeAdjustInterfaceForSubscriptingCheck(IFace, Rec, Ctx);
 
-  if (const ObjCMethodDecl *MD = IFace->lookupInstanceMethod(subscriptSel)) {
+  if (const ObjCMethodDecl *MD =
+          IFace->lookupInstanceMethod(subscriptSel, AllDeclsVisible)) {
     if (!MD->isUnavailable())
       return true;
   }

lib/Frontend/Rewrite/RewriteModernObjC.cpp

     bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
       IdentifierInfo* II = &Context->Idents.get("load");
       Selector LoadSel = Context->Selectors.getSelector(0, &II);
-      return OD->getClassMethod(LoadSel) != nullptr;
+      return OD->getClassMethod(LoadSel, AllDeclsVisible) != nullptr;
     }
 
     StringLiteral *getStringLiteral(StringRef Str) {

 static bool mustSynthesizeSetterGetterMethod(ObjCImplementationDecl *IMP,
                                              ObjCPropertyDecl *PD,
                                              bool getter) {
-  return getter ? !IMP->getInstanceMethod(PD->getGetterName())
-                : !IMP->getInstanceMethod(PD->getSetterName());
-  
+  return !IMP->getInstanceMethod(
+      getter ? PD->getGetterName() : PD->getSetterName(), AllDeclsVisible);
 }
 
 void RewriteModernObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,

lib/Index/IndexDecl.cpp

   /// user.
   static bool hasUserDefined(const ObjCMethodDecl *D,
                              const ObjCImplDecl *Container) {
-    const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(),
-                                                    D->isInstanceMethod());
+    const ObjCMethodDecl *MD = Container->getMethod(
+        D->getSelector(), D->isInstanceMethod(), AllDeclsVisible);
     return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition();
   }
 

lib/Sema/ScopeInfo.cpp

       Uses = WeakObjectUses.find(WeakObjectProfileTy(DRE));
   } else if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
     if (const ObjCMethodDecl *MD = MsgE->getMethodDecl()) {
-      if (const ObjCPropertyDecl *Prop = MD->findPropertyDecl()) {
+      if (const ObjCPropertyDecl *Prop =
+              MD->findPropertyDecl(AllDeclsVisible)) {
         Uses =
           WeakObjectUses.find(WeakObjectProfileTy(MsgE->getInstanceReceiver(),
                                                   Prop));

lib/Sema/SemaCodeComplete.cpp

   // parameter in a setter.
   if (!Block && ObjCMethodParam &&
       cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
-    if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
-                             ->findPropertyDecl(/*CheckOverrides=*/false))
+    if (const auto *PD =
+            cast<ObjCMethodDecl>(Param->getDeclContext())
+                ->findPropertyDecl(AllDeclsVisible, /*CheckOverrides=*/false))
       findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
                                    SuppressBlock);
   }

       const NamedDecl *ND = Declaration;
       if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
         if (M->isPropertyAccessor())
-          if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
+          if (const ObjCPropertyDecl *PDecl =
+                  M->findPropertyDecl(AllDeclsVisible))
             if (PDecl->getGetterName() == M->getSelector() &&
                 PDecl->getIdentifier() != M->getIdentifier()) {
               if (const RawComment *RC = 

     } 
     else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
       if (OMD->isPropertyAccessor())
-        if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
+        if (const ObjCPropertyDecl *PDecl =
+                OMD->findPropertyDecl(AllDeclsVisible))
           if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
             Result.addBriefComment(RC->getBriefText(Ctx));
   }

   ObjCMethodDecl *SuperMethod = nullptr;
   while ((Class = Class->getSuperClass()) && !SuperMethod) {
     // Check in the class
-    SuperMethod = Class->getMethod(CurMethod->getSelector(), 
-                                   CurMethod->isInstanceMethod());
+    SuperMethod = Class->getMethod(CurMethod->getSelector(),
+                                   CurMethod->isInstanceMethod(),
+                                   Sema::IsHiddenCallback(S));
 
     // Check in categories or class extensions.
     if (!SuperMethod) {
       for (const auto *Cat : Class->known_categories()) {
         if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
-                                               CurMethod->isInstanceMethod())))
+                                          CurMethod->isInstanceMethod(),
+                                          Sema::IsHiddenCallback(S))))
           break;
       }
     }

   NamedDecl *CurClass
     = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
   if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
-    for (const auto *Cat : Class->visible_categories())
+    for (const auto *Cat : Class->visible_categories(IsHiddenCallback(*this)))
       CategoryNames.insert(Cat->getIdentifier());
   }
 

   Results.EnterNewScope();
   bool IgnoreImplemented = true;
   while (Class) {
-    for (const auto *Cat : Class->visible_categories()) {
+    for (const auto *Cat : Class->visible_categories(IsHiddenCallback(*this))) {
       if ((!IgnoreImplemented || !Cat->getImplementation()) &&
           CategoryNames.insert(Cat->getIdentifier()).second)
         Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),

   QualType PropertyType = Context.getObjCIdType();
   if (Class) {
     if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
-            PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+            PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+            IsHiddenCallback(*this))) {
       PropertyType 
         = Property->getType().getNonReferenceType().getUnqualifiedType();
       

                                KnownMethods, InOriginalClass);
 
     // Add methods from any class extensions and categories.
-    for (auto *Cat : IFace->visible_categories()) {
+    for (auto *Cat : IFace->known_categories()) {
       FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
                                KnownMethods, false);      
     }

         IFace = Category->getClassInterface();
     
     if (IFace)
-      for (auto *Cat : IFace->visible_categories())
+      for (auto *Cat : IFace->visible_categories(IsHiddenCallback(*this)))
         Containers.push_back(Cat);
     
     for (unsigned I = 0, N = Containers.size(); I != N; ++I)

lib/Sema/SemaDecl.cpp

     }
     if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
       const ObjCMethodDecl *InitMethod = nullptr;
-      bool isDesignated =
-          MD->isDesignatedInitializerForTheInterface(&InitMethod);
+      bool isDesignated = MD->isDesignatedInitializerForTheInterface(
+          IsHiddenCallback(*this), &InitMethod);
       assert(isDesignated && InitMethod);
       (void)isDesignated;
 

lib/Sema/SemaDeclObjC.cpp

   // Warn on deprecated methods under -Wdeprecated-implementations,
   // and prepare for warning on missing super calls.
   if (ObjCInterfaceDecl *IC = MDecl->getClassInterface()) {
-    ObjCMethodDecl *IMD = 
-      IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod());
-    
+    ObjCMethodDecl *IMD =
+        IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod(),
+                         IsHiddenCallback(*this));
+
     if (IMD) {
       ObjCImplDecl *ImplDeclOfMethodDef = 
         dyn_cast<ObjCImplDecl>(MDecl->getDeclContext());

     }
 
     if (MDecl->getMethodFamily() == OMF_init) {
-      if (MDecl->isDesignatedInitializerForTheInterface()) {
+      if (MDecl->isDesignatedInitializerForTheInterface(
+              IsHiddenCallback(*this))) {
         getCurFunction()->ObjCIsDesignatedInit = true;
         getCurFunction()->ObjCWarnForNoDesignatedInitChain =
             IC->getSuperClass() != nullptr;

           getCurFunction()->ObjCShouldCallSuper = true;
         
       } else {
-        const ObjCMethodDecl *SuperMethod =
-          SuperClass->lookupMethod(MDecl->getSelector(),
-                                   MDecl->isInstanceMethod());
+        const ObjCMethodDecl *SuperMethod = SuperClass->lookupMethod(
+            MDecl->getSelector(), MDecl->isInstanceMethod(),
+            IsHiddenCallback(*this));
         getCurFunction()->ObjCShouldCallSuper = 
           (SuperMethod && SuperMethod->hasAttr<ObjCRequiresSuperAttr>());
       }

           !InsMap.count(method->getSelector()) &&
           (!Super || !Super->lookupMethod(method->getSelector(),
                                           true /* instance */,
+                                          Sema::IsHiddenCallback(S),
                                           false /* shallowCategory */,
                                           true /* followsSuper */,
                                           nullptr /* category */))) {

             if (ObjCMethodDecl *MethodInClass =
                   IDecl->lookupMethod(method->getSelector(),
                                       true /* instance */,
+                                      Sema::IsHiddenCallback(S),
                                       true /* shallowCategoryLookup */,
                                       false /* followSuper */))
               if (C || MethodInClass->isPropertyAccessor())

         !ClsMap.count(method->getSelector()) &&
         (!Super || !Super->lookupMethod(method->getSelector(),
                                         false /* class method */,
+                                        Sema::IsHiddenCallback(S),
                                         false /* shallowCategoryLookup */,
                                         true  /* followSuper */,
                                         nullptr /* category */))) {

       // See above comment for instance method lookups.
       if (C && IDecl->lookupMethod(method->getSelector(),
                                    false /* class */,
+                                   Sema::IsHiddenCallback(S),
                                    true /* shallowCategoryLookup */,
                                    false /* followSuper */))
         continue;

       continue;
     } else {
       ObjCMethodDecl *ImpMethodDecl =
-        IMPDecl->getInstanceMethod(I->getSelector());
-      assert(CDecl->getInstanceMethod(I->getSelector(), true/*AllowHidden*/) &&
+          IMPDecl->getInstanceMethod(I->getSelector(), IsHiddenCallback(*this));
+      assert(CDecl->getInstanceMethod(I->getSelector(), AllDeclsVisible) &&
              "Expected to find the method through lookup as well");
       // ImpMethodDecl may be null as in a @dynamic property.
       if (ImpMethodDecl) {

                             diag::warn_undef_method_impl);
     } else {
       ObjCMethodDecl *ImpMethodDecl =
-        IMPDecl->getClassMethod(I->getSelector());
-      assert(CDecl->getClassMethod(I->getSelector(), true/*AllowHidden*/) &&
+        IMPDecl->getClassMethod(I->getSelector(), IsHiddenCallback(*this));
+      assert(CDecl->getClassMethod(I->getSelector(), AllDeclsVisible) &&
              "Expected to find the method through lookup as well");
       // ImpMethodDecl may be null as in a @dynamic property.
       if (ImpMethodDecl) {

     // When checking for methods implemented in the category, skip over
     // those declared in category class's super class. This is because
     // the super class must implement the method.
-    if (SuperIDecl && SuperIDecl->lookupMethod(Sel, true))
+    if (SuperIDecl &&
+        SuperIDecl->lookupMethod(Sel, true, IsHiddenCallback(*this)))
       continue;
     InsMap.insert(Sel);
   }

   
   for (const auto *I : CatIMPDecl->class_methods()) {
     Selector Sel = I->getSelector();
-    if (SuperIDecl && SuperIDecl->lookupMethod(Sel, false))
+    if (SuperIDecl &&
+        SuperIDecl->lookupMethod(Sel, false, IsHiddenCallback(*this)))
       continue;
     ClsMap.insert(Sel);
   }

               continue;
 
           for (const auto *Ext : IDecl->visible_extensions()) {
-            if (ObjCMethodDecl *GetterMethod
-                  = Ext->getInstanceMethod(Property->getGetterName()))
+            if (ObjCMethodDecl *GetterMethod = Ext->getInstanceMethod(
+                    Property->getGetterName(), IsHiddenCallback(*this)))
               GetterMethod->setPropertyAccessor(true);
             if (!Property->isReadOnly())
-              if (ObjCMethodDecl *SetterMethod
-                    = Ext->getInstanceMethod(Property->getSetterName()))
+              if (ObjCMethodDecl *SetterMethod = Ext->getInstanceMethod(
+                      Property->getSetterName(), IsHiddenCallback(*this)))
                 SetterMethod->setPropertyAccessor(true);
           }
         }

     // Check for a method in this container which matches this selector.
     ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
                                                 Method->isInstanceMethod(),
-                                                /*AllowHidden=*/true);
+                                                AllDeclsVisible);
 
     // If we find one, record it and bail out.
     if (meth) {

   const ObjCMethodDecl *PrevMethod = nullptr;
   if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
     if (MethodType == tok::minus) {
-      PrevMethod = ImpDecl->getInstanceMethod(Sel);
+      PrevMethod = ImpDecl->getInstanceMethod(Sel, IsHiddenCallback(*this));
       ImpDecl->addInstanceMethod(ObjCMethod);
     } else {
-      PrevMethod = ImpDecl->getClassMethod(Sel);
+      PrevMethod = ImpDecl->getClassMethod(Sel, IsHiddenCallback(*this));
       ImpDecl->addClassMethod(ObjCMethod);
     }
 

     // @implementation.
     if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {
       if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
-                                          ObjCMethod->isInstanceMethod())) {
+                                          ObjCMethod->isInstanceMethod(),
+                                          IsHiddenCallback(*this))) {
         mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD);
 
         // Warn about defining -dealloc in a category.

 
 ObjCIvarDecl *
 Sema::GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
-                                     const ObjCPropertyDecl *&PDecl) const {
+                                     const ObjCPropertyDecl *&PDecl) {
   if (Method->isClassMethod())
     return nullptr;
   const ObjCInterfaceDecl *IDecl = Method->getClassInterface();

   if (!IDecl)
     return nullptr;
   Method = IDecl->lookupMethod(Method->getSelector(), /*isInstance=*/true,
+                               IsHiddenCallback(*this),
                                /*shallowCategoryLookup=*/false,
                                /*followSuper=*/false);
   if (!Method || !Method->isPropertyAccessor())

lib/Sema/SemaExpr.cpp

   }
 }
 
-static bool HasRedeclarationWithoutAvailabilityInCategory(const Decl *D) {
+static bool HasRedeclarationWithoutAvailabilityInCategory(Sema &S,
+                                                          const Decl *D) {
   const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
   if (!OMD)
     return false;

 
   for (const ObjCCategoryDecl *Cat : OID->visible_categories())
     if (ObjCMethodDecl *CatMeth =
-            Cat->getMethod(OMD->getSelector(), OMD->isInstanceMethod()))
+            Cat->getMethod(OMD->getSelector(), OMD->isInstanceMethod(),
+                           Sema::IsHiddenCallback(S)))
       if (!CatMeth->hasAttr<AvailabilityAttr>())
         return true;
   return false;

     // Objective-C method declarations in categories are not modelled as
     // redeclarations, so manually look for a redeclaration in a category
     // if necessary.
-    if (Warn && HasRedeclarationWithoutAvailabilityInCategory(D))
+    if (Warn && HasRedeclarationWithoutAvailabilityInCategory(*this, D))
       Warn = false;
     // In general, D will point to the most recent redeclaration. However,
     // for `@class A;` decls, this isn't true -- manually go through the

lib/Sema/SemaExprMember.cpp

   return VT; // should never get here (a typedef type should always be found).
 }
 
-static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
-                                                IdentifierInfo *Member,
-                                                const Selector &Sel,
-                                                ASTContext &Context) {
+static Decl *
+FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl *PDecl,
+                                         IdentifierInfo *Member,
+                                         const Selector &Sel, Sema &S) {
   if (Member)
     if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(
-            Member, ObjCPropertyQueryKind::OBJC_PR_query_instance))
+            Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+            Sema::IsHiddenCallback(S)))
       return PD;
-  if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
+  if (ObjCMethodDecl *OMD =
+          PDecl->getInstanceMethod(Sel, Sema::IsHiddenCallback(S)))
     return OMD;
 
   for (const auto *I : PDecl->protocols()) {
-    if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel,
-                                                           Context))
+    if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, S))
       return D;
   }
   return nullptr;

 static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy,
                                       IdentifierInfo *Member,
                                       const Selector &Sel,
-                                      ASTContext &Context) {
+                                      Sema &S) {
   // Check protocols on qualified interfaces.
   Decl *GDecl = nullptr;
   for (const auto *I : QIdTy->quals()) {
     if (Member)
       if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(
-              Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+              Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+              Sema::IsHiddenCallback(S))) {
         GDecl = PD;
         break;
       }
     // Also must look for a getter or setter name which uses property syntax.
-    if (ObjCMethodDecl *OMD = I->getInstanceMethod(Sel)) {
+    if (ObjCMethodDecl *OMD =
+            I->getInstanceMethod(Sel, Sema::IsHiddenCallback(S))) {
       GDecl = OMD;
       break;
     }

   if (!GDecl) {
     for (const auto *I : QIdTy->quals()) {
       // Search in the protocol-qualifier list of current protocol.
-      GDecl = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, Context);
+      GDecl = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, S);
       if (GDecl)
         return GDecl;
     }

       return ExprError();
 
     ObjCInterfaceDecl *ClassDeclared = nullptr;
-    ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
+    ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared,
+                                                     Sema::IsHiddenCallback(S));
 
     if (!IV) {
       // Attempt to correct for typos in ivar names.

       } else {
         if (IsArrow &&
             IDecl->FindPropertyDeclaration(
-                Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+                Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+                Sema::IsHiddenCallback(S))) {
           S.Diag(MemberLoc, diag::err_property_found_suggest)
               << Member << BaseExpr.get()->getType()
               << FixItHint::CreateReplacement(OpLoc, ".");

       // Check protocols on qualified interfaces.
       Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
       if (Decl *PMDecl =
-              FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
+              FindGetterSetterNameDecl(OPT, Member, Sel, S)) {
         if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
           // Check the use of this declaration
           if (S.DiagnoseUseOfDecl(PD, MemberLoc))

           ObjCMethodDecl *SMD = nullptr;
           if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
                                                      /*Property id*/ nullptr,
-                                                     SetterSel, S.Context))
+                                                     SetterSel, S))
             SMD = dyn_cast<ObjCMethodDecl>(SDecl);
 
           return new (S.Context)

       Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
       ObjCInterfaceDecl *IFace = MD->getClassInterface();
       ObjCMethodDecl *Getter;
-      if ((Getter = IFace->lookupClassMethod(Sel))) {
+      if ((Getter = IFace->lookupClassMethod(Sel, Sema::IsHiddenCallback(S)))) {
         // Check the use of this method.
         if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
           return ExprError();
       } else
-        Getter = IFace->lookupPrivateMethod(Sel, false);
+        Getter =
+            IFace->lookupPrivateClassMethod(Sel, Sema::IsHiddenCallback(S));
       // If we found a getter then this may be a valid dot-reference, we
       // will look for the matching setter, in case it is needed.
       Selector SetterSel =

         SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
                                                S.PP.getSelectorTable(),
                                                Member);
-      ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
+      ObjCMethodDecl *Setter =
+          IFace->lookupClassMethod(SetterSel, Sema::IsHiddenCallback(S));
       if (!Setter) {
         // If this reference is in an @implementation, also check for 'private'
         // methods.
-        Setter = IFace->lookupPrivateMethod(SetterSel, false);
+        Setter = IFace->lookupPrivateClassMethod(SetterSel,
+                                                 Sema::IsHiddenCallback(S));
       }
 
       if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))

lib/Sema/SemaExprObjC.cpp

   }
   
   // Look for the appropriate method within NSNumber.
-  ObjCMethodDecl *Method = S.NSNumberDecl->lookupClassMethod(Sel);
+  ObjCMethodDecl *Method =
+      S.NSNumberDecl->lookupClassMethod(Sel, Sema::IsHiddenCallback(S));
   if (!Method && S.getLangOpts().DebuggerObjCLiteral) {
     // create a stub definition this NSNumber factory method.
     TypeSourceInfo *ReturnTInfo = nullptr;

         Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II);
 
         // Look for the appropriate method within NSString.
-        BoxingMethod = NSStringDecl->lookupClassMethod(stringWithUTF8String);
+        BoxingMethod = NSStringDecl->lookupClassMethod(
+            stringWithUTF8String, Sema::IsHiddenCallback(*this));
         if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) {
           // Debugger needs to work even if NSString hasn't been defined.
           TypeSourceInfo *ReturnTInfo = nullptr;

       Selector ValueWithBytesObjCType = Context.Selectors.getSelector(2, II);
       
       // Look for the appropriate method within NSValue.
-      BoxingMethod = NSValueDecl->lookupClassMethod(ValueWithBytesObjCType);
+      BoxingMethod = NSValueDecl->lookupClassMethod(ValueWithBytesObjCType,
+                                                    IsHiddenCallback(*this));
       if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) {
         // Debugger needs to work even if NSValue hasn't been defined.
         TypeSourceInfo *ReturnTInfo = nullptr;

   if (!ArrayWithObjectsMethod) {
     Selector
       Sel = NSAPIObj->getNSArraySelector(NSAPI::NSArr_arrayWithObjectsCount);
-    ObjCMethodDecl *Method = NSArrayDecl->lookupClassMethod(Sel);
+    ObjCMethodDecl *Method =
+        NSArrayDecl->lookupClassMethod(Sel, IsHiddenCallback(*this));
     if (!Method && getLangOpts().DebuggerObjCLiteral) {
       TypeSourceInfo *ReturnTInfo = nullptr;
       Method = ObjCMethodDecl::Create(

   if (!DictionaryWithObjectsMethod) {
     Selector Sel = NSAPIObj->getNSDictionarySelector(
                                NSAPI::NSDict_dictionaryWithObjectsForKeysCount);
-    ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel);
+    ObjCMethodDecl *Method =
+        NSDictionaryDecl->lookupClassMethod(Sel, IsHiddenCallback(*this));
     if (!Method && getLangOpts().DebuggerObjCLiteral) {
       Method = ObjCMethodDecl::Create(Context,  
                            SourceLocation(), SourceLocation(), Sel,

 
 /// Look for an ObjC method whose result type exactly matches the given type.
 static const ObjCMethodDecl *
-findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD,
+findExplicitInstancetypeDeclarer(Sema &S, const ObjCMethodDecl *MD,
                                  QualType instancetype) {
   if (MD->getReturnType() == instancetype)
     return MD;

       iface = impl->getClassInterface();
     }
 
-    const ObjCMethodDecl *ifaceMD = 
-      iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
-    if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
+    const ObjCMethodDecl *ifaceMD = iface->getMethod(
+        MD->getSelector(), MD->isInstanceMethod(), Sema::IsHiddenCallback(S));
+    if (ifaceMD)
+      return findExplicitInstancetypeDeclarer(S, ifaceMD, instancetype);
   }
 
   SmallVector<const ObjCMethodDecl *, 4> overrides;

   MD->getOverriddenMethods(overrides);
   for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
     if (const ObjCMethodDecl *result =
-          findExplicitInstancetypeDeclarer(overrides[i], instancetype))
+            findExplicitInstancetypeDeclarer(S, overrides[i], instancetype))
       return result;
   }
 

 
   // Look for a method overridden by this method which explicitly uses
   // 'instancetype'.
-  if (const ObjCMethodDecl *overridden =
-        findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) {
+  if (const ObjCMethodDecl *overridden = findExplicitInstancetypeDeclarer(
+          *this, MD, Context.getObjCInstanceType())) {
     SourceRange range = overridden->getReturnTypeSourceRange();
     SourceLocation loc = range.getBegin();
     if (loc.isInvalid())

             ReceiverType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()) {
           Diag(ThisClass->getLocation(), diag::note_receiver_class_declared);
           if (!RecRange.isInvalid())
-            if (ThisClass->lookupClassMethod(Sel))
+            if (ThisClass->lookupClassMethod(Sel, IsHiddenCallback(*this)))
               Diag(RecRange.getBegin(),diag::note_receiver_expr_here)
                 << FixItHint::CreateReplacement(RecRange,
                                                 ThisClass->getNameAsString());

   const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
   if (ObjCInterfaceDecl *iface = objType->getInterface()) {
     // Look it up in the main interface (and categories, etc.)
-    if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
+    if (ObjCMethodDecl *method =
+            iface->lookupMethod(sel, isInstance, IsHiddenCallback(*this)))
       return method;
 
     // Okay, look for "private" methods declared in any
     // @implementations we've seen.
-    if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
+    if (ObjCMethodDecl *method = iface->lookupPrivateMethod(
+            sel, isInstance, IsHiddenCallback(*this)))
       return method;
   }
 
   // Check qualifiers.
   for (const auto *I : objType->quals())
-    if (ObjCMethodDecl *method = I->lookupMethod(sel, isInstance))
+    if (ObjCMethodDecl *method =
+            I->lookupMethod(sel, isInstance, IsHiddenCallback(*this)))
       return method;
 
   return nullptr;

 {
   ObjCMethodDecl *MD = nullptr;
   for (const auto *PROTO : OPT->quals()) {
-    if ((MD = PROTO->lookupMethod(Sel, Instance))) {
+    if ((MD = PROTO->lookupMethod(Sel, Instance, IsHiddenCallback(*this)))) {
       return MD;
     }
   }

                           diag::err_property_not_found_forward_class,
                           MemberName, BaseRange))
     return ExprError();
- 
   if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(
-          Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+          Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+          IsHiddenCallback(*this))) {
     // Check whether we can reference this property.
     if (DiagnoseUseOfDecl(PD, MemberLoc))
       return ExprError();

   // Check protocols on qualified interfaces.
   for (const auto *I : OPT->quals())
     if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(
-            Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+            Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+            IsHiddenCallback(*this))) {
       // Check whether we can reference this property.
       if (DiagnoseUseOfDecl(PD, MemberLoc))
         return ExprError();

   // shared with the code in ActOnInstanceMessage.
 
   Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
-  ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
-  
+  ObjCMethodDecl *Getter =
+      IFace->lookupInstanceMethod(Sel, IsHiddenCallback(*this));
+
   // May be found in property's qualified list.
   if (!Getter)
     Getter = LookupMethodInQualifiedType(Sel, OPT, true);

 
   // If this reference is in an @implementation, check for 'private' methods.
   if (!Getter)
-    Getter = IFace->lookupPrivateMethod(Sel);
+    Getter = IFace->lookupPrivateMethod(Sel, IsHiddenCallback(*this));
 
   if (Getter) {
     // Check if we can reference this property.

   Selector SetterSel =
     SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
                                            PP.getSelectorTable(), Member);
-  ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
-      
+  ObjCMethodDecl *Setter =
+      IFace->lookupInstanceMethod(SetterSel, IsHiddenCallback(*this));
+
   // May be found in property's qualified list.
   if (!Setter)
     Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);

   if (!Setter) {
     // If this reference is in an @implementation, also check for 'private'
     // methods.
-    Setter = IFace->lookupPrivateMethod(SetterSel);
+    Setter = IFace->lookupPrivateMethod(SetterSel, IsHiddenCallback(*this));
   }
     
   if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))

   // name 'x'.
   if (Setter && Setter->isImplicit() && Setter->isPropertyAccessor() &&
       !IFace->FindPropertyDeclaration(
-          Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
-      if (const ObjCPropertyDecl *PDecl = Setter->findPropertyDecl()) {
-        // Do not warn if user is using property-dot syntax to make call to
-        // user named setter.
-        if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter))
-          Diag(MemberLoc,
-               diag::warn_property_access_suggest)
-          << MemberName << QualType(OPT, 0) << PDecl->getName()
-          << FixItHint::CreateReplacement(MemberLoc, PDecl->getName());
-      }
+          Member, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+          IsHiddenCallback(*this))) {
+    if (const ObjCPropertyDecl *PDecl =
+            Setter->findPropertyDecl(IsHiddenCallback(*this))) {
+      // Do not warn if user is using property-dot syntax to make call to
+      // user named setter.
+      if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter))
+        Diag(MemberLoc, diag::warn_property_access_suggest)
+            << MemberName << QualType(OPT, 0) << PDecl->getName()
+            << FixItHint::CreateReplacement(MemberLoc, PDecl->getName());
+    }
   }
 
   if (Getter || Setter) {

     }
   }
   ObjCInterfaceDecl *ClassDeclared;
-  if (ObjCIvarDecl *Ivar = 
-      IFace->lookupInstanceVariable(Member, ClassDeclared)) {
+  if (ObjCIvarDecl *Ivar = IFace->lookupInstanceVariable(
+          Member, IsHiddenCallback(*this), ClassDeclared)) {
     QualType T = Ivar->getType();
     if (const ObjCObjectPointerType * OBJPT = 
         T->getAsObjCInterfacePointerType()) {

   Selector GetterSel;
   Selector SetterSel;
   if (auto PD = IFace->FindPropertyDeclaration(
-          &propertyName, ObjCPropertyQueryKind::OBJC_PR_query_class)) {
+          &propertyName, ObjCPropertyQueryKind::OBJC_PR_query_class,
+          IsHiddenCallback(*this))) {
     GetterSel = PD->getGetterName();
     SetterSel = PD->getSetterName();
   } else {

   }
 
   // Search for a declared property first.
-  ObjCMethodDecl *Getter = IFace->lookupClassMethod(GetterSel);
+  ObjCMethodDecl *Getter =
+      IFace->lookupClassMethod(GetterSel, IsHiddenCallback(*this));
 
   // If this reference is in an @implementation, check for 'private' methods.
   if (!Getter)
-    Getter = IFace->lookupPrivateClassMethod(GetterSel);
+    Getter =
+        IFace->lookupPrivateClassMethod(GetterSel, IsHiddenCallback(*this));
 
   if (Getter) {
     // FIXME: refactor/share with ActOnMemberReference().

   }
 
   // Look for the matching setter, in case it is needed.
-  ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
+  ObjCMethodDecl *Setter =
+      IFace->lookupClassMethod(SetterSel, IsHiddenCallback(*this));
   if (!Setter) {
     // If this reference is in an @implementation, also check for 'private'
     // methods.
-    Setter = IFace->lookupPrivateClassMethod(SetterSel);
+    Setter =
+        IFace->lookupPrivateClassMethod(SetterSel, IsHiddenCallback(*this));
   }
   // Look through local category implementations associated with the class.
   if (!Setter)
-    Setter = IFace->getCategoryClassMethod(SetterSel);
+    Setter = IFace->getCategoryClassMethod(SetterSel, IsHiddenCallback(*this));
 
   if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
     return ExprError();

     const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>();
     if (!OPT || !OPT->getInterfaceDecl())
       return;
-    ImpliedMethod =
-        OPT->getInterfaceDecl()->lookupInstanceMethod(SE->getSelector());
+    ImpliedMethod = OPT->getInterfaceDecl()->lookupInstanceMethod(
+        SE->getSelector(), Sema::IsHiddenCallback(S));
     if (!ImpliedMethod)
-      ImpliedMethod =
-          OPT->getInterfaceDecl()->lookupPrivateMethod(SE->getSelector());
+      ImpliedMethod = OPT->getInterfaceDecl()->lookupPrivateMethod(
+          SE->getSelector(), Sema::IsHiddenCallback(S));
   } else {
     const auto *IT = ReceiverType->getAs<ObjCInterfaceType>();
     if (!IT)
       return;
-    ImpliedMethod = IT->getDecl()->lookupClassMethod(SE->getSelector());
+    ImpliedMethod = IT->getDecl()->lookupClassMethod(SE->getSelector(),
+                                                     Sema::IsHiddenCallback(S));
     if (!ImpliedMethod)
-      ImpliedMethod =
-          IT->getDecl()->lookupPrivateClassMethod(SE->getSelector());
+      ImpliedMethod = IT->getDecl()->lookupPrivateClassMethod(
+          SE->getSelector(), Sema::IsHiddenCallback(S));
   }
   if (!ImpliedMethod)
     return;

           << Method->getDeclName();
     }
     if (!Method)
-      Method = Class->lookupClassMethod(Sel);
+      Method = Class->lookupClassMethod(Sel, IsHiddenCallback(*this));
 
     // If we have an implementation in scope, check "private" methods.
     if (!Method)
-      Method = Class->lookupPrivateClassMethod(Sel);
+      Method = Class->lookupPrivateClassMethod(Sel, IsHiddenCallback(*this));
 
     if (Method && DiagnoseUseOfDecl(Method, SelLoc))
       return ExprError();

         if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
           if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
             // First check the public methods in the class interface.
-            Method = ClassDecl->lookupClassMethod(Sel);
+            Method =
+                ClassDecl->lookupClassMethod(Sel, IsHiddenCallback(*this));
 
             if (!Method)
-              Method = ClassDecl->lookupPrivateClassMethod(Sel);
+              Method = ClassDecl->lookupPrivateClassMethod(
+                  Sel, IsHiddenCallback(*this));
           }
           if (Method && DiagnoseUseOfDecl(Method, SelLoc))
             return ExprError();

                         : SuperLoc, diag::note_receiver_is_id);
           Method = nullptr;
         } else {
-          Method = ClassDecl->lookupInstanceMethod(Sel);
+          Method =
+              ClassDecl->lookupInstanceMethod(Sel, IsHiddenCallback(*this));
         }
 
         if (!Method)

         
         if (!Method) {
           // If we have implementations in scope, check "private" methods.
-          Method = ClassDecl->lookupPrivateMethod(Sel);
+          Method = ClassDecl->lookupPrivateMethod(Sel, IsHiddenCallback(*this));
 
           if (!Method && getLangOpts().ObjCAutoRefCount) {
             Diag(SelLoc, diag::err_arc_may_not_respond)

         if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) {
           // Either we know this is a designated initializer or we
           // conservatively assume it because we don't know for sure.
-          if (!ID->declaresOrInheritsDesignatedInitializers() ||
-              ID->isDesignatedInitializer(Sel)) {
+          if (!ID->declaresOrInheritsDesignatedInitializers(
+                  IsHiddenCallback(*this)) ||
+              ID->isDesignatedInitializer(Sel, IsHiddenCallback(*this))) {
             isDesignatedInitChain = true;
             DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false;
           }

     if (!isDesignatedInitChain) {
       const ObjCMethodDecl *InitMethod = nullptr;
       bool isDesignated =
-        getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod);
+          getCurMethodDecl()->isDesignatedInitializerForTheInterface(
+              IsHiddenCallback(*this), &InitMethod);
       assert(isDesignated && InitMethod);
       (void)isDesignated;
       Diag(SelLoc, SuperLoc.isValid() ?

 
   if (getLangOpts().ObjCWeak) {
     if (!isImplicit && Method) {
-      if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
+      if (const ObjCPropertyDecl *Prop =
+              Method->findPropertyDecl(IsHiddenCallback(*this))) {
         bool IsWeak =
           Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
         if (!IsWeak && Sel.isUnarySelector())

               return false;
             } else if (castType->isObjCIdType() ||
                        (S.Context.ObjCObjectAdoptsQTypeProtocols(
-                          castType, ExprClass)))
+                          castType, ExprClass, Sema::IsHiddenCallback(S))))
               // ok to cast to 'id'.
               // casting to id<p-list> is ok if bridge type adopts all of
               // p-list protocols.

               return false;
             } else if (castExpr->getType()->isObjCIdType() ||
                        (S.Context.QIdProtocolsAdoptObjCObjectProtocols(
-                          castExpr->getType(), CastClass)))
+                           castExpr->getType(), CastClass,
+                           Sema::IsHiddenCallback(S))))
               // ok to cast an 'id' expression to a CFtype.
               // ok to cast an 'id<plist>' expression to CFtype provided plist
               // adopts all of CFtype's ObjetiveC's class plist.

   // Check for an existing class method with the given selector name.
   if (CfToNs && CMId) {
     Selector Sel = Context.Selectors.getUnarySelector(CMId);
-    ClassMethod = RelatedClass->lookupMethod(Sel, false);
+    ClassMethod =
+        RelatedClass->lookupMethod(Sel, false, IsHiddenCallback(*this));
     if (!ClassMethod) {
       if (Diagnose) {
         Diag(Loc, diag::err_objc_bridged_related_known_method)

   // Check for an existing instance method with the given selector name.
   if (!CfToNs && IMId) {
     Selector Sel = Context.Selectors.getNullarySelector(IMId);
-    InstanceMethod = RelatedClass->lookupMethod(Sel, true);
+    InstanceMethod =
+        RelatedClass->lookupMethod(Sel, true, IsHiddenCallback(*this));
     if (!InstanceMethod) {
       if (Diagnose) {
         Diag(Loc, diag::err_objc_bridged_related_known_method)

             getLocForEndOfToken(SrcExpr->getLocEnd());
         if (InstanceMethod->isPropertyAccessor())
           if (const ObjCPropertyDecl *PDecl =
-                  InstanceMethod->findPropertyDecl()) {
+                  InstanceMethod->findPropertyDecl(IsHiddenCallback(*this))) {
             // fixit: ObjectExpr.propertyname when it is  aproperty accessor.
             ExpressionString = ".";
             ExpressionString += PDecl->getNameAsString();

lib/Sema/SemaLookup.cpp

               if (ObjCInterfaceDecl *Class = Method->getClassInterface()) {
                 ObjCInterfaceDecl *ClassDeclared;
                 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
-                                                 Name.getAsIdentifierInfo(),
-                                                             ClassDeclared)) {
+                        Name.getAsIdentifierInfo(), ClassDeclared)) {
                   if (NamedDecl *ND = R.getAcceptableDecl(Ivar)) {
                     R.addDecl(ND);
                     R.resolveKind();

   // Traverse the contexts of Objective-C classes.
   if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Ctx)) {
     // Traverse categories.
-    for (auto *Cat : IFace->visible_categories()) {
+    for (auto *Cat :
+         IFace->visible_categories(Sema::IsHiddenCallback(Result.getSema()))) {
       ShadowContextRAII Shadow(Visited);
       LookupVisibleDecls(Cat, Result, QualifiedNameLookup, false,
                          Consumer, Visited);

   if (MemberContext) {
     if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(MemberContext)) {
       if (isObjCIvarLookup) {
-        if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(Name)) {
+        if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
+                Name, Sema::IsHiddenCallback(SemaRef))) {
           Res.addDecl(Ivar);
           Res.resolveKind();
           return;

       }
 
       if (ObjCPropertyDecl *Prop = Class->FindPropertyDeclaration(
-              Name, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
+              Name, ObjCPropertyQueryKind::OBJC_PR_query_instance,
+              Sema::IsHiddenCallback(SemaRef))) {
         Res.addDecl(Prop);
         Res.resolveKind();
         return;

         (Res.empty() ||
          (Res.isSingleResult() &&
           Res.getFoundDecl()->isDefinedOutsideFunctionOrMethod()))) {
-       if (ObjCIvarDecl *IV
-             = Method->getClassInterface()->lookupInstanceVariable(Name)) {
-         Res.addDecl(IV);
-         Res.resolveKind();
-       }
+      if (ObjCIvarDecl *IV =
+              Method->getClassInterface()->lookupInstanceVariable(
+                  Name, Sema::IsHiddenCallback(SemaRef))) {
+        Res.addDecl(IV);
+        Res.resolveKind();
       }
+    }
   }
 }
 

lib/Sema/SemaObjCProperty.cpp

   // Find the property in the extended class's primary class or
   // extensions.
   ObjCPropertyDecl *PIDecl = CCPrimary->FindPropertyVisibleInPrimaryClass(
-      PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty));
+      PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty),
+      IsHiddenCallback(*this));
 
   // If we found a property in an extension, complain. 
   if (PIDecl && isa<ObjCCategoryDecl>(PIDecl->getDeclContext())) {

       if (IDecl)
         if (ObjCProtocolDecl* PNSCopying =
             LookupProtocol(&Context.Idents.get("NSCopying"), AtLoc))
-          if (IDecl->ClassImplementsProtocol(PNSCopying, true))
+          if (IDecl->ClassImplementsProtocol(PNSCopying, true,
+                                             IsHiddenCallback(*this)))
             Diag(AtLoc, diag::warn_implements_nscopying) << PropertyId;
     }
   }

                          (Attributes & ObjCDeclSpec::DQ_PR_class);
   // Class property and instance property can have the same name.
   if (ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(
-          DC, PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty))) {
+          DC, PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty),
+          IsHiddenCallback(*this))) {
     Diag(PDecl->getLocation(), diag::err_duplicate_property);
     Diag(prevDecl->getLocation(), diag::note_property_declare);
     PDecl->setInvalidDecl();

 }
 
 /// Determine whether any storage attributes were written on the property.
-static bool hasWrittenStorageAttribute(ObjCPropertyDecl *Prop,
+static bool hasWrittenStorageAttribute(Sema &S, ObjCPropertyDecl *Prop,
                                        ObjCPropertyQueryKind QueryKind) {
   if (Prop->getPropertyAttributesAsWritten() & OwnershipMask) return true;
 

   // Look through all of the protocols.
   for (const auto *Proto : OrigClass->all_referenced_protocols()) {
     if (ObjCPropertyDecl *OrigProp = Proto->FindPropertyDeclaration(
-            Prop->getIdentifier(), QueryKind))
+            Prop->getIdentifier(), QueryKind, Sema::IsHiddenCallback(S)))
       return OrigProp->getPropertyAttributesAsWritten() & OwnershipMask;
   }
 

            "ActOnPropertyImplDecl - @implementation without @interface");
 
     // Look for this property declaration in the @implementation's @interface
-    property = IDecl->FindPropertyDeclaration(PropertyId, QueryKind);
+    property = IDecl->FindPropertyDeclaration(PropertyId, QueryKind,
+                                              IsHiddenCallback(*this));
     if (!property) {
       Diag(PropertyLoc, diag::err_bad_property_decl) << IDecl->getDeclName();
       return nullptr;

       Diag(AtLoc, diag::err_missing_property_interface);
       return nullptr;
     }
-    ObjCCategoryDecl *Category =
-    IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
+    ObjCCategoryDecl *Category = IDecl->FindCategoryDeclaration(
+        CatImplClass->getIdentifier(), IsHiddenCallback(*this));
 
     // If category for this implementation not found, it is an error which
     // has already been reported eralier.

     if (!Category)
       return nullptr;
     // Look for this property declaration in @implementation's category
-    property = Category->FindPropertyDeclaration(PropertyId, QueryKind);
+    property = Category->FindPropertyDeclaration(PropertyId, QueryKind,
+                                                 IsHiddenCallback(*this));
     if (!property) {
       Diag(PropertyLoc, diag::err_bad_category_property_decl)
       << Category->getDeclName();

       PropertyIvar = PropertyId;
     // Check that this is a previously declared 'ivar' in 'IDecl' interface
     ObjCInterfaceDecl *ClassDeclared;
-    Ivar = IDecl->lookupInstanceVariable(PropertyIvar, ClassDeclared);
+    Ivar = IDecl->lookupInstanceVariable(PropertyIvar, IsHiddenCallback(*this),
+                                         ClassDeclared);
     QualType PropType = property->getType();
     QualType PropertyIvarType = PropType.getNonReferenceType();
 

 
         // It's an error if we have to do this and the user didn't
         // explicitly write an ownership attribute on the property.
-        if (!hasWrittenStorageAttribute(property, QueryKind) &&
+        if (!hasWrittenStorageAttribute(*this, property, QueryKind) &&
             !(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
           Diag(PropertyDiagLoc,
                diag::err_arc_objc_property_default_assign_on_object);

     if (!Context.hasSameType(PropertyIvarType, IvarType)) {
       if (isa<ObjCObjectPointerType>(PropertyIvarType) 
           && isa<ObjCObjectPointerType>(IvarType))
-        compat =
-          Context.canAssignObjCInterfaces(
-                                  PropertyIvarType->getAs<ObjCObjectPointerType>(),
-                                  IvarType->getAs<ObjCObjectPointerType>());
+        compat = Context.canAssignObjCInterfaces(
+            PropertyIvarType->getAs<ObjCObjectPointerType>(),
+            IvarType->getAs<ObjCObjectPointerType>(), IsHiddenCallback(*this));
       else {
         compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType,
                                              IvarType)

     if ((propertyObjCPtr =
              PropertyRValueType->getAs<ObjCObjectPointerType>()) &&
         (getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>()))
-      compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr);
+      compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr,
+                                               IsHiddenCallback(*this));
     else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType)
               != Compatible) {
           Diag(Loc, diag::err_property_accessor_type)

 /// CollectImmediateProperties - This routine collects all properties in
 /// the class and its conforming protocols; but not those in its super class.
 static void
-CollectImmediateProperties(ObjCContainerDecl *CDecl,
+CollectImmediateProperties(Sema &S, ObjCContainerDecl *CDecl,
                            ObjCContainerDecl::PropertyMap &PropMap,
                            ObjCContainerDecl::PropertyMap &SuperPropMap,
                            bool CollectClassPropsOnly = false,

     }
 
     // Collect the properties from visible extensions.
-    for (auto *Ext : IDecl->visible_extensions())
-      CollectImmediateProperties(Ext, PropMap, SuperPropMap,
+    for (auto *Ext : IDecl->visible_extensions(Sema::IsHiddenCallback(S)))
+      CollectImmediateProperties(S, Ext, PropMap, SuperPropMap,
                                  CollectClassPropsOnly, IncludeProtocols);
 
     if (IncludeProtocols) {
       // Scan through class's protocols.
       for (auto *PI : IDecl->all_referenced_protocols())
-        CollectImmediateProperties(PI, PropMap, SuperPropMap,
+        CollectImmediateProperties(S, PI, PropMap, SuperPropMap,
                                    CollectClassPropsOnly);
     }
   }

     if (IncludeProtocols) {
       // Scan through class's protocols.
       for (auto *PI : CATDecl->protocols())
-        CollectImmediateProperties(PI, PropMap, SuperPropMap,
+        CollectImmediateProperties(S, PI, PropMap, SuperPropMap,
                                    CollectClassPropsOnly);
     }
   }

     }
     // Scan through protocol's protocols.
     for (auto *PI : PDecl->protocols())
-      CollectImmediateProperties(PI, PropMap, SuperPropMap,
+      CollectImmediateProperties(S, PI, PropMap, SuperPropMap,
                                  CollectClassPropsOnly);
   }
 }

                                      ObjCMethodDecl *Method, ObjCIvarDecl *IV) {
   if (!IV->getSynthesize())
     return false;
-  ObjCMethodDecl *IMD = IFace->lookupMethod(Method->getSelector(),
-                                            Method->isInstanceMethod());
+  ObjCMethodDecl *IMD =
+      IFace->lookupMethod(Method->getSelector(), Method->isInstanceMethod(),
+                          IsHiddenCallback(*this));
   if (!IMD || !IMD->isPropertyAccessor())
     return false;
   

   return false;
 }
 
-static bool SuperClassImplementsProperty(ObjCInterfaceDecl *IDecl,
+static bool SuperClassImplementsProperty(Sema &S, ObjCInterfaceDecl *IDecl,
                                          ObjCPropertyDecl *Prop) {
   bool SuperClassImplementsGetter = false;
   bool SuperClassImplementsSetter = false;

 
   while (IDecl->getSuperClass()) {
     ObjCInterfaceDecl *SDecl = IDecl->getSuperClass();
-    if (!SuperClassImplementsGetter && SDecl->getInstanceMethod(Prop->getGetterName()))
+    if (!SuperClassImplementsGetter &&
+        SDecl->getInstanceMethod(Prop->getGetterName(),
+                                 Sema::IsHiddenCallback(S)))
       SuperClassImplementsGetter = true;
 
-    if (!SuperClassImplementsSetter && SDecl->getInstanceMethod(Prop->getSetterName()))
+    if (!SuperClassImplementsSetter &&
+        SDecl->getInstanceMethod(Prop->getSetterName(),
+                                 Sema::IsHiddenCallback(S)))
       SuperClassImplementsSetter = true;
     if (SuperClassImplementsGetter && SuperClassImplementsSetter)
       return true;

     if (IMPDecl->FindPropertyImplDecl(
             Prop->getIdentifier(), Prop->getQueryKind()))
       continue;
-    if (IMPDecl->getInstanceMethod(Prop->getGetterName())) {
+    if (IMPDecl->getInstanceMethod(Prop->getGetterName(),
+                                   IsHiddenCallback(*this))) {
       if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
         continue;
-      if (IMPDecl->getInstanceMethod(Prop->getSetterName()))
+      if (IMPDecl->getInstanceMethod(Prop->getSetterName(),
+                                     IsHiddenCallback(*this)))
         continue;
     }
     if (ObjCPropertyImplDecl *PID =

       // Suppress the warning if class's superclass implements property's
       // getter and implements property's setter (if readwrite property).
       // Or, if property is going to be implemented in its super class.
-      if (!SuperClassImplementsProperty(IDecl, Prop) && !PropInSuperClass) {
+      if (!SuperClassImplementsProperty(*this, IDecl, Prop) &&
+          !PropInSuperClass) {
         Diag(IMPDecl->getLocation(),
              diag::warn_auto_synthesizing_protocol_property)
           << Prop << Proto;

     }
     // If property to be implemented in the super class, ignore.
     if (PropInSuperClass) {
-      if ((Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite) &&
+      if ((Prop->getPropertyAttributes() &
+           ObjCPropertyDecl::OBJC_PR_readwrite) &&
           (PropInSuperClass->getPropertyAttributes() &
            ObjCPropertyDecl::OBJC_PR_readonly) &&
-          !IMPDecl->getInstanceMethod(Prop->getSetterName()) &&
-          !IDecl->HasUserDeclaredSetterMethod(Prop)) {
+          !IMPDecl->getInstanceMethod(Prop->getSetterName(),
+                                      IsHiddenCallback(*this)) &&
+          !IDecl->HasUserDeclaredSetterMethod(Prop, IsHiddenCallback(*this))) {
         Diag(Prop->getLocation(), diag::warn_no_autosynthesis_property)
         << Prop->getIdentifier();
         Diag(PropInSuperClass->getLocation(), diag::note_property_declare);

   // the class is going to implement them.
   if (I == SMap.end() &&
       (PrimaryClass == nullptr ||
-       !PrimaryClass->lookupPropertyAccessor(Method, C,
-                                             Prop->isClassProperty()))) {
+       !PrimaryClass->lookupPropertyAccessor(Method, Sema::IsHiddenCallback(S),
+                                             C, Prop->isClassProperty()))) {
     unsigned diag =
         isa<ObjCCategoryDecl>(CDecl)
             ? (Prop->isClassProperty()

     CollectSuperClassPropertyImplementations(IDecl, NoNeedToImplPropMap);
     
   // When SynthesizeProperties is true, we only check class properties.
-  CollectImmediateProperties(CDecl, PropMap, NoNeedToImplPropMap,
+  CollectImmediateProperties(*this, CDecl, PropMap, NoNeedToImplPropMap,
                              SynthesizeProperties/*CollectClassPropsOnly*/);
 
   // Scan the @interface to see if any of the protocols it adopts

       if (!LazyMap) {
         ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
         LazyMap.reset(new ObjCContainerDecl::PropertyMap());
-        CollectImmediateProperties(CDecl, *LazyMap, NoNeedToImplPropMap,
+        CollectImmediateProperties(*this, CDecl, *LazyMap, NoNeedToImplPropMap,
                                    /* CollectClassPropsOnly */ false,
                                    /* IncludeProtocols */ false);
       }

         property->getSetterMethodDecl()) {
       auto *getterMethod = property->getGetterMethodDecl();
       auto *setterMethod = property->getSetterMethodDecl();
-      if (!impDecl->getInstanceMethod(setterMethod->getSelector()) &&
-          !impDecl->getInstanceMethod(getterMethod->getSelector())) {
+      if (!impDecl->getInstanceMethod(setterMethod->getSelector(),
+                                      IsHiddenCallback(*this)) &&
+          !impDecl->getInstanceMethod(getterMethod->getSelector(),
+                                      IsHiddenCallback(*this))) {
         SourceLocation loc = propertyImpl->getLocation();
         if (loc.isInvalid())
           loc = impDecl->getLocStart();

 
     if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
         !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
-      GetterMethod = Property->isClassProperty() ?
-                     IMPDecl->getClassMethod(Property->getGetterName()) :
-                     IMPDecl->getInstanceMethod(Property->getGetterName());
-      SetterMethod = Property->isClassProperty() ?
-                     IMPDecl->getClassMethod(Property->getSetterName()) :
-                     IMPDecl->getInstanceMethod(Property->getSetterName());
+      GetterMethod = IMPDecl->getMethod(Property->getGetterName(),
+                                        !Property->isClassProperty(),
+                                        IsHiddenCallback(*this));
+      SetterMethod = IMPDecl->getMethod(Property->getSetterName(),
+                                        !Property->isClassProperty(),
+                                        IsHiddenCallback(*this));
       LookedUpGetterSetter = true;
       if (GetterMethod) {
         Diag(GetterMethod->getLocation(),

       if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
         continue;
       if (!LookedUpGetterSetter) {
-        GetterMethod = Property->isClassProperty() ?
-                       IMPDecl->getClassMethod(Property->getGetterName()) :
-                       IMPDecl->getInstanceMethod(Property->getGetterName());
-        SetterMethod = Property->isClassProperty() ?
-                       IMPDecl->getClassMethod(Property->getSetterName()) :
-                       IMPDecl->getInstanceMethod(Property->getSetterName());
+        GetterMethod = IMPDecl->getMethod(Property->getGetterName(),
+                                          !Property->isClassProperty(),
+                                          IsHiddenCallback(*this));
+        SetterMethod = IMPDecl->getMethod(Property->getSetterName(),
+                                          !Property->isClassProperty(),
+                                          IsHiddenCallback(*this));
       }
       if ((GetterMethod && !SetterMethod) || (!GetterMethod && SetterMethod)) {
         SourceLocation MethodLoc =

     const ObjCPropertyDecl *PD = PID->getPropertyDecl();
     if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
         !PD->isClassProperty() &&
-        !D->getInstanceMethod(PD->getGetterName())) {
+        !D->getInstanceMethod(PD->getGetterName(), IsHiddenCallback(*this))) {
       ObjCMethodDecl *method = PD->getGetterMethodDecl();
       if (!method)
         continue;

       InitSelSet.insert(I->getSelector());
 
   SmallVector<const ObjCMethodDecl *, 8> DesignatedInits;
-  SuperD->getDesignatedInitializers(DesignatedInits);
+  SuperD->getDesignatedInitializers(DesignatedInits, IsHiddenCallback(*this));
   for (SmallVector<const ObjCMethodDecl *, 8>::iterator
          I = DesignatedInits.begin(), E = DesignatedInits.end(); I != E; ++I) {
     const ObjCMethodDecl *MD = *I;
     if (!InitSelSet.count(MD->getSelector())) {
       bool Ignore = false;
-      if (auto *IMD = IFD->getInstanceMethod(MD->getSelector())) {
+      if (auto *IMD = IFD->getInstanceMethod(MD->getSelector(),
+                                             IsHiddenCallback(*this))) {
         Ignore = IMD->isUnavailable();
       }
       if (!Ignore) {

     return;
 
   bool IsClassProperty = property->isClassProperty();
-  GetterMethod = IsClassProperty ?
-    CD->getClassMethod(property->getGetterName()) :
-    CD->getInstanceMethod(property->getGetterName());
+  GetterMethod = CD->getMethod(property->getGetterName(), !IsClassProperty,
+                               IsHiddenCallback(*this));
 
   // if setter or getter is not found in class extension, it might be
   // in the primary class.

   if (!GetterMethod)
     if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD))
       if (CatDecl->IsClassExtension())
-        GetterMethod = IsClassProperty ? CatDecl->getClassInterface()->
-                         getClassMethod(property->getGetterName()) :
-                       CatDecl->getClassInterface()->
-                         getInstanceMethod(property->getGetterName());
-        
-  SetterMethod = IsClassProperty ?
-                 CD->getClassMethod(property->getSetterName()) :
-                 CD->getInstanceMethod(property->getSetterName());
+        GetterMethod = CatDecl->getClassInterface()->getMethod(
+            property->getGetterName(), !IsClassProperty,
+            IsHiddenCallback(*this));
+
+  SetterMethod = CD->getMethod(property->getSetterName(), !IsClassProperty,
+                               IsHiddenCallback(*this));
   if (!SetterMethod)
     if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD))
       if (CatDecl->IsClassExtension())
-        SetterMethod = IsClassProperty ? CatDecl->getClassInterface()->
-                          getClassMethod(property->getSetterName()) :
-                       CatDecl->getClassInterface()->
-                          getInstanceMethod(property->getSetterName());
+        SetterMethod = CatDecl->getClassInterface()->getMethod(
+            property->getSetterName(), !IsClassProperty,
+            IsHiddenCallback(*this));
   DiagnosePropertyAccessorMismatch(property, GetterMethod,
                                    property->getLocation());
 

lib/Sema/SemaOverload.cpp

       return false;
 
     // Conversion between Objective-C pointers.
-    if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
+    if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr,
+                                        IsHiddenCallback(*this))) {
       const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
       const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
       if (getLangOpts().CPlusPlus && LHS && RHS &&

       return true;
     }
 
-    if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
+    if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr,
+                                        IsHiddenCallback(*this))) {
       // Okay: this is some kind of implicit downcast of Objective-C
       // interfaces, which is permitted. However, we're going to
       // complain about it.

     const ObjCObjectPointerType* FromObjCPtr2
       = FromType2->getAs<ObjCObjectPointerType>();
     if (FromObjCPtr1 && FromObjCPtr2) {
-      bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
-                                                          FromObjCPtr2);
-      bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
-                                                           FromObjCPtr1);
+      bool AssignLeft = S.Context.canAssignObjCInterfaces(
+          FromObjCPtr1, FromObjCPtr2, Sema::IsHiddenCallback(S));
+      bool AssignRight = S.Context.canAssignObjCInterfaces(
+          FromObjCPtr2, FromObjCPtr1, Sema::IsHiddenCallback(S));
       if (AssignLeft != AssignRight) {
         return AssignLeft? ImplicitConversionSequence::Better
                          : ImplicitConversionSequence::Worse;

       // that we do for C++ pointers to class types. However, we employ the
       // Objective-C pseudo-subtyping relationship used for assignment of
       // Objective-C pointer types.
-      bool FromAssignLeft
-        = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
-      bool FromAssignRight
-        = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
-      bool ToAssignLeft
-        = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
-      bool ToAssignRight
-        = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
+      bool FromAssignLeft = S.Context.canAssignObjCInterfaces(
+          FromPtr1, FromPtr2, Sema::IsHiddenCallback(S));
+      bool FromAssignRight = S.Context.canAssignObjCInterfaces(
+          FromPtr2, FromPtr1, Sema::IsHiddenCallback(S));
+      bool ToAssignLeft = S.Context.canAssignObjCInterfaces(
+          ToPtr1, ToPtr2, Sema::IsHiddenCallback(S));
+      bool ToAssignRight = S.Context.canAssignObjCInterfaces(
+          ToPtr2, ToPtr1, Sema::IsHiddenCallback(S));
 
       // A conversion to an a non-id object pointer type or qualified 'id'
       // type is better than a conversion to 'id'.

     DerivedToBase = true;
   else if (UnqualT1->isObjCObjectOrInterfaceType() &&
            UnqualT2->isObjCObjectOrInterfaceType() &&
-           Context.canBindObjCObjectType(UnqualT1, UnqualT2))
+           Context.canBindObjCObjectType(UnqualT1, UnqualT2,
+                                         IsHiddenCallback(*this)))
     ObjCConversion = true;
   else if (UnqualT2->isFunctionType() &&
            IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2))

lib/Sema/SemaPseudoObject.cpp

         PropertyName[0] = front;
         IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName);
         if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(
-                AltMember, prop->getQueryKind()))
+                AltMember, prop->getQueryKind(), Sema::IsHiddenCallback(S)))
           if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
             S.Diag(RefExpr->getExprLoc(), diag::err_property_setter_ambiguous_use)
               << prop << prop1 << setter->getSelector();

lib/Sema/SemaStmt.cpp

 
     // If there's an interface, look in both the public and private APIs.
     if (iface) {
-      method = iface->lookupInstanceMethod(selector);
-      if (!method) method = iface->lookupPrivateMethod(selector);
+      method = iface->lookupInstanceMethod(selector, IsHiddenCallback(*this));
+      if (!method)
+        method = iface->lookupPrivateMethod(selector, IsHiddenCallback(*this));
     }
 
     // Also check protocol qualifiers.

lib/Sema/SemaType.cpp

         // parameter bound is 'id'.
         if (boundObjC->isObjCIdType())
           continue;
-      } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) {
+      } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC,
+                                                   Sema::IsHiddenCallback(S))) {
         // Otherwise, we follow the assignability rules.
         continue;
       }

lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp

         return;
 
       ObjCMethodDecl *GetterMethod =
-          InterfD->getInstanceMethod(PD->getGetterName());
+          InterfD->getInstanceMethod(PD->getGetterName(), AllDeclsVisible);
       ObjCMethodDecl *SetterMethod =
-          InterfD->getInstanceMethod(PD->getSetterName());
+          InterfD->getInstanceMethod(PD->getSetterName(), AllDeclsVisible);
 
       if (SetterMethod && SetterMethod->getCanonicalDecl() == MD)
         return;

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

       const ObjCInterfaceDecl *InterfaceDecl = TrackedType->getInterfaceDecl();
       // The method might not be found.
       Selector Sel = MessageExpr->getSelector();
-      Method = InterfaceDecl->lookupInstanceMethod(Sel);
+      Method = InterfaceDecl->lookupInstanceMethod(Sel, AllDeclsVisible);
       if (!Method)
-        Method = InterfaceDecl->lookupClassMethod(Sel);
+        Method = InterfaceDecl->lookupClassMethod(Sel, AllDeclsVisible);
     }
   }
 

lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp

     const ObjCMethodDecl *InterfD = *I;
 
     // Get the corresponding method in the @implementation.
-    const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
-                                               InterfD->isInstanceMethod());
+    const ObjCMethodDecl *D = ImplD->getMethod(
+        InterfD->getSelector(), InterfD->isInstanceMethod(), AllDeclsVisible);
     if (D && D->hasBody()) {
       AtImplementationContainsAtLeastOnePartialInvalidationMethod = true;
 

     const ObjCMethodDecl *InterfD = *I;
 
     // Get the corresponding method in the @implementation.
-    const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
-                                               InterfD->isInstanceMethod());
+    const ObjCMethodDecl *D = ImplD->getMethod(
+        InterfD->getSelector(), InterfD->isInstanceMethod(), AllDeclsVisible);
     if (D && D->hasBody()) {
       AtImplementationContainsAtLeastOneInvalidationMethod = true;
 

lib/StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp

     ImplD = CatD->getClassInterface()->getImplementation();
   }
 
-  if (!ImplD || ImplD->HasUserDeclaredSetterMethod(D))
+  if (!ImplD || ImplD->HasUserDeclaredSetterMethod(D, AllDeclsVisible))
     return;
 
   SmallString<128> Str;

lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp

   Selector S = Msg.getSelector();
   const ObjCMethodDecl *Method = Msg.getDecl();
   if (!Method && ReceiverClass)
-    Method = ReceiverClass->getInstanceMethod(S);
+    Method = ReceiverClass->getInstanceMethod(S, AllDeclsVisible);
 
   return getMethodSummary(S, ReceiverClass, Method, Msg.getResultType(),
                           ObjCMethodSummaries);

lib/StaticAnalyzer/Core/CallEvent.cpp

   // the selector.
   ObjCMethodDecl *D = nullptr;
   while (true) {
-    D = IDecl->lookupMethod(Sel, true);
+    D = IDecl->lookupMethod(Sel, true, AllDeclsVisible);
 
     // Cannot find a public definition.
     if (!D)

 
         // Query lookupPrivateMethod() if the cache does not hit.
         if (!Val.hasValue()) {
-          Val = IDecl->lookupPrivateMethod(Sel);
+          Val = IDecl->lookupPrivateMethod(Sel, AllDeclsVisible);
 
           // If the method is a property accessor, we should try to "inline" it
           // even if we don't actually have an implementation.

                   auto *ID = CompileTimeMD->getClassInterface();
                   for (auto *CatDecl : ID->visible_extensions()) {
                     Val = CatDecl->getMethod(Sel,
-                                             CompileTimeMD->isInstanceMethod());
+                                             CompileTimeMD->isInstanceMethod(),
+                                             AllDeclsVisible);
                     if (*Val)
                       break;
                   }
                 }
                 if (!*Val)
-                  Val = IDecl->lookupInstanceMethod(Sel);
+                  Val = IDecl->lookupInstanceMethod(Sel, AllDeclsVisible);
               }
         }
 

     // class name.
     if (ObjCInterfaceDecl *IDecl = E->getReceiverInterface()) {
       // Find/Return the method implementation.
-      return RuntimeDefinition(IDecl->lookupPrivateClassMethod(Sel));
+      return RuntimeDefinition(
+          IDecl->lookupPrivateClassMethod(Sel, AllDeclsVisible));
     }
   }
 

test/Modules/interface-visibility.m

+// RUN: %clang_cc1 -fmodules -fobjc-arc -x objective-c-module-map %s -fmodule-name=Foo -verify
+
+module Foo {}
+
+#pragma clang module contents
+#pragma clang module begin Foo
+
+// expected-no-diagnostics
+
+#pragma clang module build Foundation
+module Foundation {}
+#pragma clang module contents
+#pragma clang module begin Foundation
+@interface NSIndexSet
+@end
+#pragma clang module end
+#pragma clang module endbuild
+
+#pragma clang module import Foundation
+
+@interface NSIndexSet (Testing)
+- (int)foo;
+@end
+
+static inline int test(NSIndexSet *obj) {
+  return [obj foo];
+}
+
+#pragma clang module end

tools/libclang/CIndex.cpp

   IdentifierInfo *PropertyId = PD->getIdentifier();
   ObjCPropertyDecl *prevDecl =
     ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId,
-                                       PD->getQueryKind());
+                                       PD->getQueryKind(), AllDeclsVisible);
 
   if (!prevDecl)
     return false;

     if (const ObjCInterfaceDecl *Class
                        = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
       if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
-        if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
-                                                  Method->isInstanceMethod()))
+        if (ObjCMethodDecl *Def = ClassImpl->getMethod(
+                Method->getSelector(), Method->isInstanceMethod(),
+                AllDeclsVisible))
           if (Def->isThisDeclarationADefinition())
             return MakeCXCursor(Def, TU);