Issue7955 type first spec 2

.github/workflows/root-ci.yml

@@ -240,6 +240,10 @@ jobs:
             config: Debug
           - event_name: push
             config: Debug
+          # This is this platform is subject to timeouts when building from
+          # scratch.
+          - target_arch: x86
+            config: Debug 
 
     name: Windows 10 ${{ matrix.target_arch }} ${{ matrix.config }}
 

core/clingutils/res/TClingUtils.h

@@ -613,12 +613,14 @@ static inline std::string DemangleNameForDlsym(const std::string& name)
 //______________________________________________________________________________
 // Return the type with all parts fully qualified (most typedefs),
 // including template arguments, appended to name.
-void GetFullyQualifiedTypeName(std::string &name, const clang::QualType &type, const cling::Interpreter &interpreter);
+void GetFullyQualifiedTypeName(std::string &name, const clang::QualType &type, const cling::Interpreter &interpreter,
+                               const clang::ClassTemplateSpecializationDecl *Spec = nullptr);
 
 //______________________________________________________________________________
 // Return the type with all parts fully qualified (most typedefs),
 // including template arguments, appended to name, without using the interpreter
-void GetFullyQualifiedTypeName(std::string &name, const clang::QualType &type, const clang::ASTContext &);
+void GetFullyQualifiedTypeName(std::string &name, const clang::QualType &type, const clang::ASTContext &,
+                               const clang::ClassTemplateSpecializationDecl *Spec = nullptr);
 
 //______________________________________________________________________________
 // Return the type normalized for ROOT,

core/clingutils/src/TClingUtils.cxx

