issue #6382: computational time issue of Java generics

doxygen · doxygen · commit 53fcef6dfa28 · 2022-01-22T16:36:51.000+01:00
- Java doesn't have typedefs, so doxygen should not try to resolve them.
diff --git a/src/classdef.cpp b/src/classdef.cpp
@@ -3472,7 +3472,7 @@ void ClassDefImpl::mergeMembers()
                   found=matchArguments2(
                       srcMd->getOuterScope(),srcMd->getFileDef(),&srcAl,
                       dstMd->getOuterScope(),dstMd->getFileDef(),&dstAl,
-                      TRUE
+                      TRUE,getLanguage()
                       );
                   //printf("  Yes, matching (%s<->%s): %d\n",
                   //    qPrint(argListToString(srcMd->argumentList())),
diff --git a/src/doxygen.cpp b/src/doxygen.cpp
@@ -3649,7 +3649,7 @@ static void buildFunctionList(const Entry *root)
               if (
                   matchArguments2(md->getOuterScope(),mfd,&mdAl,
                     rnd ? rnd : Doxygen::globalScope,rfd,&root->argList,
-                    FALSE) &&
+                    FALSE,root->lang) &&
                   sameNumTemplateArgs &&
                   matchingReturnTypes &&
                   sameRequiresClause &&
@@ -3816,7 +3816,7 @@ static void findFriends()
               (mmd->isFriend() || (mmd->isRelated() && mmd->isFunction())) &&
               matchArguments2(mmd->getOuterScope(), mmd->getFileDef(), &mmd->argumentList(),
                               fmd->getOuterScope(), fmd->getFileDef(), &fmd->argumentList(),
-                              TRUE
+                              TRUE,mmd->getLanguage()
                              )
 
              ) // if the member is related and the arguments match then the
@@ -3946,7 +3946,7 @@ static void transferFunctionReferences()
       if (
           matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),const_cast<ArgumentList*>(&mdefAl),
                           mdec->getOuterScope(),mdec->getFileDef(),const_cast<ArgumentList*>(&mdecAl),
