[core] Only check via TClassTable for alternative names

Author: vepadulano

core/clingutils/res/TClingUtils.h

@@ -160,25 +160,26 @@ class TNormalizedCtxt {
 class TClingLookupHelper : public TClassEdit::TInterpreterLookupHelper {
 public:
    typedef bool (*ExistingTypeCheck_t)(const std::string &tname, std::string &result);
+   typedef bool (*TClassTableCheck_t)(const std::string &tname, std::string &result);
    typedef bool (*AutoParse_t)(const char *name);
 
 private:
    cling::Interpreter *fInterpreter;
    TNormalizedCtxt    *fNormalizedCtxt;
    ExistingTypeCheck_t fExistingTypeCheck;
+   TClassTableCheck_t fTClassTableCheck;
    AutoParse_t         fAutoParse;
    bool               *fInterpreterIsShuttingDownPtr;
    const int          *fPDebug; // debug flag, might change at runtime thus *
    bool WantDiags() const { return fPDebug && *fPDebug > 5; }
 
 public:
-   TClingLookupHelper(cling::Interpreter &interpreter, TNormalizedCtxt &normCtxt,
-                      ExistingTypeCheck_t existingTypeCheck,
-                      AutoParse_t autoParse,
-                      bool *shuttingDownPtr,
+   TClingLookupHelper(cling::Interpreter &interpreter, TNormalizedCtxt &normCtxt, ExistingTypeCheck_t existingTypeCheck,
+                      TClassTableCheck_t TClassTableCheck, AutoParse_t autoParse, bool *shuttingDownPtr,
                       const int *pgDebug = nullptr);
    virtual ~TClingLookupHelper() { /* we're not owner */ }
 
+   bool TClassTableCheck(const std::string &tname, std::string &result) override;
    bool ExistingTypeCheck(const std::string &tname, std::string &result) override;
    void GetPartiallyDesugaredName(std::string &nameLong) override;
    bool IsAlreadyPartiallyDesugaredName(const std::string &nondef, const std::string &nameLong) override;

core/clingutils/src/TClingUtils.cxx

@@ -522,17 +522,16 @@ AnnotatedRecordDecl::AnnotatedRecordDecl(long index,
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TClingLookupHelper::TClingLookupHelper(cling::Interpreter &interpreter,
-                                       TNormalizedCtxt &normCtxt,
-                                       ExistingTypeCheck_t existingTypeCheck,
-                                       AutoParse_t autoParse,
-                                       bool *shuttingDownPtr,
-                                       const int* pgDebug /*= 0*/):
-   fInterpreter(&interpreter),fNormalizedCtxt(&normCtxt),
-   fExistingTypeCheck(existingTypeCheck),
-   fAutoParse(autoParse),
-   fInterpreterIsShuttingDownPtr(shuttingDownPtr),
-   fPDebug(pgDebug)
+TClingLookupHelper::TClingLookupHelper(cling::Interpreter &interpreter, TNormalizedCtxt &normCtxt,
+                                       ExistingTypeCheck_t existingTypeCheck, TClassTableCheck_t TClassTableCheck,
+                                       AutoParse_t autoParse, bool *shuttingDownPtr, const int *pgDebug /*= 0*/)
+   : fInterpreter(&interpreter),
+     fNormalizedCtxt(&normCtxt),
+     fExistingTypeCheck(existingTypeCheck),
+     fTClassTableCheck(TClassTableCheck),
+     fAutoParse(autoParse),
+     fInterpreterIsShuttingDownPtr(shuttingDownPtr),
+     fPDebug(pgDebug)
 {
 }
 
@@ -549,6 +548,17 @@ bool TClingLookupHelper::ExistingTypeCheck(const std::string &tname,
    else return false;
 }
 
+bool TClingLookupHelper::TClassTableCheck(const std::string &tname, std::string &result)
+{
+   if (tname.empty())
+      return false;
+
+   if (fTClassTableCheck)
+      return fTClassTableCheck(tname, result);
+   else
+      return false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void TClingLookupHelper::GetPartiallyDesugaredName(std::string &nameLong)

core/dictgen/src/rootcling_impl.cxx

@@ -4498,7 +4498,7 @@ int RootClingMain(int argc,
 
    // We are now ready (enough is loaded) to init the list of opaque typedefs.
    ROOT::TMetaUtils::TNormalizedCtxt normCtxt(interp.getLookupHelper());
-   ROOT::TMetaUtils::TClingLookupHelper helper(interp, normCtxt, nullptr, nullptr, nullptr);
+   ROOT::TMetaUtils::TClingLookupHelper helper(interp, normCtxt, nullptr, nullptr, nullptr, nullptr);
    TClassEdit::Init(&helper);
 
    // flags used only for the pragma parser:

core/foundation/inc/TClassEdit.h

@@ -124,6 +124,7 @@ namespace TClassEdit {
       TInterpreterLookupHelper() { }
       virtual ~TInterpreterLookupHelper();
 
+      virtual bool TClassTableCheck(const std::string &, std::string &) = 0;
       virtual bool ExistingTypeCheck(const std::string & /*tname*/,
                                      std::string & /*result*/) = 0;
       virtual void GetPartiallyDesugaredName(std::string & /*nameLong*/) = 0;

core/foundation/src/TClassEdit.cxx

@@ -913,7 +913,7 @@ void TClassEdit::GetNormalizedName(std::string &norm_name, std::string_view name
       // is when looking for registered alternate names of a custom user class
       // present in the class dictionary.
       std::string typeresult;
-      if (gInterpreterHelper->ExistingTypeCheck(norm_name, typeresult)) {
+      if (gInterpreterHelper->TClassTableCheck(norm_name, typeresult)) {
          if (!typeresult.empty()) {
             norm_name = typeresult;
          }

core/metacling/src/TCling.cxx

@@ -1010,6 +1010,39 @@ bool TClingLookupHelper__ExistingTypeCheck(const std::string &tname,
    return false;
 }
 
+bool TClingLookupHelper__TClassTableCheck(const std::string &tname, std::string &result)
+{
+   result.clear();
+
+   unsigned long offset = 0;
+   if (strncmp(tname.c_str(), "const ", 6) == 0) {
+      offset = 6;
+   }
+   unsigned long end = tname.length();
+   while (end && (tname[end - 1] == '&' || tname[end - 1] == '*' || tname[end - 1] == ']')) {
+      if (tname[end - 1] == ']') {
+         --end;
+         while (end && tname[end - 1] != '[')
+            --end;
+      }
+      --end;
+   }
+   std::string innerbuf;
+   const char *inner;
+   if (end != tname.length()) {
+      innerbuf = tname.substr(offset, end - offset);
+      inner = innerbuf.c_str();
+   } else {
+      inner = tname.c_str() + offset;
+   }
+
+   if (gROOT->GetListOfClasses()->FindObject(inner) || TClassTable::Check(inner, result)) {
+      // This is a known class.
+      return true;
+   }
+
+   return false;
+}
 ////////////////////////////////////////////////////////////////////////////////
 
 TCling::TUniqueString::TUniqueString(Long64_t size)
@@ -1586,10 +1619,9 @@ TCling::TCling(const char *name, const char *title, const char* const argv[], vo
 
    // We are now ready (enough is loaded) to init the list of opaque typedefs.
    fNormalizedCtxt = new ROOT::TMetaUtils::TNormalizedCtxt(fInterpreter->getLookupHelper());
-   fLookupHelper = new ROOT::TMetaUtils::TClingLookupHelper(*fInterpreter, *fNormalizedCtxt,
-                                                            TClingLookupHelper__ExistingTypeCheck,
-                                                            TClingLookupHelper__AutoParse,
-                                                            &fIsShuttingDown);
+   fLookupHelper = new ROOT::TMetaUtils::TClingLookupHelper(
+      *fInterpreter, *fNormalizedCtxt, TClingLookupHelper__ExistingTypeCheck, TClingLookupHelper__TClassTableCheck,
+      TClingLookupHelper__AutoParse, &fIsShuttingDown);
    TClassEdit::Init(fLookupHelper);
 
    // Disallow auto-parsing in rootcling