Extended the multiple inheritance to work for templates.

ddobrev · ddobrev · commit 52c754c4de61 · 2017-12-23T23:34:20.000+02:00
Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/src/Generator/Generators/CSharp/CSharpMarshal.cs b/src/Generator/Generators/CSharp/CSharpMarshal.cs
@@ -275,12 +275,13 @@ public override bool VisitTypedefType(TypedefType typedef, TypeQualifiers quals)
                 Context.Before.WriteLine($"var {ptrName} = {Context.ReturnVarName};");
 
                 var specialization = decl.Namespace as ClassTemplateSpecialization;
+                Type returnType = Context.ReturnType.Type.Desugar();
+                var finalType = (returnType.GetFinalPointee() ?? returnType).Desugar();
                 var res = string.Format(
                     "{0} == IntPtr.Zero? null : {1}({2}) Marshal.GetDelegateForFunctionPointer({0}, typeof({2}))",
                     ptrName,
-                    specialization == null ? string.Empty :
-                        $@"({specialization.TemplatedDecl.TemplatedClass.Typedefs.First(
-                            t => t.Name == decl.Name).Visit(this.typePrinter)}) (object) ",
+                    finalType.IsDependent ? $@"({specialization.TemplatedDecl.TemplatedClass.Typedefs.First(
+                        t => t.Name == decl.Name).Visit(this.typePrinter)}) (object) " : string.Empty,
                     typedef);
                 Context.Return.Write(res);
                 return true;
@@ -359,7 +360,10 @@ public override bool VisitParameterDecl(Parameter parameter)
 
         public override bool VisitTemplateParameterSubstitutionType(TemplateParameterSubstitutionType param, TypeQualifiers quals)
         {
-            Context.Return.Write($"({param.ReplacedParameter.Parameter.Name}) (object) ");
+            Type returnType = Context.ReturnType.Type.Desugar();
+            Type finalType = (returnType.GetFinalPointee() ?? returnType).Desugar();
+            if (finalType.IsDependent)
+                Context.Return.Write($"({param.ReplacedParameter.Parameter.Name}) (object) ");
             if (param.Replacement.Type.Desugar().IsPointerToPrimitiveType())
                 Context.Return.Write($"({CSharpTypePrinter.IntPtrType}) ");
             return base.VisitTemplateParameterSubstitutionType(param, quals);
diff --git a/src/Generator/Generators/CSharp/CSharpSources.cs b/src/Generator/Generators/CSharp/CSharpSources.cs
@@ -680,7 +680,7 @@ public override void GenerateClassSpecifier(Class @class)
 
             if (@class.NeedsBase)
             {
-                foreach (var @base in @class.Bases.Where(b => b.IsClass))
+                foreach (var @base in @class.Bases.Where(b => b.IsClass && b.Class.IsGenerated))
                 {
                     var typeMaps = new List<System.Type>();
                     var keys = new List<string>();
@@ -868,7 +868,7 @@ private void GenerateFunctionSetter(Class @class, Property property)
                 GenerateInternalFunctionCall(property.SetMethod, parameters, @void);
         }
 
-        private void GenerateFieldSetter(Field field, Class @class)
+        private void GenerateFieldSetter(Field field, Class @class, QualifiedType fieldType)
         {
             var param = new Parameter
             {
@@ -1153,7 +1153,7 @@ private static Property GetActualProperty(Property property, Class c)
                 p.GetMethod.InstantiatedFrom == property.GetMethod);
         }
 
-        private void GenerateFieldGetter(Field field, Class @class)
+        private void GenerateFieldGetter(Field field, Class @class, QualifiedType returnType)
         {
             var name = @class.Layout.Fields.First(f => f.FieldPtr == field.OriginalPtr).Name;
             var ctx = new CSharpMarshalContext(Context)
@@ -1163,7 +1163,7 @@ private void GenerateFieldGetter(Field field, Class @class)
                 ReturnVarName = $@"{(@class.IsValueType ? Helpers.InstanceField :
                     $"(({TypePrinter.PrintNative(@class)}*) {Helpers.InstanceIdentifier})")}{
                     (@class.IsValueType ? "." : "->")}{SafeIdentifier(name)}",
-                ReturnType = field.QualifiedType
+                ReturnType = returnType
             };
             ctx.PushMarshalKind(MarshalKind.NativeField);
 
