Restore removed specializations

ddobrev · ddobrev · commit 3caa8c5da274 · 2019-04-12T16:26:36.000+03:00
All specializations which only use pointers as their type arguments need at most one internal representation since pointers are mapped to IntPtr. This was achieved by removing the unneeded specializations from their containing list. This was, however, a bug because specializations were thus removed not only as internal structures but in their entirety.

Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/src/AST/Type.cs b/src/AST/Type.cs
@@ -551,7 +551,7 @@ public override int GetHashCode() =>
     /// <summary>
     /// Represents a template argument within a class template specialization.
     /// </summary>
-    public struct TemplateArgument
+    public class TemplateArgument
     {
         /// The kind of template argument we're storing.
         public enum ArgumentKind
diff --git a/src/Generator/Generators/CSharp/CSharpSources.cs b/src/Generator/Generators/CSharp/CSharpSources.cs
@@ -312,7 +312,7 @@ classTemplate.OriginalNamespace is Class &&
                 GenerateClassTemplateSpecializationsInternals(
                     nestedTemplate, nestedTemplate.Specializations);
 
-            foreach (var specialization in generated)
+            foreach (var specialization in generated.KeepSingleAllPointersSpecialization())
                 GenerateClassInternals(specialization);
 
             foreach (var group in generated.SelectMany(s => s.Classes).Where(
@@ -558,14 +558,32 @@ private IEnumerable<Function> GatherClassInternalFunctions(Class @class,
                     functions.AddRange(GatherClassInternalFunctions(@base.Class, false));
 
             var currentSpecialization = @class as ClassTemplateSpecialization;
-            Class template;
-            if (currentSpecialization != null &&
-                (template = currentSpecialization.TemplatedDecl.TemplatedClass)
-                .GetSpecializedClassesToGenerate().Count() == 1)
-                foreach (var specialization in template.Specializations.Where(s => s.IsGenerated))
-                    GatherClassInternalFunctions(specialization, includeCtors, functions);
-            else
-                GatherClassInternalFunctions(@class, includeCtors, functions);
+            if (currentSpecialization != null)
+            {
+                Class template = currentSpecialization.TemplatedDecl.TemplatedClass;
+                IEnumerable<ClassTemplateSpecialization> specializations = null;
+                if (template.GetSpecializedClassesToGenerate().Count() == 1)
+                    specializations = template.Specializations.Where(s => s.IsGenerated);
+                else
+                {
+                    Func<TemplateArgument, bool> allPointers = (TemplateArgument a) =>
+                        a.Type.Type?.Desugar().IsAddress() == true;
+                    if (currentSpecialization.Arguments.All(allPointers))
+                    {
+                        specializations = template.Specializations.Where(
+                            s => s.IsGenerated && s.Arguments.All(allPointers));
+                    }
+                }
+
+                if (specializations != null)
+                {
+                    foreach (var specialization in specializations)
+                        GatherClassInternalFunctions(specialization, includeCtors, functions);
+                    return functions;
+                }
+            }
+
+            GatherClassInternalFunctions(@class, includeCtors, functions);
 
             return functions;
         }
diff --git a/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs b/src/Generator/Generators/CSharp/CSharpSourcesExtensions.cs
@@ -23,11 +23,37 @@ public static void GenerateNativeConstructorsByValue(
         {
             var printedClass = @class.Visit(gen.TypePrinter);
             if (@class.IsDependent)
-                foreach (var specialization in @class.GetSpecializedClassesToGenerate(
-                    ).Where(s => s.IsGenerated))
+            {
+                IEnumerable<Class> specializations =
+                    @class.GetSpecializedClassesToGenerate().Where(s => s.IsGenerated);
+                if (@class.IsTemplate)
+                    specializations = specializations.KeepSingleAllPointersSpecialization();
+                foreach (var specialization in specializations)
                     gen.GenerateNativeConstructorByValue(specialization, printedClass.Type);
+            }
             else
+            {
                 gen.GenerateNativeConstructorByValue(@class, printedClass.Type);
+            }
+        }
+
+        public static IEnumerable<Class> KeepSingleAllPointersSpecialization(
+            this IEnumerable<Class> specializations)
+        {
+            Func<TemplateArgument, bool> allPointers = (TemplateArgument a) =>
+                a.Type.Type?.Desugar().IsAddress() == true;
+            var groups = (from ClassTemplateSpecialization spec in specializations
+                          group spec by spec.Arguments.All(allPointers)
+                          into @group
+                          select @group).ToList();
+            foreach (var group in groups)
+            {
+                if (group.Key)
+                    yield return group.First();
+                else
+                    foreach (var specialization in group)
+                        yield return specialization;
+            }
         }
 
         public static void GenerateField(this CSharpSources gen, Class @class,
@@ -112,7 +138,7 @@ private static void WriteTemplateSpecializationCheck(CSharpSources gen,
                 Enumerable.Range(0, @class.TemplateParameters.Count).Select(
                 i =>
                 {
-                    CppSharp.AST.Type type = specialization.Arguments[i].Type.Type.Desugar();
+                    CppSharp.AST.Type type = specialization.Arguments[i].Type.Type;
                     return type.IsPointerToPrimitiveType() ?
                         $"__{@class.TemplateParameters[i].Name}.FullName == \"System.IntPtr\"" :
                         $"__{@class.TemplateParameters[i].Name}.IsAssignableFrom(typeof({type}))";
diff --git a/src/Generator/Generators/CSharp/CSharpTypePrinter.cs b/src/Generator/Generators/CSharp/CSharpTypePrinter.cs
@@ -560,14 +560,14 @@ public TypePrinterResult VisitTemplateArgument(TemplateArgument a)
         {
             if (a.Type.Type == null)
                 return a.Integral.ToString(CultureInfo.InvariantCulture);
-            var type = a.Type.Type.Desugar();
+            var type = a.Type.Type;
             PrimitiveType pointee;
             if (type.IsPointerToPrimitiveType(out pointee) && !type.IsConstCharString())
             {
                 return $@"CppSharp.Runtime.Pointer<{(pointee == PrimitiveType.Void ? IntPtrType :
                     VisitPrimitiveType(pointee, new TypeQualifiers()).Type)}>";
             }
-            return (type.IsPrimitiveType(PrimitiveType.Void)) ? "object" : type.Visit(this).Type;
+            return type.IsPrimitiveType(PrimitiveType.Void) ? "object" : type.Visit(this).Type;
         }
 
         public override TypePrinterResult VisitParameterDecl(Parameter parameter)
diff --git a/src/Generator/Passes/CheckDuplicatedNamesPass.cs b/src/Generator/Passes/CheckDuplicatedNamesPass.cs
@@ -159,10 +159,16 @@ public bool Equals(TemplateArgument x, TemplateArgument y)
                 if (x.Kind != TemplateArgument.ArgumentKind.Type ||
                     y.Kind != TemplateArgument.ArgumentKind.Type)
                     return x.Equals(y);
-                return x.Type.Type.GetMappedType(ParameterTypeComparer.TypeMaps,
-                    ParameterTypeComparer.GeneratorKind).Equals(
-                    y.Type.Type.GetMappedType(ParameterTypeComparer.TypeMaps,
-                        ParameterTypeComparer.GeneratorKind));
+                Type left = x.Type.Type.GetMappedType(ParameterTypeComparer.TypeMaps,
+                    ParameterTypeComparer.GeneratorKind);
+                Type right = y.Type.Type.GetMappedType(ParameterTypeComparer.TypeMaps,
+                    ParameterTypeComparer.GeneratorKind);
+                // consider Type and const Type the same
+                if (left.IsReference() && !left.IsPointerToPrimitiveType())
+                    left = left.GetPointee();
+                if (right.IsReference() && !right.IsPointerToPrimitiveType())
+                    right = right.GetPointee();
+                return left.Equals(right);
             }
 
             public int GetHashCode(TemplateArgument obj)
diff --git a/src/Generator/Passes/DelegatesPass.cs b/src/Generator/Passes/DelegatesPass.cs
@@ -46,12 +46,38 @@ public override bool VisitClassDecl(Class @class)
             return base.VisitClassDecl(@class);
         }
 
+        public override bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization)
+        {
+            if (!base.VisitClassTemplateSpecializationDecl(specialization) ||
+                !specialization.IsGenerated || !specialization.TemplatedDecl.TemplatedDecl.IsGenerated)
+                return false;
+
+            foreach (TemplateArgument arg in specialization.Arguments.Where(
+                a => a.Kind == TemplateArgument.ArgumentKind.Type))
+            {
+                arg.Type = CheckForDelegate(arg.Type, specialization);
+            }
+
+            return true;
+        }
+
         public override bool VisitMethodDecl(Method method)
         {
             if (!base.VisitMethodDecl(method) || !method.IsVirtual || method.Ignore)
                 return false;
 
-            method.FunctionType = CheckForDelegate(method.FunctionType, method);
+            var functionType = new FunctionType
+                {
+                    CallingConvention = method.CallingConvention,
+                    IsDependent = method.IsDependent,
+                    ReturnType = method.ReturnType
+                };
+
+            functionType.Parameters.AddRange(
+                method.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi, true));
+
+            method.FunctionType = CheckForDelegate(new QualifiedType(functionType),
+                method.Namespace, @private: true);
 
             return true;
         }
@@ -61,7 +87,8 @@ public override bool VisitFunctionDecl(Function function)
             if (!base.VisitFunctionDecl(function) || function.Ignore)
                 return false;
 
-            function.ReturnType = CheckForDelegate(function.ReturnType, function);
+            function.ReturnType = CheckForDelegate(function.ReturnType,
+                function.Namespace);
             return true;
         }
 
@@ -71,7 +98,8 @@ public override bool VisitParameterDecl(Parameter parameter)
                 parameter.Namespace.Ignore)
                 return false;
 
