Fixed the generated C# for specialisations only used as type arguments.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/CppParser/Parser.cpp

@@ -1437,15 +1437,14 @@ Parser::WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateA
     case clang::TemplateArgument::Type:
     {
         Arg.kind = CppSharp::CppParser::TemplateArgument::ArgumentKind::Type;
+        clang::TypeLoc ArgTL;
         if (ArgLoc && ArgLoc->getTypeSourceInfo())
         {
-            auto ArgTL = ArgLoc->getTypeSourceInfo()->getTypeLoc();
-            Arg.type = GetQualifiedType(TA.getAsType(), &ArgTL);
-        }
-        else
-        {
-            Arg.type = GetQualifiedType(TA.getAsType());
+            ArgTL = ArgLoc->getTypeSourceInfo()->getTypeLoc();
         }
+        auto Type = TA.getAsType();
+        CompleteIfSpecializationType(Type);
+        Arg.type = GetQualifiedType(Type, &ArgTL);
         break;
     }
     case clang::TemplateArgument::Declaration:

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -295,9 +295,8 @@ namespace CppSharp.Generators.CSharp
         private IEnumerable<ClassTemplateSpecialization> GetGenerated(
             IList<ClassTemplateSpecialization> specializations)
         {
-            var specialization = specializations.FirstOrDefault(s => !s.Ignore);
-            if (specialization == null)
-                specialization = specializations[0];
+            var specialization = specializations.FirstOrDefault(s => s.IsGenerated) ??
+                specializations[0];
 
             Class classTemplate = specialization.TemplatedDecl.TemplatedClass;
             if (classTemplate.HasDependentValueFieldInLayout())

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -179,6 +179,9 @@ namespace CppSharp.Generators.CSharp
 
         public static bool IsConstCharString(PointerType pointer)
         {
+            if (pointer.IsReference)
+                return false;
+
             var pointee = pointer.Pointee.Desugar();
 
             return (pointee.IsPrimitiveType(PrimitiveType.Char) ||

src/Generator/Passes/TrimSpecializationsPass.cs

@@ -66,8 +66,7 @@ namespace CppSharp.Passes
                 Action<ClassTemplateSpecialization> add =
                     s =>
                     {
-                        if (internalSpecializations.Contains(s))
-                            internalSpecializations.Remove(s);
+                        internalSpecializations.Remove(s);
                         specializations.Add(s);
                     };
                 ASTUtils.CheckTypeForSpecialization(function.OriginalReturnType.Type,
@@ -189,6 +188,7 @@ namespace CppSharp.Passes
                 var specialization = @base.Class as ClassTemplateSpecialization;
                 if (specialization != null)
                 {
+                    internalSpecializations.Remove(specialization);
                     specializations.Add(specialization);
                     foreach (var field in specialization.Fields)
                         field.Visit(this);

src/Generator/Types/TypeIgnoreChecker.cs

@@ -126,10 +126,7 @@ namespace CppSharp
                 return false;
             }
 
-            var result = base.VisitTemplateSpecializationType(template, quals);
-            if (!result)
-                Ignore();
-            return result;
+            return IsIgnored = !base.VisitTemplateSpecializationType(template, quals);
         }
 
         public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)

tests/CSharp/CSharpTemplates.cpp

@@ -126,7 +126,8 @@ void forceUseSpecializations(IndependentFields<int> _1, IndependentFields<bool>
                              VirtualTemplate<int> _6, VirtualTemplate<bool> _7,
                              HasDefaultTemplateArgument<int, int> _8, DerivedChangesTypeName<T1> _9,
                              TemplateWithIndexer<int> _10, TemplateWithIndexer<T1> _11,
-                             TemplateWithIndexer<T2*> _12, TemplateDerivedFromRegularDynamic<RegularDynamic> _13, std::string s)
+                             TemplateWithIndexer<T2*> _12, TemplateDerivedFromRegularDynamic<RegularDynamic> _13,
+                             IndependentFields<OnlySpecialisedInTypeArg<double> > _14, std::string s)
 {
 }
 

tests/CSharp/CSharpTemplates.h

@@ -492,6 +492,11 @@ TemplateDerivedFromRegularDynamic<T>::~TemplateDerivedFromRegularDynamic()
 {
 }
 
+template <typename T>
+class OnlySpecialisedInTypeArg
+{
+};
+
 // we optimise specialisations so that only actually used ones are wrapped
 void forceUseSpecializations(IndependentFields<int> _1, IndependentFields<bool> _2,
                              IndependentFields<T1> _3, IndependentFields<std::string> _4,
@@ -499,7 +504,8 @@ void forceUseSpecializations(IndependentFields<int> _1, IndependentFields<bool>
                              VirtualTemplate<int> _6, VirtualTemplate<bool> _7,
                              HasDefaultTemplateArgument<int, int> _8, DerivedChangesTypeName<T1> _9,
                              TemplateWithIndexer<int> _10, TemplateWithIndexer<T1> _11,
-                             TemplateWithIndexer<T2*> _12, TemplateDerivedFromRegularDynamic<RegularDynamic> _13, std::string s);
+                             TemplateWithIndexer<T2*> _12, TemplateDerivedFromRegularDynamic<RegularDynamic> _13,
+                             IndependentFields<OnlySpecialisedInTypeArg<double>> _14, std::string s);
 
 DLL_API DependentValueFields<double> specialiseReturnOnly();