Reused parameters between functions and their types (as Clang does).

Signed-off-by: Dimitar Dobrev <[email protected]>

Author: ddobrev

src/CppParser/Parser.cpp

@@ -2889,10 +2889,16 @@ static clang::TypeLoc DesugarTypeLoc(const clang::TypeLoc& Loc)
 Parameter* Parser::WalkParameter(const clang::ParmVarDecl* PVD,
     const clang::SourceLocation& ParamStartLoc)
 {
-    auto P = new Parameter();
+    using namespace clang;
+
+    auto P = walkedParameters[PVD];
+    if (P)
+        return P;
+
+    P = new Parameter();
     P->name = PVD->getNameAsString();
 
-    clang::TypeLoc PTL;
+    TypeLoc PTL;
     if (auto TSI = PVD->getTypeSourceInfo())
         PTL = PVD->getTypeSourceInfo()->getTypeLoc();
 
@@ -2912,6 +2918,9 @@ Parameter* Parser::WalkParameter(const clang::ParmVarDecl* PVD,
             P->defaultArgument = WalkExpression(PVD->getDefaultArg());
     }
     HandleDeclaration(PVD, P);
+    walkedParameters[PVD] = P;
+    auto Context = cast<Decl>(PVD->getDeclContext());
+    P->_namespace = static_cast<DeclarationContext*>(WalkDeclaration(Context));
 
     return P;
 }
@@ -3028,7 +3037,6 @@ void Parser::WalkFunction(const clang::FunctionDecl* FD, Function* F,
     for (const auto& VD : FD->parameters())
     {
         auto P = WalkParameter(VD, ParamStartLoc);
-        P->_namespace = F;
         F->Parameters.push_back(P);
 
         ParamStartLoc = VD->getLocEnd();
@@ -3093,11 +3101,11 @@ Function* Parser::WalkFunction(const clang::FunctionDecl* FD, bool IsDependent,
     F = new Function();
     HandleDeclaration(FD, F);
 
-    WalkFunction(FD, F, IsDependent);
-
     if (AddToNamespace)
         NS->Functions.push_back(F);
 
+    WalkFunction(FD, F, IsDependent);
+
     return F;
 }
 
@@ -3746,6 +3754,11 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D)
         Decl = Existing;
         break;
     }
+    case Decl::TranslationUnit:
+    {
+        Decl = GetTranslationUnit(D);
+        break;
+    }
     case Decl::Namespace:
     {
         auto ND = cast<NamespaceDecl>(D);

src/CppParser/Parser.h

@@ -162,6 +162,7 @@ class Parser
     std::unordered_map<const clang::TemplateTypeParmDecl*, TypeTemplateParameter*> walkedTypeTemplateParameters;
     std::unordered_map<const clang::TemplateTemplateParmDecl*, TemplateTemplateParameter*> walkedTemplateTemplateParameters;
     std::unordered_map<const clang::NonTypeTemplateParmDecl*, NonTypeTemplateParameter*> walkedNonTypeTemplateParameters;
+    std::unordered_map<const clang::ParmVarDecl*, Parameter*> walkedParameters;
     std::unordered_set<std::string> supportedStdTypes;
 };
 

src/Generator.Tests/AST/TestAST.cs

@@ -500,8 +500,9 @@ public void TestFunctionSpecifications()
         [Test]
         public void TestFunctionSpecializationInfo()
         {
-            var functionWithSpecInfo = AstContext.FindFunction(
-                "functionWithSpecInfo").First(f => !f.IsDependent);
+            var functionWithSpecInfo = AstContext.TranslationUnits.Find(
+                t => t.IsValid && t.FileName == "AST.h").Functions.First(
+                f => f.Name == "functionWithSpecInfo" && !f.IsDependent);
             var @float = new QualifiedType(new BuiltinType(PrimitiveType.Float));
             Assert.That(functionWithSpecInfo.SpecializationInfo.Arguments.Count, Is.EqualTo(2));
             foreach (var arg in functionWithSpecInfo.SpecializationInfo.Arguments)

src/Generator/Generators/CLI/CLITypeReferences.cs

@@ -114,7 +114,7 @@ private void GenerateInclude(ASTRecord<Declaration> record)
 
             var translationUnit = decl.Namespace.TranslationUnit;
 
-            if (translationUnit.IsSystemHeader)
+            if (translationUnit.IsSystemHeader || !translationUnit.IsValid)
                 return;
 
             if (!decl.IsGenerated)