@@ -1358,7 +1358,8 @@ bool ROOT::TMetaUtils::HasCustomConvStreamerMemberFunction(const AnnotatedRecord
 
 void ROOT::TMetaUtils::GetQualifiedName(std::string &qual_name, const clang::QualType &type, const clang::NamedDecl &forcontext)
 {
-   ROOT::TMetaUtils::GetFullyQualifiedTypeName(qual_name, type, forcontext.getASTContext());
+   ROOT::TMetaUtils::GetFullyQualifiedTypeName(qual_name, type, forcontext.getASTContext(),
+      llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(&forcontext));
 }
 
 //----
@@ -1473,6 +1474,7 @@ static void CreateNameTypeMap(const clang::CXXRecordDecl &cl, ROOT::MembersTypeM
    std::string typenameStr;
 
    const clang::ASTContext& astContext =  cl.getASTContext();
+   auto CTSD = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(&cl);
 
    // Loop over the non static data member.
    for(clang::RecordDecl::field_iterator field_iter = cl.field_begin(), end = cl.field_end();
@@ -1497,7 +1499,7 @@ static void CreateNameTypeMap(const clang::CXXRecordDecl &cl, ROOT::MembersTypeM
          }
       }
 
-      ROOT::TMetaUtils::GetFullyQualifiedTypeName(typenameStr, fieldType, astContext);
+      ROOT::TMetaUtils::GetFullyQualifiedTypeName(typenameStr, fieldType, astContext, CTSD);
       nameType[field_iter->getName().str()] = ROOT::Internal::TSchemaType(typenameStr.c_str(),dims.str().c_str());
    }
 
@@ -3489,9 +3491,10 @@ std::string ROOT::TMetaUtils::GetFileName(const clang::Decl& decl,
 
 void ROOT::TMetaUtils::GetFullyQualifiedTypeName(std::string &typenamestr,
                                                  const clang::QualType &qtype,
-                                                 const clang::ASTContext &astContext)
+                                                 const clang::ASTContext &astContext,
+                                                 const clang::ClassTemplateSpecializationDecl *Spec /*= nullptr*/)
 {
-   std::string fqname = cling::utils::TypeName::GetFullyQualifiedName(qtype, astContext);
+   std::string fqname = cling::utils::TypeName::GetFullyQualifiedName(qtype, astContext, Spec);
    TClassEdit::TSplitType splitname(fqname.c_str(),
                                     (TClassEdit::EModType)(TClassEdit::kLong64 | TClassEdit::kDropStd | TClassEdit::kDropStlDefault | TClassEdit::kKeepOuterConst));
    splitname.ShortType(typenamestr,TClassEdit::kDropStd | TClassEdit::kDropStlDefault | TClassEdit::kKeepOuterConst);
@@ -3501,7 +3504,8 @@ void ROOT::TMetaUtils::GetFullyQualifiedTypeName(std::string &typenamestr,
 
 void ROOT::TMetaUtils::GetFullyQualifiedTypeName(std::string &typenamestr,
                                                  const clang::QualType &qtype,
-                                                 const cling::Interpreter &interpreter)
+                                                 const cling::Interpreter &interpreter,
+                                                 const clang::ClassTemplateSpecializationDecl *Spec /*= nullptr*/)
 {
    // We need this because GetFullyQualifiedTypeName is triggering deserialization
    // This calling the same name function GetFullyQualifiedTypeName, but this should stay here because
@@ -3510,7 +3514,8 @@ void ROOT::TMetaUtils::GetFullyQualifiedTypeName(std::string &typenamestr,
 
    GetFullyQualifiedTypeName(typenamestr,
                              qtype,
-                             interpreter.getCI()->getASTContext());
+                             interpreter.getCI()->getASTContext(),
+                             Spec);
 }
 
 ////////////////////////////////////////////////////////////////////////////////

core/dictgen/res/DictSelectionReader.h

@@ -260,25 +260,16 @@ class DictSelectionReader : public clang::RecursiveASTVisitor<DictSelectionReade
       std::unordered_set<std::string> fUnsplittableMembers {};
    };
 
-   inline bool
-   InSelectionNamespace(const clang::RecordDecl &,
-                        const std::string &str =
-                           ""); ///< Check if in the ROOT::Meta::Selection namespace
-   inline bool FirstPass(const clang::RecordDecl &); ///< First pass on the AST
-   inline bool SecondPass(const clang::RecordDecl &); ///< Second pass on the AST, using the information of the first one
-   inline void
-   ManageFields(const clang::RecordDecl &,
-                const std::string &,
-                ClassSelectionRule &,
-                bool); ///< Take care of the class fields
-   inline void
-   ManageBaseClasses(const clang::CXXRecordDecl &, const std::string &, bool &); ///< Take care of the class bases
+   bool InSelectionNamespace(const clang::RecordDecl &,
+                             const std::string &str = ""); ///< Check if in the ROOT::Meta::Selection namespace
+   bool FirstPass(const clang::RecordDecl &); ///< First pass on the AST
+   bool SecondPass(const clang::RecordDecl &); ///< Second pass on the AST, using the information of the first one
+   void ManageFields(const clang::RecordDecl &, const std::string &,
+                     ClassSelectionRule &, bool); ///< Take care of the class fields
+   void ManageBaseClasses(const clang::CXXRecordDecl &, const std::string &, bool &); ///< Take care of the class bases
    template <class T>
-   inline unsigned int ExtractTemplateArgValue(
-      const T &,
-      const std::string &); ///< Extract the value of the template parameter
-   inline const clang::TemplateArgumentList *GetTmplArgList(
-      const clang::CXXRecordDecl &); ///< Get the template arguments list if any
+   unsigned int ExtractTemplateArgValue(const T &, const std::string &); ///< Extract the value of the template parameter
+   const clang::TemplateArgumentList *GetTmplArgList(const clang::CXXRecordDecl &); ///< Get the template arguments list if any
 
    std::string PatternifyName(const std::string &className); ///< Transform instance name in pattern for selection
    void GetPointeeType(std::string &typeName); ///< Get name of the pointee type

core/dictgen/src/DictSelectionReader.cxx

@@ -383,12 +383,27 @@ bool DictSelectionReader::SecondPass(const clang::RecordDecl &recordDecl)
 
 bool DictSelectionReader::VisitRecordDecl(clang::RecordDecl *recordDecl)
 {
+   if (auto CXXRD = llvm::dyn_cast<clang::CXXRecordDecl>(recordDecl)) {
+      if (CXXRD->getDescribedClassTemplate()) {
+         // this is a member of a template; ignore: dictionaries can only
+         // select instances / specializations.
+         return true;
+      }
+   }
+   if (auto CXXRD = llvm::dyn_cast<clang::CXXRecordDecl>(recordDecl->getDeclContext())) {
+      if (CXXRD->getDescribedClassTemplate()) {
+         // this is a member of a template; ignore: dictionaries can only
+         // select instances / specializations.
+         return true;
+      }
+   }
    if (fIsFirstPass)
       return FirstPass(*recordDecl);
    else
       return SecondPass(*recordDecl);
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
 
 /**

core/meta/src/TClass.cxx

@@ -698,7 +698,7 @@ void TDumpMembers::Inspect(TClass *cl, const char *pname, const char *mname, con
             }
          }
          if (isPrintable) {
-            strncpy(line + kvalue, *ppointer, std::min( i, kline - kvalue));
+            strncpy(line + kvalue, *ppointer, kline - kvalue);
             line[kvalue+i] = 0;
          } else {
             line[kvalue] = 0;

core/metacling/src/TClingDataMemberInfo.cxx

@@ -36,6 +36,7 @@ from the Clang C++ compiler, not CINT.
 #include "clang/AST/Attr.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
@@ -586,7 +587,8 @@ const char *TClingDataMemberInfo::TypeName() const
    // if (we_need_to_do_the_subst_because_the_class_is_a_template_instance_of_double32_t)
    vdType = ROOT::TMetaUtils::ReSubstTemplateArg(vdType, GetClassAsType() );
 
-   ROOT::TMetaUtils::GetFullyQualifiedTypeName(buf, vdType, *fInterp);
+   auto CTSD = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(vd->getDeclContext());
+   ROOT::TMetaUtils::GetFullyQualifiedTypeName(buf, vdType, *fInterp, CTSD);
 
    return buf.c_str();
 }

core/metacling/src/TClingMethodArgInfo.cxx

@@ -29,6 +29,7 @@ the Clang C++ compiler, not CINT.
 #include "cling/Interpreter/Interpreter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyPrinter.h"
@@ -148,6 +149,10 @@ const char *TClingMethodArgInfo::TypeName() const
    if (!IsValid()) {
       return nullptr;
    }
-   return Type()->Name();
+
+   const clang::ClassTemplateSpecializationDecl *spec = nullptr;
+   if (const auto FD = llvm::cast_or_null<clang::FunctionDecl>(TClingDeclInfo::GetDecl()))
+      spec = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(FD->getDeclContext());
+   return Type()->Name(spec);
 }
 

core/metacling/src/TClingMethodInfo.cxx

@@ -634,7 +634,9 @@ const char *TClingMethodInfo::GetPrototype()
    if (const clang::TypeDecl *td = llvm::dyn_cast<clang::TypeDecl>(GetDecl()->getDeclContext())) {
       std::string name;
       clang::QualType qualType(td->getTypeForDecl(),0);
-      ROOT::TMetaUtils::GetFullyQualifiedTypeName(name,qualType,*fInterp);
+      const clang::ClassTemplateSpecializationDecl *spec
+         = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(td);
+      ROOT::TMetaUtils::GetFullyQualifiedTypeName(name, qualType, *fInterp, spec);
       buf += name;
       buf += "::";
    } else if (const clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(FD->getDeclContext())) {
@@ -688,9 +690,17 @@ const char *TClingMethodInfo::TypeName() const
    // The next *two* calls lock the interpreter mutex. Lock here first instead
    // of locking/unlocking twice.
    R__LOCKGUARD(gInterpreterMutex);
-   return Type()->Name();
+   const clang::ClassTemplateSpecializationDecl *spec
+      = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(GetDecl()->getDeclContext());
+   return Type()->Name(spec);
 }
 
+std::string TClingMethodInfo::NormalizedName(ROOT::TMetaUtils::TNormalizedCtxt &ctx) const
+{
+   return Type()->NormalizedName(ctx);
+}
+
+
 const char *TClingMethodInfo::Title()
 {
    if (!IsValid()) {

core/metacling/src/TClingMethodInfo.h

@@ -165,6 +165,7 @@ class TClingMethodInfo final : public TClingDeclInfo {
    const char                                  *GetPrototype();
    const char                                  *Name() const override;
    const char                                  *TypeName() const;
+   std::string                                  NormalizedName(ROOT::TMetaUtils::TNormalizedCtxt &ctx) const;
    const char                                  *Title();
 };
 

core/metacling/src/TClingTypeInfo.cxx

@@ -33,6 +33,7 @@ but the type metadata comes from the Clang C++ compiler, not CINT.
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/Frontend/CompilerInstance.h"
@@ -97,7 +98,7 @@ void TClingTypeInfo::Init(const char *name)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-const char *TClingTypeInfo::Name() const
+const char *TClingTypeInfo::Name(const clang::ClassTemplateSpecializationDecl *spec) const
 {
    if (!IsValid()) {
       return "";
@@ -109,7 +110,7 @@ const char *TClingTypeInfo::Name() const
    // TODO: This needs to be locked, but the lock cannot be placed in TClingUtils.cxx as it cannot depend from
    // TInterpreter.h for the declaration of gInterpreterMutex. Or can it?
    R__LOCKGUARD(gInterpreterMutex);
-   ROOT::TMetaUtils::GetFullyQualifiedTypeName(buf,fQualType,*fInterp);
+   ROOT::TMetaUtils::GetFullyQualifiedTypeName(buf,fQualType,*fInterp, spec);
    return buf.c_str();  // NOLINT
 }
 

core/metacling/src/TClingTypeInfo.h

@@ -30,6 +30,10 @@
 
 #include "clang/AST/Type.h"
 
+namespace clang {
+   class ClassTemplateSpecializationDecl;
+}
+
 namespace cling {
 class Interpreter;
 }
@@ -65,7 +69,8 @@ class TClingTypeInfo final : public TClingDeclInfo {
    void                 Init(const char *name); // Set type by name.
    void                 Init(clang::QualType ty) { fQualType = ty; }
    bool                 IsValid() const override { return !fQualType.isNull(); }
-   const char          *Name() const override; // Get name of type.
+   const char          *Name() const override { return Name(nullptr); }
+   const char          *Name(const clang::ClassTemplateSpecializationDecl *spec) const; // Get name of type.
    long                 Property() const; // Get properties of type.
    int                  RefType() const; // Get CINT reftype of type.
    int                  Size() const; // Get size in bytes of type.