Move the GenerateInclude logic to GetTypeReference (mono#1319)

Improve generation of forward references and includes in C++/CLI.

Move the GenerateInclude logic to GetTypeReference so that an include is also generated for visited types of an ASTRecord that are forward declared, and come from typedef of ignored class template.

Co-authored-by: Build Agent <[email protected]>

Author: IIFE

build/Tests.lua

@@ -31,10 +31,10 @@ function SetupTestCSharp(name)
   SetupTestProjectsCSharp(name)
 end
 
-function SetupTestCLI(name)
+function SetupTestCLI(name, extraFiles, suffix)
   SetupTestGeneratorProject(name)
   SetupTestNativeProject(name)
-  SetupTestProjectsCLI(name)
+  SetupTestProjectsCLI(name, extraFiles, suffix)
 end
 
 function SetupManagedTestProject()

src/Generator/Generators/CLI/CLITypeReferences.cs

@@ -48,10 +48,25 @@ public CLITypeReference GetTypeReference(Declaration decl)
             if (typeReferences.ContainsKey(decl))
                 return typeReferences[decl];
 
-            var @ref = new CLITypeReference { Declaration = decl };
-            typeReferences.Add(decl, @ref);
+            var translationUnit = decl.Namespace.TranslationUnit;
+
+            if (ShouldIncludeTranslationUnit(translationUnit) && decl.IsGenerated && !IsBuiltinTypedef(decl))
+            {
+                var @ref = new CLITypeReference { Declaration = decl };
+
+                @ref.Include = new CInclude
+                {
+                    File = GetIncludePath(translationUnit),
+                    TranslationUnit = translationUnit,
+                    Kind = translationUnit.IsGenerated ? CInclude.IncludeKind.Quoted : CInclude.IncludeKind.Angled
+                };
 
-            return @ref;
+                typeReferences.Add(decl, @ref);
+
+                return @ref;
+            }
+
+            return null;
         }
 
         static Namespace GetEffectiveNamespace(Declaration decl)
@@ -104,39 +119,27 @@ private void GenerateInclude(ASTRecord<Declaration> record)
             if (decl.Namespace == null)
                 return;
 
+            var typedefType = record.Value as TypedefNameDecl;
+
             // Find a type map for the declaration and use it if it exists.
             TypeMap typeMap;
-            if (TypeMapDatabase.FindTypeMap(record.Value, out typeMap))
+            if (TypeMapDatabase.FindTypeMap(record.Value, out typeMap) 
+                || (typedefType != null && TypeMapDatabase.FindTypeMap(typedefType.Type.Desugar(), out typeMap)))
             {
                 typeMap.CLITypeReference(this, record);
                 return;
             }
 
-            var translationUnit = decl.Namespace.TranslationUnit;
-
-            if (translationUnit.IsSystemHeader || !translationUnit.IsValid)
-                return;
-
-            if (!decl.IsGenerated)
-                return;
-
-            if (IsBuiltinTypedef(decl))
-                return;
-
             var typeRef = GetTypeReference(decl);
-            if (typeRef.Include.TranslationUnit == null)
+            if(typeRef != null)
             {
-                typeRef.Include = new CInclude
-                {
-                    File = GetIncludePath(translationUnit),
-                    TranslationUnit = translationUnit,
-                    Kind = translationUnit.IsGenerated
-                            ? CInclude.IncludeKind.Quoted
-                            : CInclude.IncludeKind.Angled,
-                };
+                typeRef.Include.InHeader |= IsIncludeInHeader(record);
             }
+        }
 
-            typeRef.Include.InHeader |= IsIncludeInHeader(record);
+        private bool ShouldIncludeTranslationUnit(TranslationUnit unit)
+        {
+            return !unit.IsSystemHeader && unit.IsValid && !unit.Ignore;
         }
 
         private string GetIncludePath(TranslationUnit translationUnit)
@@ -168,7 +171,7 @@ private bool IsBuiltinTypedef(Declaration decl)
             return typedefType.Declaration.Type is BuiltinType;
         }
 
-        private bool IsIncludeInHeader(ASTRecord<Declaration> record)
+        public bool IsIncludeInHeader(ASTRecord<Declaration> record)
         {
             if (TranslationUnit == record.Value.Namespace.TranslationUnit)
                 return false;
@@ -198,7 +201,12 @@ public override bool VisitClassDecl(Class @class)
 
             var @ref = $"{keywords} {@class.Name};";
 
-            GetTypeReference(@class).FowardReference = @ref;
+            var typeRef = GetTypeReference(@class);
+
+            if (typeRef != null)
+            {
+                typeRef.FowardReference = @ref;
+            }
 
             return false;
         }
@@ -217,7 +225,12 @@ public override bool VisitEnumDecl(Enumeration @enum)
 
             var @ref = $"{enumKind} {@enum.Name}{@base};";
 
-            GetTypeReference(@enum).FowardReference = @ref;
+            var typeRef = GetTypeReference(@enum);
+
+            if (typeRef != null)
+            {
+                typeRef.FowardReference = @ref;
+            }
 
             return false;
         }

src/Generator/Types/Std/Stdlib.cs

@@ -690,13 +690,16 @@ public override void CLITypeReference(CLITypeReferenceCollector collector,
         {
             var typeRef = collector.GetTypeReference(loc.Value);
 
-            var include = new CInclude
+            if (typeRef != null)
             {
-                File = "cstddef",
-                Kind = CInclude.IncludeKind.Angled,
-            };
+                var include = new CInclude
+                {
+                    File = "cstddef",
+                    Kind = CInclude.IncludeKind.Angled,
+                };
 
-            typeRef.Include = include;
+                typeRef.Include = include;
+            }
         }
     }
 