-                          TRUE
+                          TRUE,mdef->getLanguage()
             )
          ) /* match found */
       {
@@ -3988,7 +3988,7 @@ static void transferRelatedFunctionDocumentation()
                 (rmd->isRelated() || rmd->isForeign()) && // related function
                 matchArguments2( md->getOuterScope(), md->getFileDef(), &md->argumentList(),
                   rmd->getOuterScope(),rmd->getFileDef(),&rmd->argumentList(),
-                  TRUE
+                  TRUE,md->getLanguage()
                   )
                )
             {
@@ -4096,7 +4096,7 @@ static void findUsedClassesForClass(const Entry *root,
       {
         //printf("    Found variable %s in class %s\n",qPrint(md->name()),qPrint(masterCd->name()));
         QCString type = normalizeNonTemplateArgumentsInString(md->typeString(),masterCd,formalArgs);
-        QCString typedefValue = resolveTypeDef(masterCd,type);
+        QCString typedefValue = md->getLanguage()==SrcLangExt_Java ? type : resolveTypeDef(masterCd,type);
         if (!typedefValue.isEmpty())
         {
           type = typedefValue;
@@ -4640,9 +4640,6 @@ static bool findClassRelation(
           }
         }
         bool isATemplateArgument = templateNames.find(biName.str())!=templateNames.end();
-        // make templSpec canonical
-        // warning: the following line doesn't work for Mixin classes (see bug 560623)
-        // templSpec = getCanonicalTemplateSpec(cd, cd->getFileDef(), templSpec);
 
         //printf("4. found=%d\n",found);
         if (found)
@@ -5180,7 +5177,7 @@ static void addMemberDocs(const Entry *root,
     if (
           matchArguments2( md->getOuterScope(), md->getFileDef(),const_cast<ArgumentList*>(&mdAl),
                            rscope,rfd,&root->argList,
-                           TRUE
+                           TRUE, root->lang
                          )
        )
     {
@@ -5411,7 +5408,7 @@ static bool findGlobalMember(const Entry *root,
           md->isVariable() || md->isTypedef() || /* in case of function pointers */
           matchArguments2(md->getOuterScope(),const_cast<const MemberDef *>(md.get())->getFileDef(),&mdAl,
                           rnd ? rnd : Doxygen::globalScope,fd,&root->argList,
-                          FALSE);
+                          FALSE,root->lang);
 
         // for template members we need to check if the number of
         // template arguments is the same, otherwise we are dealing with
@@ -5841,7 +5838,7 @@ static void addMemberFunction(const Entry *root,
         matchArguments2(
             md->getClassDef(),md->getFileDef(),&argList,
             cd,fd,&root->argList,
-            TRUE);
+            TRUE,root->lang);
 
       if (md->getLanguage()==SrcLangExt_ObjC && md->isVariable() && (root->section&Entry::FUNCTION_SEC))
       {
@@ -6622,7 +6619,7 @@ static void findMember(const Entry *root,
                 className!=rmd->getOuterScope()->name() ||
                 !matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,
                     cd,fd,&root->argList,
-                    TRUE);
+                    TRUE,root->lang);
               if (!newMember)
               {
                 rmd_found = rmd;
@@ -6721,7 +6718,7 @@ static void findMember(const Entry *root,
                   if (
                       matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,
                         cd,fd,&root->argList,
-                        TRUE)
+                        TRUE,root->lang)
                      )
                   {
                     found=TRUE;
@@ -7874,7 +7871,7 @@ static void computeMemberRelations()
                     bmd->getLanguage()==SrcLangExt_Python ||
                     matchArguments2(bmd->getOuterScope(),bmd->getFileDef(),&bmdAl,
                       md->getOuterScope(), md->getFileDef(), &mdAl,
-                      TRUE
+                      TRUE,bmd->getLanguage()
                       )
                    )
                 {
diff --git a/src/groupdef.cpp b/src/groupdef.cpp
@@ -344,7 +344,7 @@ bool GroupDefImpl::insertMember(const MemberDef *md,bool docOnly)
         (tSrcMdAl.size()==tMdAl.size()) &&       // same number of template arguments
         matchArguments2(srcMd->getOuterScope(),srcMd->getFileDef(),&srcMdAl,
                         md->getOuterScope(),md->getFileDef(),&mdAl,
-                        TRUE
+                        TRUE,srcMd->getLanguage()
                        ) && // matching parameters
         sameScope // both are found in the same scope
        )
diff --git a/src/memberdef.cpp b/src/memberdef.cpp
@@ -5843,7 +5843,7 @@ void combineDeclarationAndDefinition(MemberDefMutable *mdec,MemberDefMutable *md
     if (sameNumTemplateArgs &&
         matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),&mdefAl,
                         mdec->getOuterScope(),mdec->getFileDef(),&mdecAl,
-                        TRUE
+                        TRUE,mdef->getLanguage()
                        )
        ) /* match found */
     {
diff --git a/src/util.cpp b/src/util.cpp
@@ -1589,19 +1589,19 @@ static QCString stripDeclKeywords(const QCString &s)
 }
 
 // forward decl for circular dependencies
-static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCString type);
+static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCString type,SrcLangExt lang);
 
-QCString getCanonicalTemplateSpec(const Definition *d,const FileDef *fs,const QCString& spec)
+static QCString getCanonicalTemplateSpec(const Definition *d,const FileDef *fs,const QCString& spec,SrcLangExt lang)
 {
 
   QCString templSpec = spec.stripWhiteSpace();
   // this part had been commented out before... but it is needed to match for instance
   // std::list<std::string> against list<string> so it is now back again!
   if (!templSpec.isEmpty() && templSpec.at(0) == '<')
   {
-    templSpec = "< " + extractCanonicalType(d,fs,templSpec.right(templSpec.length()-1).stripWhiteSpace());
+    templSpec = "< " + extractCanonicalType(d,fs,templSpec.right(templSpec.length()-1).stripWhiteSpace(),lang);
   }
-  QCString resolvedType = resolveTypeDef(d,templSpec);
+  QCString resolvedType = lang==SrcLangExt_Java ? templSpec : resolveTypeDef(d,templSpec);
   if (!resolvedType.isEmpty()) // not known as a typedef either
   {
     templSpec = resolvedType;
@@ -1612,14 +1612,14 @@ QCString getCanonicalTemplateSpec(const Definition *d,const FileDef *fs,const QC
 
 
 static QCString getCanonicalTypeForIdentifier(
-    const Definition *d,const FileDef *fs,const QCString &word,
+    const Definition *d,const FileDef *fs,const QCString &word,SrcLangExt lang,
     QCString *tSpec,int count=0)
 {
   if (count>10) return word; // oops recursion
 
   QCString symName,result,templSpec,tmpName;
   if (tSpec && !tSpec->isEmpty())
-    templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,*tSpec));
+    templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,*tSpec,lang));
 
   if (word.findRev("::")!=-1 && !(tmpName=stripScope(word)).isEmpty())
   {
@@ -1691,7 +1691,7 @@ static QCString getCanonicalTypeForIdentifier(
       else if (!ts.isEmpty() && templSpec.isEmpty())
       {
         // use formal template args for spec
-        templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,ts));
+        templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,ts,lang));
       }
 
       result = removeRedundantWhiteSpace(cd->qualifiedName() + templSpec);
@@ -1734,7 +1734,7 @@ static QCString getCanonicalTypeForIdentifier(
         type.stripPrefix("typename ");
         type = stripTemplateSpecifiersFromScope(type,FALSE);
       }
