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

@@ -3046,6 +3046,25 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi
       // continue as before ...
    }
 
+   // Check if this is a fundamental type already in the typesystem to delay
+   // as much as possible any lookup
+   if (!cl) {
+      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);
+            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;
+      }
+   }
+
    std::string normalizedName;
    Bool_t checkTable = kFALSE;
 
@@ -3054,6 +3073,7 @@ TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hi
          TInterpreter::SuspendAutoLoadingRAII autoloadOff(gInterpreter);
          TClassEdit::GetNormalizedName(normalizedName, name);
       }
+
       // Try the normalized name.
       if (normalizedName != name) {
          cl = (TClass*)gROOT->GetListOfClasses()->FindObject(normalizedName.c_str());