[cling] use one instead of two lookups within TClass::Init()

Fixes #7123

Author: ferdymercury

core/meta/inc/TInterpreter.h

@@ -208,14 +208,14 @@ class TInterpreter : public TNamed {
    virtual void     UpdateListOfGlobals() = 0;
    virtual void     UpdateListOfGlobalFunctions() = 0;
    virtual void     UpdateListOfTypes() = 0;
-   virtual void     SetClassInfo(TClass *cl, Bool_t reload = kFALSE) = 0;
+   virtual void     SetClassInfo(TClass *cl, Bool_t reload = kFALSE, TDictionary::DeclId_t decl = nullptr) = 0;
 
    enum ECheckClassInfo {
       kUnknown = 0, // backward compatible with false
       kKnown = 1,
       kWithClassDefInline = 2
    };
-   virtual ECheckClassInfo CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE) = 0;
+   virtual ECheckClassInfo CheckClassInfo(const char *name, TDictionary::DeclId_t &decl, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE) = 0;
 
    virtual Bool_t   CheckClassTemplate(const char *name) = 0;
    virtual Longptr_t Calc(const char *line, EErrorCode* error = nullptr) = 0;

core/meta/src/TClass.cxx

@@ -1513,8 +1513,9 @@ void TClass::Init(const char *name, Version_t cversion,
          if (proto)
             proto->FillTClass(this);
       }