tests/CLI/CLI.Tests.cs

@@ -26,4 +26,13 @@ public void TestByRefEnumParam()
             Assert.AreEqual(EnumParam.E1, byRefEnumParam.GetPassedEnumParam(EnumParam.E1));
         }
     }
+
+    [Test]
+    public void GetEmployeeNameFromOrgTest()
+    {
+        using (EmployeeOrg org = new EmployeeOrg())
+        {
+            Assert.AreEqual("Employee", org.Employee.Name);
+        }
+    }
 }

tests/CLI/CLI.cs

@@ -1,9 +1,58 @@
 using CppSharp.AST;
+using CppSharp.AST.Extensions;
 using CppSharp.Generators;
+using CppSharp.Passes;
+using CppSharp.Types;
 using CppSharp.Utils;
 
 namespace CppSharp.Tests
 {
+    [TypeMap("IgnoredClassTemplateForEmployee")]
+    public class IgnoredClassTemplateForEmployeeMap : TypeMap
+    {
+        public override Type CLISignatureType(TypePrinterContext ctx)
+        {
+            return new CustomType("CLI::Employee^");
+        }
+
+        public override void CLIMarshalToManaged(MarshalContext ctx)
+        {
+            ctx.Return.Write($"gcnew CLI::Employee({ctx.ReturnVarName}.m_employee)");
+        }
+    }
+
+    public class CompleteIgnoredClassTemplateForEmployeeTypedefPass : TranslationUnitPass
+    {
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
+        {
+            var templateType = GetDesugaredFinalPointeeElseType(typedef?.Type?.Desugar()) as TemplateSpecializationType;
+            bool isTemplateTypedef = IsTemplateTypedef(templateType?.Template?.OriginalName);
+            if (isTemplateTypedef)
+            {
+                Class @class;
+                if (templateType.TryGetClass(out @class))
+                {
+                    @class.IsIncomplete = false;
+                    return true;
+                }
+            }
+
+            return base.VisitTypedefDecl(typedef);
+        }
+
+        private bool IsTemplateTypedef(string templateName)
+        {
+            return !string.IsNullOrEmpty(templateName) && "IgnoredClassTemplateForEmployee" == templateName;
+        }
+
+        public Type GetDesugaredFinalPointeeElseType(Type t)
+        {
+            Type finalPointee = t.GetFinalPointee();
+
+            return finalPointee != null ? finalPointee.Desugar() : t;
+        }
+    }
+
     public class CLITestsGenerator : GeneratorTest
     {
         public CLITestsGenerator(GeneratorKind kind)
@@ -22,6 +71,11 @@ public override void Preprocess(Driver driver, ASTContext ctx)
         {
         }
 
+        public override void SetupPasses(Driver driver)
+        {
+            driver.AddTranslationUnitPass(new CompleteIgnoredClassTemplateForEmployeeTypedefPass());
+        }
+
         public static void Main(string[] args)
         {
             ConsoleDriver.Run(new CLITestsGenerator(GeneratorKind.CLI));

tests/CLI/CLI.h

@@ -1,5 +1,8 @@
 #include "../Tests.h"
 
+#include "UseTemplateTypeFromIgnoredClassTemplate/Employee.h"
+#include "UseTemplateTypeFromIgnoredClassTemplate/EmployeeOrg.h"
+
 #include <ostream>
 
 // Tests for C++ types

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/Employee.cpp

@@ -0,0 +1,6 @@
+#include "Employee.h"
+
+std::string Employee::GetName()
+{
+    return "Employee";
+}

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/Employee.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "../../Tests.h"
+#include <string>
+
+class DLL_API Employee
+{
+public:
+    virtual std::string GetName();
+};

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/EmployeeForwardDecl.h

@@ -0,0 +1,4 @@
+#include "IgnoredClassTemplateForEmployee.h"
+
+class Employee;
+typedef IgnoredClassTemplateForEmployee<Employee> EmployeeTypedef;

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/EmployeeOrg.cpp

@@ -0,0 +1,13 @@
+ #include "EmployeeOrg.h"
+
+#include "Employee.h"
+
+EmployeeTypedef EmployeeOrg::GetEmployee()
+{
+    return IgnoredClassTemplateForEmployee<Employee>(new Employee());
+}
+
+void EmployeeOrg::DoSomething()
+{
+
+}

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/EmployeeOrg.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../../Tests.h"
+
+#include "EmployeeForwardDecl.h"
+
+class DLL_API EmployeeOrg
+{
+public:
+    void DoSomething();
+
+    EmployeeTypedef GetEmployee();
+};

tests/CLI/UseTemplateTypeFromIgnoredClassTemplate/IgnoredClassTemplateForEmployee.h

@@ -0,0 +1,13 @@
+#pragma once
+
+template<typename EmployeeT>
+class IgnoredClassTemplateForEmployee
+{
+public:
+    IgnoredClassTemplateForEmployee<EmployeeT>(EmployeeT* employee)
+        : m_employee(employee)
+    {       
+    }
+
+    EmployeeT* m_employee;
+};

tests/CLI/premake4.lua

@@ -1,2 +1,2 @@
 group "Tests/CLI"
-  SetupTestCLI("CLI")
+  SetupTestCLI("CLI", { "Employee", "EmployeeOrg" })