@@ -3167,13 +3167,6 @@ public void GenerateInternalFunction(Function function)
             if (function.IsPure)
                 return;
 
-            if (function.OriginalFunction != null)
-            {
-                var @class = function.OriginalNamespace as Class;
-                if (@class != null && @class.IsInterface)
-                    function = function.OriginalFunction;
-            }
-
             PushBlock(BlockKind.InternalsClassMethod);
             WriteLine("[SuppressUnmanagedCodeSecurity]");
             Write("[DllImport(\"{0}\", ", GetLibraryOf(function));
diff --git a/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs b/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs
@@ -31,7 +31,7 @@ public static void GenerateNativeConstructorsByValue(
         }
 
         public static void GenerateField(this CSharpSources gen, Class @class,
-            Field field, Action<Field, Class> generate, bool isVoid)
+            Field field, Action<Field, Class, QualifiedType> generate, bool isVoid)
         {
             if (@class.IsDependent)
             {
@@ -46,7 +46,7 @@ public static void GenerateField(this CSharpSources gen, Class @class,
                         gen.WriteStartBraceIndent();
                         var specializedField = specialization.Fields.First(
                             f => f.OriginalName == field.OriginalName);
-                        generate(specializedField, specialization);
+                        generate(specializedField, specialization, field.QualifiedType);
                         if (isVoid)
                             gen.WriteLine("return;");
                         gen.WriteCloseBraceIndent();
@@ -58,12 +58,13 @@ public static void GenerateField(this CSharpSources gen, Class @class,
                     var specialization = @class.Specializations[0];
                     var specializedField = specialization.Fields.First(
                         f => f.OriginalName == field.OriginalName);
-                    generate(specializedField, specialization);
+                    generate(specializedField, specialization, field.QualifiedType);
                 }
             }
             else
             {
-                generate(field, @class.IsDependent ? @class.Specializations[0] : @class);
+                generate(field, @class.IsDependent ? @class.Specializations[0] : @class,
+                    field.QualifiedType);
             }
         }
 
diff --git a/src/Generator/Passes/MultipleInheritancePass.cs b/src/Generator/Passes/MultipleInheritancePass.cs
@@ -46,7 +46,7 @@ public override bool VisitClassDecl(Class @class)
             {
                 var @base = @class.Bases[i];
                 var baseClass = @base.Class;
-                if (baseClass == null || baseClass.IsInterface) continue;
+                if (baseClass == null || baseClass.IsInterface || !baseClass.IsGenerated) continue;
 
                 var @interface = GetInterface(baseClass);
                 @class.Bases[i] = new BaseClassSpecifier(@base) { Type = new TagType(@interface) };
@@ -70,14 +70,35 @@ private Class GetInterface(Class @base)
 
         private Class GetNewInterface(string name, Class @base)
         {
-            var @interface = new Class
-                {
-                    Name = name,
-                    Namespace = @base.Namespace,
-                    Access = @base.Access,
-                    Type = ClassType.Interface,
-                    OriginalClass = @base
-                };
+            var specialization = @base as ClassTemplateSpecialization;
+            Class @interface;
+            if (specialization == null)
+            {
+                @interface = new Class();
+            }
+            else
+            {
+                Class template = specialization.TemplatedDecl.TemplatedClass;
+                Class templatedInterface;
+                if (templatedInterfaces.ContainsKey(template))
+                    templatedInterface = templatedInterfaces[template];
+                else
+                    templatedInterfaces[template] = templatedInterface = GetInterface(template);
+                var specializedInterface = new ClassTemplateSpecialization();
+                specializedInterface.Arguments.AddRange(specialization.Arguments);
+                specializedInterface.TemplatedDecl = new ClassTemplate { TemplatedDecl = templatedInterface };
+                @interface = specializedInterface;
+            }
+            @interface.Name = name;
+            @interface.Namespace = @base.Namespace;
+            @interface.Access = @base.Access;
+            @interface.Type = ClassType.Interface;
+            @interface.OriginalClass = @base;
+            if (@base.IsTemplate)
+            {
+                @interface.IsDependent = true;
+                @interface.TemplateParameters.AddRange(@base.TemplateParameters);
+            }
 
             @interface.Bases.AddRange(
                 from b in @base.Bases
@@ -136,7 +157,8 @@ where property.IsDeclared
 
             @base.Bases.Add(new BaseClassSpecifier { Type = new TagType(@interface) });
 
-            interfaces.Add(@base, @interface);
+            if (specialization == null)
+                interfaces.Add(@base, @interface);
             return @interface;
         }
 
@@ -204,5 +226,7 @@ private static void ImplementInterfaceProperties(Class @class, Class @interface)
             foreach (var @base in @interface.Bases)
                 ImplementInterfaceProperties(@class, @base.Class);
         }
+
+        private readonly Dictionary<Class, Class> templatedInterfaces = new Dictionary<Class, Class>();
     }
 }
