[clang][modules] Always let Obj-C decls query the ExternalASTSource for complete redecl chains

[teemperor]

Summary

ObjCInterfaceDecls and ObjCProtocolDecls currently have a flag that indicates whether they
need to query the ExternalASTSource to complete their redeclaration chain. This flag is currently
only set when LangOpts.Modules == true. The idea behind that seems to be that only with
LangOpts.Modules == true we have a chance to find a definition for an existing declaration via the
ExternalASTSource, so we optimize the non-modules case by avoiding the work of looking for an
external definition.

The idea that LangOpts.Modules implies that the ExternalASTSource can provide a definition
doesn't work within LLDB where we are not always setting the Modules flag but we always have an
ExternalASTSource that can complete the redeclaration chain (and provide a definition).

This patch sets the flag whenever we have any valid ExternalASTSource so that the ExternalASTSource
in LLDB is also queried for definitions. In Clang this patch maintains the current behaviour for parsing
with enabled and disabled modules. The only behaviour change in Clang is that we now also query the
ExternalASTSource for Obj-C interface/protocol definitions when using (chained) PCHs.

[teemperor]

• An alternative implementation would be to extend the ExternalASTSource interface with something such as bool CanCompleteRedeclChains() const that returns true/false whether we need to query the ExternalASTSource. That would also allow us to preserve the old behaviour for the PCH case.
• I haven't done any benchmarks on how much (if at all) this slows down compiling with a PCH. Given that the same slowdown happens by just passing -fmodules without importing any modules, I don't think there is any meaningful slowdown.
• No Clang test yet as I believe this can only be tested via a unit test where I add a custom ExternalASTSource which is always a bunch of boilerplate. I'll add one later if there are no objections against the current direction of the patch.
• See also D101950 where LLDB now implements CompleteRedeclChain but doesn't receive any calls for Obj-C decls without this patch.

[jansvoboda11]

This seems reasonable to me. I have some questions though:

• Could LLDB potentially enable modules to get the desired behavior?
• Can't we query the CompilerInvocation (FrontendOptions?) to determine whether we have PCH enabled and preserve the current semantics if so?
• Can you provide a test that demonstrates the LLDB use-case?

I'm not that familiar with redeclaration chain deserialization, so I'd be more comfortable if someone else took a look as well. @rsmith and @vsapsai, do you have opinion on this?

clang/include/clang/AST/DeclObjC.h

class ObjCInterfaceDecl : public ObjCContainerDecl
 
   /// The type parameters associated with this class, if any.
   ObjCTypeParamList *TypeParamList = nullptr;
 
   /// Contains a pointer to the data associated with this class,
   /// which will be NULL if this class has not yet been defined.
   ///
   /// The bit indicates when we don't need to check for out-of-date
-  /// declarations. It will be set unless modules are enabled.
+  /// declarations. It will be set unless there is an ExternalASTSource that
+  /// could provide a definition.
   llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
 
   ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC, SourceLocation AtLoc,
                     IdentifierInfo *Id, ObjCTypeParamList *typeParamList,
                     SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
                     bool IsInternal);
 
   void anchor() override;
bool isThisDeclarationADefinition() const {
     return getDefinition() == this;
   }
 
   /// Determine whether this class has been defined.
   bool hasDefinition() const {
     // If the name of this class is out-of-date, bring it up-to-date, which
     // might bring in a definition.
     // Note: a null value indicates that we don't have a definition and that
-    // modules are enabled.
+    // there is a ExternalASTSource that could provide a definition.
     if (!Data.getOpaqueValue())
       getMostRecentDecl();
 
     return Data.getPointer();
   }
 
   /// Retrieve the definition of this class, or NULL if this class
   /// has been forward-declared (with \@class) but not yet defined (with
struct DefinitionData {
     /// Referenced protocols
     ObjCProtocolList ReferencedProtocols;
   };
 
   /// Contains a pointer to the data associated with this class,
   /// which will be NULL if this class has not yet been defined.
   ///
   /// The bit indicates when we don't need to check for out-of-date
-  /// declarations. It will be set unless modules are enabled.
+  /// declarations. It will be set unless there is an ExternalASTSource that
+  /// could provide a definition.
   llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
 
   ObjCProtocolDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
                    SourceLocation nameLoc, SourceLocation atStartLoc,
                    ObjCProtocolDecl *PrevDecl);
 
   void anchor() override;
 
ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
     return lookupMethod(Sel, false/*isInstance*/);
   }
 
   /// Determine whether this protocol has a definition.
   bool hasDefinition() const {
     // If the name of this protocol is out-of-date, bring it up-to-date, which
     // might bring in a definition.
     // Note: a null value indicates that we don't have a definition and that
-    // modules are enabled.
+    // there is a ExternalASTSource that could provide a definition.
     if (!Data.getOpaqueValue())
       getMostRecentDecl();
 
     return Data.getPointer();
   }
 
   /// Retrieve the definition of this protocol, if any.
   ObjCProtocolDecl *getDefinition() {

clang/lib/AST/DeclObjC.cpp

ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
                                              IdentifierInfo *Id,
                                              ObjCTypeParamList *typeParamList,
                                              ObjCInterfaceDecl *PrevDecl,
                                              SourceLocation ClassLoc,
                                              bool isInternal){
   auto *Result = new (C, DC)
       ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
                         isInternal);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getExternalSource());
   C.getObjCInterfaceType(Result, PrevDecl);
   return Result;
 }
 
 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                          unsigned ID) {
   auto *Result = new (C, ID)
       ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
                         SourceLocation(), nullptr, false);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getExternalSource());
   return Result;
 }
 
 ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
                                      SourceLocation AtLoc, IdentifierInfo *Id,
                                      ObjCTypeParamList *typeParamList,
                                      SourceLocation CLoc,
                                      ObjCInterfaceDecl *PrevDecl,

 
 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
                                            IdentifierInfo *Id,
                                            SourceLocation nameLoc,
                                            SourceLocation atStartLoc,
                                            ObjCProtocolDecl *PrevDecl) {
   auto *Result =
       new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getExternalSource());
   return Result;
 }
 
 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
   ObjCProtocolDecl *Result =
       new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
                                    SourceLocation(), nullptr);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getExternalSource());
   return Result;
 }
 
 bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
   return hasAttr<ObjCNonRuntimeProtocolAttr>();
 }
 
 void ObjCProtocolDecl::getImpliedProtocols(