-      result = getCanonicalTypeForIdentifier(d,fs,type,tSpec,count+1);
+      result = getCanonicalTypeForIdentifier(d,fs,type,mType->getLanguage(),tSpec,count+1);
     }
     else
     {
@@ -1743,7 +1743,7 @@ static QCString getCanonicalTypeForIdentifier(
   }
   else // fallback
   {
-    resolvedType = resolveTypeDef(d,word);
+    resolvedType = lang==SrcLangExt_Java ? word : resolveTypeDef(d,word);
     //printf("typedef [%s]->[%s]\n",qPrint(word),qPrint(resolvedType));
     if (resolvedType.isEmpty()) // not known as a typedef either
     {
@@ -1758,7 +1758,7 @@ static QCString getCanonicalTypeForIdentifier(
   return result;
 }
 
-static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCString type)
+static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCString type,SrcLangExt lang)
 {
   type = type.stripWhiteSpace();
 
@@ -1785,7 +1785,7 @@ static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCStr
     //printf("     i=%d p=%d\n",i,p);
     if (i>pp) canType += type.mid(pp,i-pp);
 
-    QCString ct = getCanonicalTypeForIdentifier(d,fs,word,&templSpec);
+    QCString ct = getCanonicalTypeForIdentifier(d,fs,word,lang,&templSpec);
 
     // in case the ct is empty it means that "word" represents scope "d"
     // and this does not need to be added to the canonical
@@ -1819,7 +1819,7 @@ static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCStr
         size_t tl = match.length();
         std::string matchStr = match.str();
         canType += ts.substr(tp,ti-tp);
-        canType += getCanonicalTypeForIdentifier(d,fs,matchStr.c_str(),0);
+        canType += getCanonicalTypeForIdentifier(d,fs,matchStr.c_str(),lang,0);
         tp=ti+tl;
       }
       canType+=ts.substr(tp);
@@ -1833,7 +1833,7 @@ static QCString extractCanonicalType(const Definition *d,const FileDef *fs,QCStr
   return removeRedundantWhiteSpace(canType);
 }
 
-static QCString extractCanonicalArgType(const Definition *d,const FileDef *fs,const Argument &arg)
+static QCString extractCanonicalArgType(const Definition *d,const FileDef *fs,const Argument &arg,SrcLangExt lang)
 {
   QCString type = arg.type.stripWhiteSpace();
   QCString name = arg.name;
@@ -1853,12 +1853,13 @@ static QCString extractCanonicalArgType(const Definition *d,const FileDef *fs,co
     type+=arg.array;
   }
 
-  return extractCanonicalType(d,fs,type);
+  return extractCanonicalType(d,fs,type,lang);
 }
 
 static bool matchArgument2(
     const Definition *srcScope,const FileDef *srcFileScope,Argument &srcA,
-    const Definition *dstScope,const FileDef *dstFileScope,Argument &dstA
+    const Definition *dstScope,const FileDef *dstFileScope,Argument &dstA,
+    SrcLangExt lang
     )
 {
   //printf(">> match argument: %s::'%s|%s' (%s) <-> %s::'%s|%s' (%s)\n",
@@ -1896,8 +1897,8 @@ static bool matchArgument2(
   if (srcA.canType.isEmpty() || dstA.canType.isEmpty())
   {
     // need to re-evaluate both see issue #8370
-    srcA.canType = extractCanonicalArgType(srcScope,srcFileScope,srcA);
-    dstA.canType = extractCanonicalArgType(dstScope,dstFileScope,dstA);
+    srcA.canType = extractCanonicalArgType(srcScope,srcFileScope,srcA,lang);
+    dstA.canType = extractCanonicalArgType(dstScope,dstFileScope,dstA,lang);
   }
 
   if (srcA.canType==dstA.canType)
@@ -1917,8 +1918,8 @@ static bool matchArgument2(
 
 // new algorithm for argument matching
 bool matchArguments2(const Definition *srcScope,const FileDef *srcFileScope,const ArgumentList *srcAl,
-                     const Definition *dstScope,const FileDef *dstFileScope,const ArgumentList *dstAl,
-                     bool checkCV)
+                               const Definition *dstScope,const FileDef *dstFileScope,const ArgumentList *dstAl,
+                               bool checkCV,SrcLangExt lang)
 {
   ASSERT(srcScope!=0 && dstScope!=0);
 
@@ -1990,7 +1991,8 @@ bool matchArguments2(const Definition *srcScope,const FileDef *srcFileScope,cons
     Argument &srcA = const_cast<Argument&>(*srcIt);
     Argument &dstA = const_cast<Argument&>(*dstIt);
     if (!matchArgument2(srcScope,srcFileScope,srcA,
-          dstScope,dstFileScope,dstA)
+                        dstScope,dstFileScope,dstA,
+                        lang)
        )
     {
       NOMATCH
@@ -2002,7 +2004,6 @@ bool matchArguments2(const Definition *srcScope,const FileDef *srcFileScope,cons
 }
 
 
-
 // merges the initializer of two argument lists
 // pre:  the types of the arguments in the list should match.
 void mergeArguments(ArgumentList &srcAl,ArgumentList &dstAl,bool forceNameOverwrite)
@@ -2172,7 +2173,7 @@ static void findMembersWithSpecificName(const MemberName *mn,
         match=matchArguments2(
             md->getOuterScope(),fd,&mdAl,
             Doxygen::globalScope,fd,argList_p.get(),
-            checkCV);
+            checkCV,md->getLanguage());
       }
       if (match)
       {
@@ -2310,7 +2311,7 @@ bool getDefs(const QCString &scName,
             bool match = args.isEmpty() ||
               matchArguments2(mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,
                              fcd,                  fcd->getFileDef(),argList.get(),
-                             checkCV);
+                             checkCV,mmd->getLanguage());
             //printf("match=%d\n",match);
             if (match)
             {
@@ -2433,9 +2434,8 @@ bool getDefs(const QCString &scName,
 
       const ArgumentList &mmdAl = mmd->argumentList();
       if (matchArguments2(mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,
-            Doxygen::globalScope,mmd->getFileDef(),argList.get(),
-            checkCV
-            )
+                          Doxygen::globalScope,mmd->getFileDef(),argList.get(),
+                          checkCV,mmd->getLanguage())
          )
       {
         fuzzy_mmd = mmd;
@@ -2520,7 +2520,7 @@ bool getDefs(const QCString &scName,
               match=matchArguments2(
                   mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,
                   fnd,mmd->getFileDef(),argList_p.get(),
-                  checkCV);
+                  checkCV,mmd->getLanguage());
             }
             if (match)
             {
diff --git a/src/util.h b/src/util.h
@@ -145,11 +145,11 @@ void generateFileRef(OutputDocInterface &od,const QCString &,
 
 void writePageRef(OutputDocInterface &od,const QCString &cn,const QCString &mn);
 
-QCString getCanonicalTemplateSpec(const Definition *d,const FileDef *fs,const QCString& spec);
+//QCString getCanonicalTemplateSpec(const Definition *d,const FileDef *fs,const QCString& spec);
 
 bool matchArguments2(const Definition *srcScope,const FileDef *srcFileScope,const ArgumentList *srcAl,
                      const Definition *dstScope,const FileDef *dstFileScope,const ArgumentList *dstAl,
-                     bool checkCV
+                     bool checkCV,SrcLangExt lang
                     );
 
 void mergeArguments(ArgumentList &,ArgumentList &,bool forceNameOverwrite=FALSE);

Original file line number	Diff line number	Diff line change
`@@ -3649,7 +3649,7 @@ static void buildFunctionList(const Entry *root)`
`3649`	`3649`	`if (`
`3650`	`3650`	`matchArguments2(md->getOuterScope(),mfd,&mdAl,`
`3651`	`3651`	`rnd ? rnd : Doxygen::globalScope,rfd,&root->argList,`
`3652`		`- FALSE) &&`
	`3652`	`+ FALSE,root->lang) &&`
`3653`	`3653`	`sameNumTemplateArgs &&`
`3654`	`3654`	`matchingReturnTypes &&`
`3655`	`3655`	`sameRequiresClause &&`
`@@ -3816,7 +3816,7 @@ static void findFriends()`
`3816`	`3816`	`(mmd->isFriend() \|\| (mmd->isRelated() && mmd->isFunction())) &&`
`3817`	`3817`	`matchArguments2(mmd->getOuterScope(), mmd->getFileDef(), &mmd->argumentList(),`
`3818`	`3818`	`fmd->getOuterScope(), fmd->getFileDef(), &fmd->argumentList(),`
`3819`		`- TRUE`
	`3819`	`+ TRUE,mmd->getLanguage()`
`3820`	`3820`	`)`
`3821`	`3821`
`3822`	`3822`	`) // if the member is related and the arguments match then the`
`@@ -3946,7 +3946,7 @@ static void transferFunctionReferences()`
`3946`	`3946`	`if (`
`3947`	`3947`	`matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),const_cast<ArgumentList*>(&mdefAl),`
`3948`	`3948`	`mdec->getOuterScope(),mdec->getFileDef(),const_cast<ArgumentList*>(&mdecAl),`
`3949`		`- TRUE`
	`3949`	`+ TRUE,mdef->getLanguage()`
`3950`	`3950`	`)`
`3951`	`3951`	`) /* match found */`
`3952`	`3952`	`{`
`@@ -3988,7 +3988,7 @@ static void transferRelatedFunctionDocumentation()`
`3988`	`3988`	`(rmd->isRelated() \|\| rmd->isForeign()) && // related function`
`3989`	`3989`	`matchArguments2( md->getOuterScope(), md->getFileDef(), &md->argumentList(),`
`3990`	`3990`	`rmd->getOuterScope(),rmd->getFileDef(),&rmd->argumentList(),`
`3991`		`- TRUE`
	`3991`	`+ TRUE,md->getLanguage()`
`3992`	`3992`	`)`
`3993`	`3993`	`)`
`3994`	`3994`	`{`
`@@ -4096,7 +4096,7 @@ static void findUsedClassesForClass(const Entry *root,`
`4096`	`4096`	`{`
`4097`	`4097`	`//printf(" Found variable %s in class %s\n",qPrint(md->name()),qPrint(masterCd->name()));`
`4098`	`4098`	`QCString type = normalizeNonTemplateArgumentsInString(md->typeString(),masterCd,formalArgs);`
`4099`		`- QCString typedefValue = resolveTypeDef(masterCd,type);`
	`4099`	`+ QCString typedefValue = md->getLanguage()==SrcLangExt_Java ? type : resolveTypeDef(masterCd,type);`
`4100`	`4100`	`if (!typedefValue.isEmpty())`
`4101`	`4101`	`{`
`4102`	`4102`	`type = typedefValue;`
`@@ -4640,9 +4640,6 @@ static bool findClassRelation(`
`4640`	`4640`	`}`
`4641`	`4641`	`}`
`4642`	`4642`	`bool isATemplateArgument = templateNames.find(biName.str())!=templateNames.end();`
`4643`		`- // make templSpec canonical`
`4644`		`- // warning: the following line doesn't work for Mixin classes (see bug 560623)`
`4645`		`- // templSpec = getCanonicalTemplateSpec(cd, cd->getFileDef(), templSpec);`
`4646`	`4643`
`4647`	`4644`	`//printf("4. found=%d\n",found);`
`4648`	`4645`	`if (found)`
`@@ -5180,7 +5177,7 @@ static void addMemberDocs(const Entry *root,`
`5180`	`5177`	`if (`
`5181`	`5178`	`matchArguments2( md->getOuterScope(), md->getFileDef(),const_cast<ArgumentList*>(&mdAl),`
`5182`	`5179`	`rscope,rfd,&root->argList,`
`5183`		`- TRUE`
	`5180`	`+ TRUE, root->lang`
`5184`	`5181`	`)`
`5185`	`5182`	`)`
`5186`	`5183`	`{`
`@@ -5411,7 +5408,7 @@ static bool findGlobalMember(const Entry *root,`
`5411`	`5408`	`md->isVariable() \|\| md->isTypedef() \|\| /* in case of function pointers */`
`5412`	`5409`	`matchArguments2(md->getOuterScope(),const_cast<const MemberDef *>(md.get())->getFileDef(),&mdAl,`
`5413`	`5410`	`rnd ? rnd : Doxygen::globalScope,fd,&root->argList,`
`5414`		`- FALSE);`
	`5411`	`+ FALSE,root->lang);`
`5415`	`5412`
`5416`	`5413`	`// for template members we need to check if the number of`
`5417`	`5414`	`// template arguments is the same, otherwise we are dealing with`
`@@ -5841,7 +5838,7 @@ static void addMemberFunction(const Entry *root,`
`5841`	`5838`	`matchArguments2(`
`5842`	`5839`	`md->getClassDef(),md->getFileDef(),&argList,`
`5843`	`5840`	`cd,fd,&root->argList,`
`5844`		`- TRUE);`
	`5841`	`+ TRUE,root->lang);`
`5845`	`5842`
`5846`	`5843`	`if (md->getLanguage()==SrcLangExt_ObjC && md->isVariable() && (root->section&Entry::FUNCTION_SEC))`
`5847`	`5844`	`{`
`@@ -6622,7 +6619,7 @@ static void findMember(const Entry *root,`
`6622`	`6619`	`className!=rmd->getOuterScope()->name() \|\|`
`6623`	`6620`	`!matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,`
`6624`	`6621`	`cd,fd,&root->argList,`
`6625`		`- TRUE);`
	`6622`	`+ TRUE,root->lang);`
`6626`	`6623`	`if (!newMember)`
`6627`	`6624`	`{`
`6628`	`6625`	`rmd_found = rmd;`
`@@ -6721,7 +6718,7 @@ static void findMember(const Entry *root,`
`6721`	`6718`	`if (`
`6722`	`6719`	`matchArguments2(rmd->getOuterScope(),rmd->getFileDef(),&rmdAl,`
`6723`	`6720`	`cd,fd,&root->argList,`
`6724`		`- TRUE)`
	`6721`	`+ TRUE,root->lang)`
`6725`	`6722`	`)`
`6726`	`6723`	`{`
`6727`	`6724`	`found=TRUE;`
`@@ -7874,7 +7871,7 @@ static void computeMemberRelations()`
`7874`	`7871`	`bmd->getLanguage()==SrcLangExt_Python \|\|`
`7875`	`7872`	`matchArguments2(bmd->getOuterScope(),bmd->getFileDef(),&bmdAl,`
`7876`	`7873`	`md->getOuterScope(), md->getFileDef(), &mdAl,`
`7877`		`- TRUE`
	`7874`	`+ TRUE,bmd->getLanguage()`
`7878`	`7875`	`)`
`7879`	`7876`	`)`
`7880`	`7877`	`{`
Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,7 @@ bool GroupDefImpl::insertMember(const MemberDef *md,bool docOnly)`
`344`	`344`	`(tSrcMdAl.size()==tMdAl.size()) && // same number of template arguments`
`345`	`345`	`matchArguments2(srcMd->getOuterScope(),srcMd->getFileDef(),&srcMdAl,`
`346`	`346`	`md->getOuterScope(),md->getFileDef(),&mdAl,`
`347`		`- TRUE`
	`347`	`+ TRUE,srcMd->getLanguage()`
`348`	`348`	`) && // matching parameters`
`349`	`349`	`sameScope // both are found in the same scope`
`350`	`350`	`)`
Original file line number	Diff line number	Diff line change
`@@ -5843,7 +5843,7 @@ void combineDeclarationAndDefinition(MemberDefMutable mdec,MemberDefMutable md`
`5843`	`5843`	`if (sameNumTemplateArgs &&`
`5844`	`5844`	`matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),&mdefAl,`
`5845`	`5845`	`mdec->getOuterScope(),mdec->getFileDef(),&mdecAl,`
`5846`		`- TRUE`
	`5846`	`+ TRUE,mdef->getLanguage()`
`5847`	`5847`	`)`
`5848`	`5848`	`) /* match found */`
`5849`	`5849`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1589,19 +1589,19 @@ static QCString stripDeclKeywords(const QCString &s)`
`1589`	`1589`	`}`
`1590`	`1590`
`1591`	`1591`	`// forward decl for circular dependencies`
`1592`		`-static QCString extractCanonicalType(const Definition d,const FileDef fs,QCString type);`
	`1592`	`+static QCString extractCanonicalType(const Definition d,const FileDef fs,QCString type,SrcLangExt lang);`
`1593`	`1593`
`1594`		`-QCString getCanonicalTemplateSpec(const Definition d,const FileDef fs,const QCString& spec)`
	`1594`	`+static QCString getCanonicalTemplateSpec(const Definition d,const FileDef fs,const QCString& spec,SrcLangExt lang)`
`1595`	`1595`	`{`
`1596`	`1596`
`1597`	`1597`	`QCString templSpec = spec.stripWhiteSpace();`
`1598`	`1598`	`// this part had been commented out before... but it is needed to match for instance`
`1599`	`1599`	`// std::list<std::string> against list<string> so it is now back again!`
`1600`	`1600`	`if (!templSpec.isEmpty() && templSpec.at(0) == '<')`
`1601`	`1601`	`{`
`1602`		`- templSpec = "< " + extractCanonicalType(d,fs,templSpec.right(templSpec.length()-1).stripWhiteSpace());`
	`1602`	`+ templSpec = "< " + extractCanonicalType(d,fs,templSpec.right(templSpec.length()-1).stripWhiteSpace(),lang);`
`1603`	`1603`	`}`
`1604`		`- QCString resolvedType = resolveTypeDef(d,templSpec);`
	`1604`	`+ QCString resolvedType = lang==SrcLangExt_Java ? templSpec : resolveTypeDef(d,templSpec);`
`1605`	`1605`	`if (!resolvedType.isEmpty()) // not known as a typedef either`
`1606`	`1606`	`{`
`1607`	`1607`	`templSpec = resolvedType;`
`@@ -1612,14 +1612,14 @@ QCString getCanonicalTemplateSpec(const Definition d,const FileDef fs,const QC`
`1612`	`1612`
`1613`	`1613`
`1614`	`1614`	`static QCString getCanonicalTypeForIdentifier(`
`1615`		`- const Definition d,const FileDef fs,const QCString &word,`
	`1615`	`+ const Definition d,const FileDef fs,const QCString &word,SrcLangExt lang,`
`1616`	`1616`	`QCString *tSpec,int count=0)`
`1617`	`1617`	`{`
`1618`	`1618`	`if (count>10) return word; // oops recursion`
`1619`	`1619`
`1620`	`1620`	`QCString symName,result,templSpec,tmpName;`
`1621`	`1621`	`if (tSpec && !tSpec->isEmpty())`
`1622`		`- templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,*tSpec));`
	`1622`	`+ templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,*tSpec,lang));`
`1623`	`1623`
`1624`	`1624`	`if (word.findRev("::")!=-1 && !(tmpName=stripScope(word)).isEmpty())`
`1625`	`1625`	`{`
`@@ -1691,7 +1691,7 @@ static QCString getCanonicalTypeForIdentifier(`
`1691`	`1691`	`else if (!ts.isEmpty() && templSpec.isEmpty())`
`1692`	`1692`	`{`
`1693`	`1693`	`// use formal template args for spec`
`1694`		`- templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,ts));`
	`1694`	`+ templSpec = stripDeclKeywords(getCanonicalTemplateSpec(d,fs,ts,lang));`
`1695`	`1695`	`}`
`1696`	`1696`
`1697`	`1697`	`result = removeRedundantWhiteSpace(cd->qualifiedName() + templSpec);`
`@@ -1734,7 +1734,7 @@ static QCString getCanonicalTypeForIdentifier(`
`1734`	`1734`	`type.stripPrefix("typename ");`
`1735`	`1735`	`type = stripTemplateSpecifiersFromScope(type,FALSE);`
`1736`	`1736`	`}`
`1737`		`- result = getCanonicalTypeForIdentifier(d,fs,type,tSpec,count+1);`
	`1737`	`+ result = getCanonicalTypeForIdentifier(d,fs,type,mType->getLanguage(),tSpec,count+1);`
`1738`	`1738`	`}`
`1739`	`1739`	`else`
`1740`	`1740`	`{`
`@@ -1743,7 +1743,7 @@ static QCString getCanonicalTypeForIdentifier(`
`1743`	`1743`	`}`
`1744`	`1744`	`else // fallback`
`1745`	`1745`	`{`
`1746`		`- resolvedType = resolveTypeDef(d,word);`
	`1746`	`+ resolvedType = lang==SrcLangExt_Java ? word : resolveTypeDef(d,word);`
`1747`	`1747`	`//printf("typedef [%s]->[%s]\n",qPrint(word),qPrint(resolvedType));`
`1748`	`1748`	`if (resolvedType.isEmpty()) // not known as a typedef either`
`1749`	`1749`	`{`
`@@ -1758,7 +1758,7 @@ static QCString getCanonicalTypeForIdentifier(`
`1758`	`1758`	`return result;`
`1759`	`1759`	`}`
`1760`	`1760`
`1761`		`-static QCString extractCanonicalType(const Definition d,const FileDef fs,QCString type)`
	`1761`	`+static QCString extractCanonicalType(const Definition d,const FileDef fs,QCString type,SrcLangExt lang)`
`1762`	`1762`	`{`
`1763`	`1763`	`type = type.stripWhiteSpace();`
`1764`	`1764`
`@@ -1785,7 +1785,7 @@ static QCString extractCanonicalType(const Definition d,const FileDef fs,QCStr`
`1785`	`1785`	`//printf(" i=%d p=%d\n",i,p);`
`1786`	`1786`	`if (i>pp) canType += type.mid(pp,i-pp);`
`1787`	`1787`
`1788`		`- QCString ct = getCanonicalTypeForIdentifier(d,fs,word,&templSpec);`
	`1788`	`+ QCString ct = getCanonicalTypeForIdentifier(d,fs,word,lang,&templSpec);`
`1789`	`1789`
`1790`	`1790`	`// in case the ct is empty it means that "word" represents scope "d"`
`1791`	`1791`	`// and this does not need to be added to the canonical`
`@@ -1819,7 +1819,7 @@ static QCString extractCanonicalType(const Definition d,const FileDef fs,QCStr`
`1819`	`1819`	`size_t tl = match.length();`
`1820`	`1820`	`std::string matchStr = match.str();`
`1821`	`1821`	`canType += ts.substr(tp,ti-tp);`
`1822`		`- canType += getCanonicalTypeForIdentifier(d,fs,matchStr.c_str(),0);`
	`1822`	`+ canType += getCanonicalTypeForIdentifier(d,fs,matchStr.c_str(),lang,0);`
`1823`	`1823`	`tp=ti+tl;`
`1824`	`1824`	`}`
`1825`	`1825`	`canType+=ts.substr(tp);`
`@@ -1833,7 +1833,7 @@ static QCString extractCanonicalType(const Definition d,const FileDef fs,QCStr`
`1833`	`1833`	`return removeRedundantWhiteSpace(canType);`
`1834`	`1834`	`}`
`1835`	`1835`
`1836`		`-static QCString extractCanonicalArgType(const Definition d,const FileDef fs,const Argument &arg)`
	`1836`	`+static QCString extractCanonicalArgType(const Definition d,const FileDef fs,const Argument &arg,SrcLangExt lang)`
`1837`	`1837`	`{`
`1838`	`1838`	`QCString type = arg.type.stripWhiteSpace();`
`1839`	`1839`	`QCString name = arg.name;`
`@@ -1853,12 +1853,13 @@ static QCString extractCanonicalArgType(const Definition d,const FileDef fs,co`
`1853`	`1853`	`type+=arg.array;`
`1854`	`1854`	`}`
`1855`	`1855`
`1856`		`- return extractCanonicalType(d,fs,type);`
	`1856`	`+ return extractCanonicalType(d,fs,type,lang);`
`1857`	`1857`	`}`
`1858`	`1858`
`1859`	`1859`	`static bool matchArgument2(`
`1860`	`1860`	`const Definition srcScope,const FileDef srcFileScope,Argument &srcA,`
`1861`		`- const Definition dstScope,const FileDef dstFileScope,Argument &dstA`
	`1861`	`+ const Definition dstScope,const FileDef dstFileScope,Argument &dstA,`
	`1862`	`+ SrcLangExt lang`
`1862`	`1863`	`)`
`1863`	`1864`	`{`
`1864`	`1865`	`//printf(">> match argument: %s::'%s\|%s' (%s) <-> %s::'%s\|%s' (%s)\n",`
`@@ -1896,8 +1897,8 @@ static bool matchArgument2(`
`1896`	`1897`	`if (srcA.canType.isEmpty() \|\| dstA.canType.isEmpty())`
`1897`	`1898`	`{`
`1898`	`1899`	`// need to re-evaluate both see issue #8370`
`1899`		`- srcA.canType = extractCanonicalArgType(srcScope,srcFileScope,srcA);`
`1900`		`- dstA.canType = extractCanonicalArgType(dstScope,dstFileScope,dstA);`
	`1900`	`+ srcA.canType = extractCanonicalArgType(srcScope,srcFileScope,srcA,lang);`
	`1901`	`+ dstA.canType = extractCanonicalArgType(dstScope,dstFileScope,dstA,lang);`
`1901`	`1902`	`}`
`1902`	`1903`
`1903`	`1904`	`if (srcA.canType==dstA.canType)`
`@@ -1917,8 +1918,8 @@ static bool matchArgument2(`
`1917`	`1918`
`1918`	`1919`	`// new algorithm for argument matching`
`1919`	`1920`	`bool matchArguments2(const Definition srcScope,const FileDef srcFileScope,const ArgumentList *srcAl,`
`1920`		`- const Definition dstScope,const FileDef dstFileScope,const ArgumentList *dstAl,`
`1921`		`- bool checkCV)`
	`1921`	`+ const Definition dstScope,const FileDef dstFileScope,const ArgumentList *dstAl,`
	`1922`	`+ bool checkCV,SrcLangExt lang)`
`1922`	`1923`	`{`
`1923`	`1924`	`ASSERT(srcScope!=0 && dstScope!=0);`
`1924`	`1925`
`@@ -1990,7 +1991,8 @@ bool matchArguments2(const Definition srcScope,const FileDef srcFileScope,cons`
`1990`	`1991`	`Argument &srcA = const_cast<Argument&>(*srcIt);`
`1991`	`1992`	`Argument &dstA = const_cast<Argument&>(*dstIt);`
`1992`	`1993`	`if (!matchArgument2(srcScope,srcFileScope,srcA,`
`1993`		`- dstScope,dstFileScope,dstA)`
	`1994`	`+ dstScope,dstFileScope,dstA,`
	`1995`	`+ lang)`
`1994`	`1996`	`)`
`1995`	`1997`	`{`
`1996`	`1998`	`NOMATCH`
`@@ -2002,7 +2004,6 @@ bool matchArguments2(const Definition srcScope,const FileDef srcFileScope,cons`
`2002`	`2004`	`}`
`2003`	`2005`
`2004`	`2006`
`2005`		`-`
`2006`	`2007`	`// merges the initializer of two argument lists`
`2007`	`2008`	`// pre: the types of the arguments in the list should match.`
`2008`	`2009`	`void mergeArguments(ArgumentList &srcAl,ArgumentList &dstAl,bool forceNameOverwrite)`
`@@ -2172,7 +2173,7 @@ static void findMembersWithSpecificName(const MemberName *mn,`
`2172`	`2173`	`match=matchArguments2(`
`2173`	`2174`	`md->getOuterScope(),fd,&mdAl,`
`2174`	`2175`	`Doxygen::globalScope,fd,argList_p.get(),`
`2175`		`- checkCV);`
	`2176`	`+ checkCV,md->getLanguage());`
`2176`	`2177`	`}`
`2177`	`2178`	`if (match)`
`2178`	`2179`	`{`
`@@ -2310,7 +2311,7 @@ bool getDefs(const QCString &scName,`
`2310`	`2311`	`bool match = args.isEmpty() \|\|`
`2311`	`2312`	`matchArguments2(mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,`
`2312`	`2313`	`fcd, fcd->getFileDef(),argList.get(),`
`2313`		`- checkCV);`
	`2314`	`+ checkCV,mmd->getLanguage());`
`2314`	`2315`	`//printf("match=%d\n",match);`
`2315`	`2316`	`if (match)`
`2316`	`2317`	`{`
`@@ -2433,9 +2434,8 @@ bool getDefs(const QCString &scName,`
`2433`	`2434`
`2434`	`2435`	`const ArgumentList &mmdAl = mmd->argumentList();`
`2435`	`2436`	`if (matchArguments2(mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,`
`2436`		`- Doxygen::globalScope,mmd->getFileDef(),argList.get(),`
`2437`		`- checkCV`
`2438`		`- )`
	`2437`	`+ Doxygen::globalScope,mmd->getFileDef(),argList.get(),`
	`2438`	`+ checkCV,mmd->getLanguage())`
`2439`	`2439`	`)`
`2440`	`2440`	`{`
`2441`	`2441`	`fuzzy_mmd = mmd;`
`@@ -2520,7 +2520,7 @@ bool getDefs(const QCString &scName,`
`2520`	`2520`	`match=matchArguments2(`
`2521`	`2521`	`mmd->getOuterScope(),mmd->getFileDef(),&mmdAl,`
`2522`	`2522`	`fnd,mmd->getFileDef(),argList_p.get(),`
`2523`		`- checkCV);`
	`2523`	`+ checkCV,mmd->getLanguage());`
`2524`	`2524`	`}`
`2525`	`2525`	`if (match)`
`2526`	`2526`	`{`