diff --git a/src/Generator/Passes/TrimSpecializationsPass.cs b/src/Generator/Passes/TrimSpecializationsPass.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using CppSharp.AST;
 using CppSharp.AST.Extensions;
+using CppSharp.Types;
 using CppSharp.Utils;
 
 namespace CppSharp.Passes
@@ -78,7 +79,14 @@ public override bool VisitFieldDecl(Field field)
             if (!base.VisitDeclaration(field))
                 return false;
 
-            if (field.Access == AccessSpecifier.Private ||
+            if (field.Access == AccessSpecifier.Private)
+            {
+                CheckForInternalSpecialization(field, field.Type);
+                return true;
+            }
+
+            TypeMap typeMap;
+            if (!Context.TypeMaps.FindTypeMap(field.Type, out typeMap) &&
                 !ASTUtils.CheckTypeForSpecialization(field.Type,
                     field, AddSpecialization, Context.TypeMaps))
                 CheckForInternalSpecialization(field, field.Type);
@@ -200,12 +208,10 @@ private void CheckBasesForSpecialization(Class @class)
             foreach (var @base in @class.Bases.Where(b => b.IsClass))
             {
                 var specialization = @base.Class as ClassTemplateSpecialization;
-                if (specialization != null)
-                {
-                    if (!ASTUtils.CheckTypeForSpecialization(@base.Type, @class,
-                           AddSpecialization, Context.TypeMaps))
-                        CheckForInternalSpecialization(@class, @base.Type);
-                }
+                if (specialization != null &&
+                    !ASTUtils.CheckTypeForSpecialization(@base.Type, @class,
+                        AddSpecialization, Context.TypeMaps))
+                    CheckForInternalSpecialization(@class, @base.Type);
                 CheckBasesForSpecialization(@base.Class);
             }
         }
diff --git a/tests/CSharp/CSharp.Tests.cs b/tests/CSharp/CSharp.Tests.cs
@@ -885,6 +885,16 @@ public void TestFieldWithSpecializationType()
         }
     }
 
+    [Test]
+    public void TestSpecializationForSecondaryBase()
+    {
+        using (var hasSpecializationForSecondaryBase = new HasSpecializationForSecondaryBase())
+        {
+            hasSpecializationForSecondaryBase.DependentValue = 5;
+            Assert.That(hasSpecializationForSecondaryBase.DependentValue, Is.EqualTo(5));
+        }
+    }
+
     [Test]
     public void TestAbstractImplementatonsInPrimaryAndSecondaryBases()
     {
diff --git a/tests/CSharp/CSharpTemplates.cpp b/tests/CSharp/CSharpTemplates.cpp
@@ -87,6 +87,14 @@ int HasVirtualTemplate::function()
     return v->function();
 }
 
+HasSpecializationForSecondaryBase::HasSpecializationForSecondaryBase()
+{
+}
+
+HasSpecializationForSecondaryBase::~HasSpecializationForSecondaryBase()
+{
+}
+
 TemplateSpecializer::TemplateSpecializer()
 {
 }
