issue #11111 Overloaded functions are mixed when their arguments have template with object in other namespace

doxygen · doxygen · commit 8386ff0b7f80 · 2024-12-28T21:09:26.000+01:00
diff --git a/src/classdef.cpp b/src/classdef.cpp
@@ -303,6 +303,7 @@ class ClassDefImpl : public DefinitionMixin<ClassDefMutable>
     void setTemplateMaster(const ClassDef *tm) override;
     void setImplicitTemplateInstance(bool b) override;
     void setTypeConstraints(const ArgumentList &al) override;
+    void addMemberToTemplateInstance(const MemberDef *md, const ArgumentList &templateArguments, const QCString &templSpec) override;
     void addMembersToTemplateInstance(const ClassDef *cd,const ArgumentList &templateArguments,const QCString &templSpec) override;
     void makeTemplateArgument(bool b=TRUE) override;
     void setCategoryOf(ClassDef *cd) override;
@@ -1308,6 +1309,20 @@ void ClassDefImpl::internalInsertMember(MemberDef *md,
     MemberNameInfo *mni = m_allMemberNameInfoLinkedMap.add(md->name());
     mni->push_back(std::make_unique<MemberInfo>(md,prot,md->virtualness(),false,false));
   }
+
+  // if we already created template instances before inserting this member (i.e. due to a typedef or using statement)
+  // then we also need to insert the member in the template instance.
+  for (const auto &ti : getTemplateInstances())
+  {
+    //printf("member %s of class %s with template instance %s\n",qPrint(md->name()),qPrint(name()),
+    //    qPrint(ti.templSpec));
+    ClassDefMutable *cdm = toClassDefMutable(ti.classDef);
+    if (cdm)
+    {
+      cdm->addMemberToTemplateInstance(md,templateArguments(),ti.templSpec);
+    }
+  }
+
 }
 
 void ClassDefImpl::insertMember(MemberDef *md)