-      if (!fHasRootPcmInfo && gInterpreter->CheckClassInfo(fName, /* autoload = */ kTRUE)) {
-         gInterpreter->SetClassInfo(this);   // sets fClassInfo pointer
+      TDictionary::DeclId_t decl {};
+      if (!fHasRootPcmInfo && gInterpreter->CheckClassInfo(fName, decl, /* autoload = */ kTRUE)) {
+         gInterpreter->SetClassInfo(this, kFALSE, decl);   // sets fClassInfo pointer
          if (fClassInfo) {
             // This should be moved out of GetCheckSum itself however the last time
             // we tried this cause problem, in particular in the end-of-process operation.
@@ -3187,7 +3188,8 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi
       printf("TClass::GetClass: Header Parsing - The representation of %s was not found in the type system. A lookup in the interpreter is about to be tried: this can cause parsing. This can be avoided selecting %s in the linkdef/selection file.\n",normalizedName.c_str(), normalizedName.c_str());
    }
    if (normalizedName.length()) {
-      auto cci = gInterpreter->CheckClassInfo(normalizedName.c_str(), kTRUE /* autoload */,
+      TDictionary::DeclId_t decl {};
+      auto cci = gInterpreter->CheckClassInfo(normalizedName.c_str(), decl, kTRUE /* autoload */,
                                               kTRUE /*Only class, structs and ns*/);
 
       // We could have an interpreted class with an inline ClassDef, in this case we do not

core/metacling/src/TCling.cxx

@@ -3985,8 +3985,9 @@ static std::string AlternateTuple(const char *classname, const cling::LookupHelp
 /// Set pointer to the TClingClassInfo in TClass.
 /// If 'reload' is true, (attempt to) generate a new ClassInfo even if we
 /// already have one.
+/// \param decl pointer to decl if already found one by CheckClassInfo
 
-void TCling::SetClassInfo(TClass* cl, Bool_t reload)
+void TCling::SetClassInfo(TClass* cl, Bool_t reload, TDictionary::DeclId_t decl)
 {
    // We are shutting down, there is no point in reloading, it only triggers
    // redundant deserializations.
@@ -4046,7 +4047,7 @@ void TCling::SetClassInfo(TClass* cl, Bool_t reload)
    // that is currently in the caller (like SetUnloaded) that disable AutoLoading and AutoParsing and
    // code is in the callee (disabling template instantiation) and end up with a more explicit class:
    //      TClingClassInfoReadOnly.
-   TClingClassInfo* info = new TClingClassInfo(GetInterpreterImpl(), name.c_str(), instantiateTemplate);
+   TClingClassInfo* info = (decl && !static_cast<const clang::Decl *>(decl)->isInvalidDecl()) ? new TClingClassInfo(GetInterpreterImpl(), decl) : new TClingClassInfo(GetInterpreterImpl(), name.c_str(), instantiateTemplate);
    if (!info->IsValid()) {
       SetWithoutClassInfoState(cl);
       delete info;
@@ -4121,9 +4122,11 @@ void TCling::SetClassInfo(TClass* cl, Bool_t reload)
 /// specifically check that each level of nesting is already loaded.
 /// In case of templates the idea is that everything between the outer
 /// '<' and '>' has to be skipped, e.g.: `aap<pippo<noot>::klaas>::a_class`
+///
+/// \param decl parameter passed by reference and set to the found decl, if any
 
 TInterpreter::ECheckClassInfo
-TCling::CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly /* = kFALSE*/)
+TCling::CheckClassInfo(const char *name, TDictionary::DeclId_t &decl, Bool_t autoload, Bool_t isClassOrNamespaceOnly /* = kFALSE*/)
 {
    R__LOCKGUARD(gInterpreterMutex);
    static const char *anonEnum = "anonymous enum ";
@@ -4191,19 +4194,18 @@ TCling::CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamesp
    // this forward declaration.
    const cling::LookupHelper& lh = fInterpreter->getLookupHelper();
    const clang::Type *type = nullptr;
-   const clang::Decl *decl
+   decl
       = lh.findScope(classname,
                      gDebug > 5 ? cling::LookupHelper::WithDiagnostics
                      : cling::LookupHelper::NoDiagnostics,
-                     &type, /* intantiateTemplate= */ false );
+                     &type, /* instantiateTemplate= */ false);
    if (!decl) {
       std::string buf = TClassEdit::InsertStd(classname);
       decl = lh.findScope(buf,
                           gDebug > 5 ? cling::LookupHelper::WithDiagnostics
                           : cling::LookupHelper::NoDiagnostics,
-                          &type,false);
+                          &type, /* instantiateTemplate= */ false);
    }
-
    if (type) {
       // If decl==0 and the type is valid, then we have a forward declaration.
       if (!decl) {

core/metacling/src/TCling.h

@@ -270,9 +270,9 @@ class TCling final : public TInterpreter {
    void    UpdateListOfGlobals() final;
    void    UpdateListOfGlobalFunctions() final;
    void    UpdateListOfTypes() final;
-   void    SetClassInfo(TClass* cl, Bool_t reload = kFALSE) final;
+   void    SetClassInfo(TClass* cl, Bool_t reload = kFALSE, TDictionary::DeclId_t decl = nullptr) final;
 
-   ECheckClassInfo CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE) final;
+   ECheckClassInfo CheckClassInfo(const char *name, TDictionary::DeclId_t &decl, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE) final;
 
    Bool_t  CheckClassTemplate(const char *name) final;
    Longptr_t Calc(const char* line, EErrorCode* error = nullptr) final;

core/metacling/src/TClingClassInfo.cxx

@@ -78,7 +78,7 @@ TClingClassInfo::TClingClassInfo(cling::Interpreter *interp, Bool_t all)
    SetDecl(TU);
 }
 
-TClingClassInfo::TClingClassInfo(cling::Interpreter *interp, const char *name, bool intantiateTemplate /* = true */)
+TClingClassInfo::TClingClassInfo(cling::Interpreter *interp, const char *name, bool instantiateTemplate /* = true */)
    : TClingDeclInfo(nullptr), fInterp(interp), fFirstTime(true), fDescend(false), fIterAll(kTRUE), fIsIter(false),
      fOffsetCache(0)
 {
@@ -87,14 +87,14 @@ TClingClassInfo::TClingClassInfo(cling::Interpreter *interp, const char *name, b
    const Decl *decl = lh.findScope(name,
                                    gDebug > 5 ? cling::LookupHelper::WithDiagnostics
                                    : cling::LookupHelper::NoDiagnostics,
-                                   &type, intantiateTemplate);
+                                   &type, instantiateTemplate);
    if (!decl) {
       std::string buf = TClassEdit::InsertStd(name);
       if (buf != name) {
          decl = lh.findScope(buf,
                              gDebug > 5 ? cling::LookupHelper::WithDiagnostics
                              : cling::LookupHelper::NoDiagnostics,
-                             &type, intantiateTemplate);
+                             &type, instantiateTemplate);
       }
    }
    if (!decl && type) {

core/metacling/src/TClingClassInfo.h

@@ -94,7 +94,7 @@ class TClingClassInfo final : public TClingDeclInfo {
       fDeclFileName(rhs.fDeclFileName), fOffsetCache(rhs.fOffsetCache)
    {}
    explicit TClingClassInfo(cling::Interpreter *, Bool_t all = kTRUE);
-   explicit TClingClassInfo(cling::Interpreter *, const char *classname, bool intantiateTemplate = kTRUE);
+   explicit TClingClassInfo(cling::Interpreter *, const char *classname, bool instantiateTemplate = kTRUE);
    explicit TClingClassInfo(cling::Interpreter *interp, const clang::Type &tag);
    explicit TClingClassInfo(cling::Interpreter *interp, const clang::Decl *D);
    TClingClassInfo &operator=(const TClingClassInfo &rhs)

core/textinput/src/Getline_color.cxx

@@ -232,9 +232,10 @@ void ROOT::TextInputColorizer::ProcessTextChange(EditorRange& Modification,
          }
          std::string word = text.substr(i, wordLen);
          char color = kColorNone;
+         TDictionary::DeclId_t decl;
          if (gClassTable->GetDict(word.c_str())
              || gInterpreter->GetClassSharedLibs(word.c_str())
-             || gInterpreter->CheckClassInfo(word.c_str(), false /*autoload*/)
+             || gInterpreter->CheckClassInfo(word.c_str(), decl, false /*autoload*/)
              || ((THashTable*)gROOT->GetListOfTypes())
                 ->THashTable::FindObject(word.c_str())) {
             color = kColorType;