diff --git a/tests/CSharp/CSharpTemplates.h b/tests/CSharp/CSharpTemplates.h
@@ -425,6 +425,13 @@ class DLL_API HasVirtualTemplate
     HasDefaultTemplateArgument<bool, bool> explicitSpecialization;
 };
 
+class DLL_API HasSpecializationForSecondaryBase : T1, DependentValueFields<int>
+{
+public:
+    HasSpecializationForSecondaryBase();
+    ~HasSpecializationForSecondaryBase();
+};
+
 template <typename T>
 class TemplateInAnotherUnit;
 

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static void GenerateNativeConstructorsByValue(`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public static void GenerateField(this CSharpSources gen, Class @class,`
`34`		`- Field field, Action<Field, Class> generate, bool isVoid)`
	`34`	`+ Field field, Action<Field, Class, QualifiedType> generate, bool isVoid)`
`35`	`35`	`{`
`36`	`36`	`if (@class.IsDependent)`
`37`	`37`	`{`
`@@ -46,7 +46,7 @@ public static void GenerateField(this CSharpSources gen, Class @class,`
`46`	`46`	`gen.WriteStartBraceIndent();`
`47`	`47`	`var specializedField = specialization.Fields.First(`
`48`	`48`	`f => f.OriginalName == field.OriginalName);`
`49`		`- generate(specializedField, specialization);`
	`49`	`+ generate(specializedField, specialization, field.QualifiedType);`
`50`	`50`	`if (isVoid)`
`51`	`51`	`gen.WriteLine("return;");`
`52`	`52`	`gen.WriteCloseBraceIndent();`
`@@ -58,12 +58,13 @@ public static void GenerateField(this CSharpSources gen, Class @class,`
`58`	`58`	`var specialization = @class.Specializations[0];`
`59`	`59`	`var specializedField = specialization.Fields.First(`
`60`	`60`	`f => f.OriginalName == field.OriginalName);`
`61`		`- generate(specializedField, specialization);`
	`61`	`+ generate(specializedField, specialization, field.QualifiedType);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`else`
`65`	`65`	`{`
`66`		`- generate(field, @class.IsDependent ? @class.Specializations[0] : @class);`
	`66`	`+ generate(field, @class.IsDependent ? @class.Specializations[0] : @class,`
	`67`	`+ field.QualifiedType);`
`67`	`68`	`}`
`68`	`69`	`}`
`69`	`70`
Original file line number	Diff line number	Diff line change
`@@ -885,6 +885,16 @@ public void TestFieldWithSpecializationType()`
`885`	`885`	`}`
`886`	`886`	`}`
`887`	`887`
	`888`	`+ [Test]`
	`889`	`+ public void TestSpecializationForSecondaryBase()`
	`890`	`+ {`
	`891`	`+ using (var hasSpecializationForSecondaryBase = new HasSpecializationForSecondaryBase())`
	`892`	`+ {`
	`893`	`+ hasSpecializationForSecondaryBase.DependentValue = 5;`
	`894`	`+ Assert.That(hasSpecializationForSecondaryBase.DependentValue, Is.EqualTo(5));`
	`895`	`+ }`
	`896`	`+ }`
	`897`	`+`
`888`	`898`	`[Test]`
`889`	`899`	`public void TestAbstractImplementatonsInPrimaryAndSecondaryBases()`
`890`	`900`	`{`
Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,14 @@ int HasVirtualTemplate::function()`
`87`	`87`	`return v->function();`
`88`	`88`	`}`
`89`	`89`
	`90`	`+HasSpecializationForSecondaryBase::HasSpecializationForSecondaryBase()`
	`91`	`+{`
	`92`	`+}`
	`93`	`+`
	`94`	`+HasSpecializationForSecondaryBase::~HasSpecializationForSecondaryBase()`
	`95`	`+{`
	`96`	`+}`
	`97`	`+`
`90`	`98`	`TemplateSpecializer::TemplateSpecializer()`
`91`	`99`	`{`
`92`	`100`	`}`