@@ -4285,6 +4300,8 @@ ClassDef *ClassDefImpl::insertTemplateInstance(const QCString &fileName,
     if (templateClass)
     {
       templateClass->setTemplateMaster(this);
+      ArgumentList tal = *stringToArgumentList(getLanguage(),templSpec);
+      templateClass->setTemplateArguments(tal);
       templateClass->setOuterScope(getOuterScope());
       templateClass->setHidden(isHidden());
       templateClass->setArtificial(isArtificial());
@@ -4330,34 +4347,40 @@ const TemplateNameMap &ClassDefImpl::getTemplateBaseClassNames() const
   return m_templBaseClassNames;
 }
 
+void ClassDefImpl::addMemberToTemplateInstance(const MemberDef *md,
+                                               const ArgumentList &templateArguments,
+                                               const QCString &templSpec)
+{
+  auto actualArguments_p = stringToArgumentList(getLanguage(),templSpec);
+  auto imd = md->createTemplateInstanceMember(templateArguments,actualArguments_p);
+  //printf("%s->setMemberClass(%p)\n",qPrint(imd->name()),this);
+  auto mmd = toMemberDefMutable(imd.get());
+  mmd->setMemberClass(this);
+  mmd->setTemplateMaster(md);
+  mmd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
+  mmd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
+  mmd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
+  mmd->setMemberSpecifiers(md->getMemberSpecifiers());
+  mmd->setMemberGroupId(md->getMemberGroupId());
+  mmd->setArtificial(true);
+  insertMember(imd.get());
+  //printf("Adding member=%s %s%s to class %s templSpec %s\n",
+  //    imd->typeString(),qPrint(imd->name()),imd->argsString(),
+  //    qPrint(imd->getClassDef()->name()),templSpec);
+  // insert imd in the list of all members
+  //printf("Adding member=%s class=%s\n",qPrint(imd->name()),qPrint(name()));
+  MemberName *mn = Doxygen::memberNameLinkedMap->add(imd->name());
+  mn->push_back(std::move(imd));
+}
+
 void ClassDefImpl::addMembersToTemplateInstance(const ClassDef *cd,const ArgumentList &templateArguments,const QCString &templSpec)
 {
   //printf("%s::addMembersToTemplateInstance(%s,%s)\n",qPrint(name()),qPrint(cd->name()),templSpec);
   for (const auto &mni : cd->memberNameInfoLinkedMap())
   {
     for (const auto &mi : *mni)
     {
-      auto actualArguments_p = stringToArgumentList(getLanguage(),templSpec);
-      MemberDef *md = mi->memberDef();
-      auto imd = md->createTemplateInstanceMember(templateArguments,actualArguments_p);
-      //printf("%s->setMemberClass(%p)\n",qPrint(imd->name()),this);
-      auto mmd = toMemberDefMutable(imd.get());
-      mmd->setMemberClass(this);
-      mmd->setTemplateMaster(md);
-      mmd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
-      mmd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
-      mmd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
-      mmd->setMemberSpecifiers(md->getMemberSpecifiers());
-      mmd->setMemberGroupId(md->getMemberGroupId());
-      mmd->setArtificial(true);
-      insertMember(imd.get());
-      //printf("Adding member=%s %s%s to class %s templSpec %s\n",
-      //    imd->typeString(),qPrint(imd->name()),imd->argsString(),
-      //    qPrint(imd->getClassDef()->name()),templSpec);
-      // insert imd in the list of all members
-      //printf("Adding member=%s class=%s\n",qPrint(imd->name()),qPrint(name()));
-      MemberName *mn = Doxygen::memberNameLinkedMap->add(imd->name());
-      mn->push_back(std::move(imd));
+      addMemberToTemplateInstance(mi->memberDef(),templateArguments,templSpec);
     }
   }
   // also instantatie members for nested classes
diff --git a/src/classdef.h b/src/classdef.h
@@ -422,6 +422,7 @@ class ClassDefMutable : public DefinitionMutable, public ClassDef
     virtual void insertExplicitTemplateInstance(ClassDef *instance,const QCString &spec) = 0;
     virtual void insertMember(MemberDef *) = 0;
     virtual void insertUsedFile(const FileDef *) = 0;
+    virtual void addMemberToTemplateInstance(const MemberDef *md, const ArgumentList &templateArguments, const QCString &templSpec) = 0;
     virtual void addMembersToTemplateInstance(const ClassDef *cd,const ArgumentList &templateArguments,const QCString &templSpec) = 0;
     virtual bool addExample(const QCString &anchor,const QCString &name, const QCString &file) = 0;
     virtual void addUsedClass(ClassDef *cd,const QCString &accessName,Protection prot) = 0;
diff --git a/src/doxygen.cpp b/src/doxygen.cpp
@@ -4747,8 +4747,6 @@ static void findTemplateInstanceRelation(const Entry *root,
 
 static void resolveTemplateInstanceInType(const Entry *root,const Definition *scope,const MemberDef *md)
 {
-  return; // disabled due to regression, need to find a better solutions
-
   // For a statement like 'using X = T<A>', add a template instance 'T<A>' as a symbol, so it can
   // be used to match arguments (see issue #11111)
   AUTO_TRACE();
@@ -5906,11 +5904,14 @@ static bool isSpecialization(
 static bool scopeIsTemplate(const Definition *d)
 {
   bool result=FALSE;
+  //printf("> scopeIsTemplate(%s)\n",qPrint(d?d->name():"null"));
   if (d && d->definitionType()==Definition::TypeClass)
   {
-    result = !(toClassDef(d))->templateArguments().empty() ||
+    auto cd = toClassDef(d);
+    result = cd->templateArguments().hasParameters() || cd->templateMaster()!=nullptr ||
              scopeIsTemplate(d->getOuterScope());
   }
+  //printf("< scopeIsTemplate=%d\n",result);
   return result;
 }
 
@@ -6246,6 +6247,7 @@ static void addMemberFunction(const Entry *root,
       }
       else if (defTemplArgs.size()>declTemplArgs.size())
       {
+        AUTO_TRACE_ADD("Different number of template arguments {} vs {}",defTemplArgs.size(),declTemplArgs.size());
         // avoid matching a non-template function in a template class against a
         // template function with the same name and parameters, see issue #10184
         substDone = false;
diff --git a/src/memberdef.cpp b/src/memberdef.cpp
@@ -309,7 +309,7 @@ class MemberDefImpl : public DefinitionMixin<MemberDefMutable>
     void overrideReferencesRelation(bool e) override;
     void overrideEnumValues(bool e) override;
     void overrideInlineSource(bool e) override;
-    void setTemplateMaster(MemberDef *mt) override;
+    void setTemplateMaster(const MemberDef *mt) override;
     void setFormalTemplateArguments(const ArgumentList &al) override;
     void addListReference(Definition *d) override;
     void setDocsForDefinition(bool b) override;
@@ -442,7 +442,7 @@ class MemberDefImpl : public DefinitionMixin<MemberDefMutable>
 
     ArgumentList m_tArgList;      // template argument list of function template
     ArgumentList m_typeConstraints; // type constraints for template parameters
-    MemberDef *m_templateMaster = nullptr;
+    const MemberDef *m_templateMaster = nullptr;
     std::optional<ArgumentList> m_formalTemplateArguments;
     ArgumentLists m_defTmpArgLists; // lists of template argument lists
                                          // (for template functions in nested template classes)
@@ -1571,7 +1571,7 @@ void MemberDefImpl::insertReimplementedBy(MemberDef *md)
 {
   if (m_templateMaster)
   {
-    MemberDefMutable *mdm = toMemberDefMutable(m_templateMaster);
+    MemberDefMutable *mdm = toMemberDefMutable(const_cast<MemberDef *>(m_templateMaster));
     if (mdm)
     {
       mdm->insertReimplementedBy(md);
@@ -5961,7 +5961,7 @@ MemberDef *MemberDefImpl::fromAnonymousMember() const
   return m_annMemb;
 }
 
-void MemberDefImpl::setTemplateMaster(MemberDef *mt)
+void MemberDefImpl::setTemplateMaster(const MemberDef *mt)
 {
   m_templateMaster=mt;
   m_isLinkableCached = 0;
diff --git a/src/memberdef.h b/src/memberdef.h
@@ -383,7 +383,7 @@ class MemberDefMutable : public DefinitionMutable, public MemberDef
     virtual void overrideInlineSource(bool e) = 0;
     virtual void overrideEnumValues(bool e) = 0;
 
-    virtual void setTemplateMaster(MemberDef *mt) = 0;
+    virtual void setTemplateMaster(const MemberDef *mt) = 0;
     virtual void setFormalTemplateArguments(const ArgumentList &al) = 0;
     virtual void addListReference(Definition *d) = 0;
     virtual void setDocsForDefinition(bool b) = 0;
diff --git a/src/util.cpp b/src/util.cpp
@@ -4933,8 +4933,13 @@ QCString stripTemplateSpecifiersFromScope(const QCString &fullName,
  */
 QCString mergeScopes(const QCString &leftScope,const QCString &rightScope)
 {
+  AUTO_TRACE("leftScope='{}' rightScope='{}'",leftScope,rightScope);
   // case leftScope=="A" rightScope=="A::B" => result = "A::B"
-  if (leftScopeMatch(rightScope,leftScope)) return rightScope;
+  if (leftScopeMatch(leftScope,rightScope))
+  {
+    AUTO_TRACE_EXIT("case1={}",rightScope);
+    return rightScope;
+  }
   QCString result;
   int i=0,p=static_cast<int>(leftScope.length());
 
@@ -4950,12 +4955,17 @@ QCString mergeScopes(const QCString &leftScope,const QCString &rightScope)
     }
     p=i-1;
   }
-  if (found) return result;
+  if (found)
+  {
+    AUTO_TRACE_EXIT("case2={}",result);
+    return result;
+  }
 
   // case leftScope=="A" rightScope=="B" => result = "A::B"
   result=leftScope;
   if (!result.isEmpty() && !rightScope.isEmpty()) result+="::";
   result+=rightScope;
+  AUTO_TRACE_EXIT("case3={}",result);
   return result;
 }
 
diff --git a/testing/105/namespacebb.xml b/testing/105/namespacebb.xml
@@ -0,0 +1,177 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="" xml:lang="en-US">
+  <compounddef id="namespacebb" kind="namespace" language="C++">
+    <compoundname>bb</compoundname>
+    <innerclass refid="structbb_1_1_template_struct" prot="public">bb::TemplateStruct</innerclass>
+    <sectiondef kind="typedef">
+      <memberdef kind="typedef" id="namespacebb_1a44bdf7017e8db36d4d0cd7df9247dd59" prot="public" static="no">
+        <type>
+          <ref refid="structaa_1_1_struct1" kindref="compound">aa::Struct1</ref>
+        </type>
+        <definition>using bb::Struct1 =  aa::Struct1</definition>
+        <argsstring/>
+        <name>Struct1</name>
+        <qualifiedname>bb::Struct1</qualifiedname>
+        <briefdescription>
+          <para>alias of Structt1 in bb </para>
+        </briefdescription>
+        <detaileddescription>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="68" column="2" bodyfile="105_using.cpp" bodystart="68" bodyend="-1"/>
+      </memberdef>
+      <memberdef kind="typedef" id="namespacebb_1acc028b753c5b8d09f24d933a1a7ae5cd" prot="public" static="no">
+        <type>
+          <ref refid="structaa_1_1_struct2" kindref="compound">aa::Struct2</ref>
+        </type>
+        <definition>using bb::Struct2 =  aa::Struct2</definition>
+        <argsstring/>
+        <name>Struct2</name>
+        <qualifiedname>bb::Struct2</qualifiedname>
+        <briefdescription>
+          <para>alias of Structt2 in bb </para>
+        </briefdescription>
+        <detaileddescription>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="73" column="2" bodyfile="105_using.cpp" bodystart="73" bodyend="-1"/>
+      </memberdef>
+      <memberdef kind="typedef" id="namespacebb_1a4b10384eab1514f579b7651c9c4a8564" prot="public" static="no">
+        <type><ref refid="structbb_1_1_template_struct" kindref="compound">TemplateStruct</ref>&lt; <ref refid="structaa_1_1_struct1" kindref="compound">aa::Struct1</ref> &gt;</type>
+        <definition>using bb::Struct1Type =  TemplateStruct&lt;aa::Struct1&gt;</definition>
+        <argsstring/>
+        <name>Struct1Type</name>
+        <qualifiedname>bb::Struct1Type</qualifiedname>
+        <briefdescription>
+          <para><ref refid="namespacebb_1a4b10384eab1514f579b7651c9c4a8564" kindref="member">Struct1Type</ref>. </para>
+        </briefdescription>
+        <detaileddescription>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="78" column="2" bodyfile="105_using.cpp" bodystart="78" bodyend="-1"/>
+      </memberdef>
+      <memberdef kind="typedef" id="namespacebb_1afdccfa9acfdee82110ae0d64e7c664fc" prot="public" static="no">
+        <type><ref refid="structbb_1_1_template_struct" kindref="compound">TemplateStruct</ref>&lt; <ref refid="structaa_1_1_struct2" kindref="compound">aa::Struct2</ref> &gt;</type>
+        <definition>using bb::Struct2Type =  TemplateStruct&lt;aa::Struct2&gt;</definition>
+        <argsstring/>
+        <name>Struct2Type</name>
+        <qualifiedname>bb::Struct2Type</qualifiedname>
+        <briefdescription>
+          <para><ref refid="namespacebb_1afdccfa9acfdee82110ae0d64e7c664fc" kindref="member">Struct2Type</ref>. </para>
+        </briefdescription>
+        <detaileddescription>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="83" column="2" bodyfile="105_using.cpp" bodystart="83" bodyend="-1"/>
+      </memberdef>
+    </sectiondef>
+    <sectiondef kind="func">
+      <memberdef kind="function" id="namespacebb_1a9018bac0330702c2a15bc96c7713637d" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
+        <type>int</type>
+        <definition>int bb::FunctionExample</definition>
+        <argsstring>(Struct1Type arg1, int arg2)</argsstring>
+        <name>FunctionExample</name>
+        <qualifiedname>bb::FunctionExample</qualifiedname>
+        <param>
+          <type>
+            <ref refid="namespacebb_1a4b10384eab1514f579b7651c9c4a8564" kindref="member">Struct1Type</ref>
+          </type>
+          <declname>arg1</declname>
+        </param>
+        <param>
+          <type>int</type>
+          <declname>arg2</declname>
+        </param>
+        <briefdescription>
+          <para>FunctionExample (overload 1) </para>
+        </briefdescription>
+        <detaileddescription>
+          <para>
+            <parameterlist kind="param">
+              <parameteritem>
+                <parameternamelist>
+                  <parametername direction="out">arg1</parametername>
+                </parameternamelist>
+                <parameterdescription>
+                  <para><ref refid="namespacebb_1a4b10384eab1514f579b7651c9c4a8564" kindref="member">Struct1Type</ref> argument </para>
+                </parameterdescription>
+              </parameteritem>
+              <parameteritem>
+                <parameternamelist>
+                  <parametername direction="in">arg2</parametername>
+                </parameternamelist>
+                <parameterdescription>
+                  <para>int argument</para>
+                </parameterdescription>
+              </parameteritem>
+            </parameterlist>
+            <simplesect kind="return">
+              <para>return value </para>
+            </simplesect>
+          </para>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="93" column="5" declfile="105_using.cpp" declline="93" declcolumn="5"/>
+      </memberdef>
+      <memberdef kind="function" id="namespacebb_1ada96dde7cf2ee341fc1a2c197de4ccf3" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
+        <type>int</type>
+        <definition>int bb::FunctionExample</definition>
+        <argsstring>(Struct2Type arg1, int arg2)</argsstring>
+        <name>FunctionExample</name>
+        <qualifiedname>bb::FunctionExample</qualifiedname>
+        <param>
+          <type>
+            <ref refid="namespacebb_1afdccfa9acfdee82110ae0d64e7c664fc" kindref="member">Struct2Type</ref>
+          </type>
+          <declname>arg1</declname>
+        </param>
+        <param>
+          <type>int</type>
+          <declname>arg2</declname>
+        </param>
+        <briefdescription>
+          <para>FunctionExample (overload 2) </para>
+        </briefdescription>
+        <detaileddescription>
+          <para>
+            <parameterlist kind="param">
+              <parameteritem>
+                <parameternamelist>
+                  <parametername direction="out">arg1</parametername>
+                </parameternamelist>
+                <parameterdescription>
+                  <para><ref refid="namespacebb_1afdccfa9acfdee82110ae0d64e7c664fc" kindref="member">Struct2Type</ref> argument </para>
+                </parameterdescription>
+              </parameteritem>
+              <parameteritem>
+                <parameternamelist>
+                  <parametername direction="in">arg2</parametername>
+                </parameternamelist>
+                <parameterdescription>
+                  <para>int argument</para>
+                </parameterdescription>
+              </parameteritem>
+            </parameterlist>
+            <simplesect kind="return">
+              <para>return value </para>
+            </simplesect>
+          </para>
+        </detaileddescription>
+        <inbodydescription>
+        </inbodydescription>
+        <location file="105_using.cpp" line="103" column="5" declfile="105_using.cpp" declline="103" declcolumn="5"/>
+      </memberdef>
+    </sectiondef>
+    <briefdescription>
+      <para>namespace bb </para>
+    </briefdescription>
+    <detaileddescription>
+    </detaileddescription>
+    <location file="105_using.cpp" line="54" column="1"/>
+  </compounddef>
+</doxygen>
diff --git a/testing/105/namespaceitpp.xml b/testing/105/namespaceitpp.xml
diff --git a/testing/105_using.cpp b/testing/105_using.cpp

Original file line number	Diff line number	Diff line change
`@@ -4747,8 +4747,6 @@ static void findTemplateInstanceRelation(const Entry *root,`
`4747`	`4747`
`4748`	`4748`	`static void resolveTemplateInstanceInType(const Entry root,const Definition scope,const MemberDef *md)`
`4749`	`4749`	`{`
`4750`		`- return; // disabled due to regression, need to find a better solutions`
`4751`		`-`
`4752`	`4750`	`// For a statement like 'using X = T<A>', add a template instance 'T<A>' as a symbol, so it can`
`4753`	`4751`	`// be used to match arguments (see issue #11111)`
`4754`	`4752`	`AUTO_TRACE();`
`@@ -5906,11 +5904,14 @@ static bool isSpecialization(`
`5906`	`5904`	`static bool scopeIsTemplate(const Definition *d)`
`5907`	`5905`	`{`
`5908`	`5906`	`bool result=FALSE;`
	`5907`	`+ //printf("> scopeIsTemplate(%s)\n",qPrint(d?d->name():"null"));`
`5909`	`5908`	`if (d && d->definitionType()==Definition::TypeClass)`
`5910`	`5909`	`{`
`5911`		`- result = !(toClassDef(d))->templateArguments().empty() \|\|`
	`5910`	`+ auto cd = toClassDef(d);`
	`5911`	`+ result = cd->templateArguments().hasParameters() \|\| cd->templateMaster()!=nullptr \|\|`
`5912`	`5912`	`scopeIsTemplate(d->getOuterScope());`
`5913`	`5913`	`}`
	`5914`	`+ //printf("< scopeIsTemplate=%d\n",result);`
`5914`	`5915`	`return result;`
`5915`	`5916`	`}`
`5916`	`5917`
`@@ -6246,6 +6247,7 @@ static void addMemberFunction(const Entry *root,`
`6246`	`6247`	`}`
`6247`	`6248`	`else if (defTemplArgs.size()>declTemplArgs.size())`
`6248`	`6249`	`{`
	`6250`	`+ AUTO_TRACE_ADD("Different number of template arguments {} vs {}",defTemplArgs.size(),declTemplArgs.size());`
`6249`	`6251`	`// avoid matching a non-template function in a template class against a`
`6250`	`6252`	`// template function with the same name and parameters, see issue #10184`
`6251`	`6253`	`substDone = false;`