-            parameter.QualifiedType = CheckForDelegate(parameter.QualifiedType, parameter);
+            parameter.QualifiedType = CheckForDelegate(parameter.QualifiedType,
+                parameter.Namespace);
 
             return true;
         }
@@ -81,7 +109,8 @@ public override bool VisitProperty(Property property)
             if (!base.VisitProperty(property))
                 return false;
 
-            property.QualifiedType = CheckForDelegate(property.QualifiedType, property);
+            property.QualifiedType = CheckForDelegate(property.QualifiedType,
+                property.Namespace);
 
             return true;
         }
@@ -91,12 +120,14 @@ public override bool VisitFieldDecl(Field field)
             if (!base.VisitFieldDecl(field))
                 return false;
 
-            field.QualifiedType = CheckForDelegate(field.QualifiedType, field);
+            field.QualifiedType = CheckForDelegate(field.QualifiedType,
+                field.Namespace);
 
             return true;
         }
 
-        private QualifiedType CheckForDelegate(QualifiedType type, ITypedDecl decl)
+        private QualifiedType CheckForDelegate(QualifiedType type,
+            DeclarationContext declarationContext, bool @private = false)
         {
             if (type.Type is TypedefType)
                 return type;
@@ -109,22 +140,21 @@ private QualifiedType CheckForDelegate(QualifiedType type, ITypedDecl decl)
             if (pointee is TypedefType)
                 return type;
 
-            var functionType = pointee.Desugar() as FunctionType;
-            if (functionType == null)
+            desugared = pointee.Desugar();
+            FunctionType functionType = desugared as FunctionType;
+            if (functionType == null && !desugared.IsPointerTo(out functionType))
                 return type;
 
-            TypedefDecl @delegate = GetDelegate(type, decl);
+            TypedefDecl @delegate = GetDelegate(functionType, declarationContext, @private);
             return new QualifiedType(new TypedefType { Declaration = @delegate });
         }
 
