TClass::GetClass: no interpreter lookups for fundamental types

This commit solves issue #9029 and, more in general, avoid lookups
and parsing in some cases.
One of the principles of the TClass::GetClass method implementation
is to avoid as much as possible. This commit adds yet another fence
in TClass::GetClass, checking if the name in input is the name of a
known fundamental type or typedef to it.
In order to avoid code duplication, a routine previously available
within the implementation of TClassEdit has been made available with
a public API.

Author: dpiparo

core/foundation/inc/TClassEdit.h

@@ -180,6 +180,8 @@ namespace TClassEdit {
    ROOT::ESTLType STLKind(std::string_view type);    //Kind of stl container
    inline ROOT::ESTLType STLKind(ROOT::Internal::TStringView type) { return STLKind(std::string_view(type)); }
    int         STLArgs   (int kind);            //Min number of arguments without allocator
+   void RemoveStd(std::string &name, size_t pos = 0);
+   void RemoveStd(std::string_view &name);
    std::string ResolveTypedef(const char *tname, bool resolveAll = false);
    std::string ShortType (const char *typeDesc, int mode);
    std::string InsertStd(const char *tname);

core/foundation/src/TClassEdit.cxx

@@ -112,7 +112,7 @@ static size_t StdLen(const std::string_view name)
 /// Remove std:: and any potential inline namespace (well compiler detail
 /// namespace.
 
-static void RemoveStd(std::string &name, size_t pos = 0)
+void TClassEdit::RemoveStd(std::string &name, size_t pos)
 {
    size_t len = StdLen({name.data()+pos,name.length()-pos});
    if (len) {
@@ -124,7 +124,7 @@ static void RemoveStd(std::string &name, size_t pos = 0)
 /// Remove std:: and any potential inline namespace (well compiler detail
 /// namespace.
 
-static void RemoveStd(std::string_view &name)
+void TClassEdit::RemoveStd(std::string_view &name)
 {
    size_t len = StdLen(name);
    if (len) {

core/meta/src/TClass.cxx

@@ -3047,13 +3047,35 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi
    }
 
    std::string normalizedName;
-   Bool_t checkTable = kFALSE;
 
+   // Check if this is a fundamental type already in the typesystem to delay
+   // as much as possible any lookup
    if (!cl) {
       {
          TInterpreter::SuspendAutoLoadingRAII autoloadOff(gInterpreter);
          TClassEdit::GetNormalizedName(normalizedName, name);
       }
+      std::string name_no_std = name;
+      TClassEdit::RemoveStd(name_no_std);
+      auto lot = reinterpret_cast<THashTable *>(gROOT->GetListOfTypes());
+      auto theType = reinterpret_cast<TDataType *>(lot->THashTable::FindObject(name_no_std.c_str()));
+      if (theType && -1 != theType->GetType()) {
+         return nullptr;
+      } else {
+         {
+            TInterpreter::SuspendAutoLoadingRAII autoloadOff(gInterpreter);
+            TInterpreter::SuspendAutoParsing autoparseOff(gInterpreter);
+            theType = reinterpret_cast<TDataType *>(lot->FindObject(name));
+         }
+         // If it is a typedef, check that this is not a class
+         if (theType && -1 != theType->GetType())
+            return nullptr;
+      }
+   }
+
+   Bool_t checkTable = kFALSE;
+
+   if (!cl) {
       // Try the normalized name.
       if (normalizedName != name) {
          cl = (TClass*)gROOT->GetListOfClasses()->FindObject(normalizedName.c_str());
@@ -3067,8 +3089,8 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi
          checkTable = kTRUE;
      }
    } else {
-      normalizedName = cl->GetName(); // Use the fact that all TClass names are normalized.
-      checkTable = load && (normalizedName != name);
+     normalizedName = cl->GetName(); // Use the fact that all TClass names are normalized.
+     checkTable = load && (normalizedName != name);
    }
 
    if (!load) return nullptr;