-        private TypedefDecl GetDelegate(QualifiedType type, ITypedDecl typedDecl)
+        private TypedefDecl GetDelegate(FunctionType functionType,
+            DeclarationContext declarationContext, bool @private = false)
         {
-            FunctionType newFunctionType = GetNewFunctionType(typedDecl, type);
-
-            var delegateName = GetDelegateName(newFunctionType);
-            var access = typedDecl is Method ? AccessSpecifier.Private : AccessSpecifier.Public;
-            var decl = (Declaration) typedDecl;
-            Module module = decl.TranslationUnit.Module;
+            var delegateName = GetDelegateName(functionType);
+            var access = @private ? AccessSpecifier.Private : AccessSpecifier.Public;
+            Module module = declarationContext.TranslationUnit.Module;
             var existingDelegate = delegates.Find(t => Match(t, delegateName, module));
             if (existingDelegate != null)
             {
@@ -135,18 +165,18 @@ private TypedefDecl GetDelegate(QualifiedType type, ITypedDecl typedDecl)
 
                 // Check if there is an existing delegate with a different calling convention
                 if (((FunctionType) existingDelegate.Type.GetPointee()).CallingConvention ==
-                    newFunctionType.CallingConvention)
+                    functionType.CallingConvention)
                     return existingDelegate;
 
                 // Add a new delegate with the calling convention appended to its name
-                delegateName += '_' + newFunctionType.CallingConvention.ToString();
+                delegateName += '_' + functionType.CallingConvention.ToString();
                 existingDelegate = delegates.Find(t => Match(t, delegateName, module));
                 if (existingDelegate != null)
                     return existingDelegate;
             }
 
-            var namespaceDelegates = GetDeclContextForDelegates(decl.Namespace);
-            var delegateType = new QualifiedType(new PointerType(new QualifiedType(newFunctionType)));
+            var namespaceDelegates = GetDeclContextForDelegates(declarationContext);
+            var delegateType = new QualifiedType(new PointerType(new QualifiedType(functionType)));
             existingDelegate = new TypedefDecl
                 {
                     Access = access,
@@ -160,30 +190,6 @@ private TypedefDecl GetDelegate(QualifiedType type, ITypedDecl typedDecl)
             return existingDelegate;
         }
 
-        private FunctionType GetNewFunctionType(ITypedDecl decl, QualifiedType type)
-        {
-            var functionType = new FunctionType();
-            var method = decl as Method;
-            if (method != null && method.FunctionType == type)
-            {
-                functionType.Parameters.AddRange(
-                    method.GatherInternalParams(Context.ParserOptions.IsItaniumLikeAbi, true));
-                functionType.CallingConvention = method.CallingConvention;
-                functionType.IsDependent = method.IsDependent;
-                functionType.ReturnType = method.ReturnType;
-            }
-            else
-            {
-                var funcTypeParam = (FunctionType) decl.Type.Desugar().GetFinalPointee().Desugar();
-                functionType = new FunctionType(funcTypeParam);
-            }
-
-            for (int i = 0; i < functionType.Parameters.Count; i++)
-                functionType.Parameters[i].Name = $"_{i}";
-
-            return functionType;
-        }
-
         private static bool Match(TypedefDecl t, string delegateName, Module module)
         {
             return t.Name == delegateName &&
diff --git a/src/Generator/Passes/SpecializationMethodsWithDependentPointersPass.cs b/src/Generator/Passes/SpecializationMethodsWithDependentPointersPass.cs
@@ -72,8 +72,11 @@ public override bool VisitClassDecl(Class @class)
                 foreach (var method in methodsWithDependentPointers.Where(
                     m => m.SynthKind == FunctionSynthKind.None))
                 {
-                    var specializedMethod = specialization.Methods.First(
+                    var specializedMethod = specialization.Methods.FirstOrDefault(
                         m => m.InstantiatedFrom == method);
+                    if (specializedMethod == null)
+                        continue;
+
                     Method extensionMethod = GetExtensionMethodForDependentPointer(specializedMethod);
                     classExtensions.Methods.Add(extensionMethod);
                     extensionMethod.Namespace = classExtensions;
diff --git a/src/Generator/Passes/TrimSpecializationsPass.cs b/src/Generator/Passes/TrimSpecializationsPass.cs
@@ -127,22 +127,10 @@ private void CleanSpecializations(Class template)
                 s => !s.IsExplicitlyGenerated && internalSpecializations.Contains(s)))
                 specialization.GenerationKind = GenerationKind.Internal;
 
-            Func<TemplateArgument, bool> allPointers =
-                a => a.Type.Type != null && a.Type.Type.IsAddress();
-            var groups = (from specialization in template.Specializations
-                          group specialization by specialization.Arguments.All(allPointers)
-                          into @group
-                          select @group).ToList();
-
-            foreach (var group in groups.Where(g => g.Key))
-                foreach (var specialization in group.Skip(1))
-                    template.Specializations.Remove(specialization);
-
             for (int i = template.Specializations.Count - 1; i >= 0; i--)
             {
                 var specialization = template.Specializations[i];
-                if (specialization is ClassTemplatePartialSpecialization &&
-                    !specialization.Arguments.All(allPointers))
+                if (specialization is ClassTemplatePartialSpecialization)
                     template.Specializations.RemoveAt(i);
             }
 

Original file line number	Diff line number	Diff line change
`@@ -551,7 +551,7 @@ public override int GetHashCode() =>`
`551`	`551`	`/// <summary>`
`552`	`552`	`/// Represents a template argument within a class template specialization.`
`553`	`553`	`/// </summary>`
`554`		`- public struct TemplateArgument`
	`554`	`+ public class TemplateArgument`
`555`	`555`	`{`
`556`	`556`	`/// The kind of template argument we're storing.`
`557`	`557`	`public enum ArgumentKind`
Original file line number	Diff line number	Diff line change
`@@ -560,14 +560,14 @@ public TypePrinterResult VisitTemplateArgument(TemplateArgument a)`
`560`	`560`	`{`
`561`	`561`	`if (a.Type.Type == null)`
`562`	`562`	`return a.Integral.ToString(CultureInfo.InvariantCulture);`
`563`		`- var type = a.Type.Type.Desugar();`
	`563`	`+ var type = a.Type.Type;`
`564`	`564`	`PrimitiveType pointee;`
`565`	`565`	`if (type.IsPointerToPrimitiveType(out pointee) && !type.IsConstCharString())`
`566`	`566`	`{`
`567`	`567`	`return $@"CppSharp.Runtime.Pointer<{(pointee == PrimitiveType.Void ? IntPtrType :`
`568`	`568`	`VisitPrimitiveType(pointee, new TypeQualifiers()).Type)}>";`
`569`	`569`	`}`
`570`		`- return (type.IsPrimitiveType(PrimitiveType.Void)) ? "object" : type.Visit(this).Type;`
	`570`	`+ return type.IsPrimitiveType(PrimitiveType.Void) ? "object" : type.Visit(this).Type;`
`571`	`571`	`}`
`572`	`572`
`573`	`573`	`public override TypePrinterResult VisitParameterDecl(Parameter parameter)`