Generate valid C# for nested in external specializations

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

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -313,30 +313,32 @@ namespace CppSharp.Generators.CSharp
                 classTemplate.Specializations);
         }
 
-        private void GenerateClassTemplateSpecializationsInternals(Class classTemplate,
+        private void GenerateClassTemplateSpecializationsInternals(Class template,
             IList<ClassTemplateSpecialization> specializations)
         {
             PushBlock(BlockKind.Namespace);
-            var generated = GetGeneratedClasses(classTemplate, specializations);
+            var generated = GetGeneratedClasses(template, specializations);
             WriteLine("namespace {0}{1}",
-                classTemplate.OriginalNamespace is Class &&
+                template.OriginalNamespace is Class &&
-                !classTemplate.OriginalNamespace.IsDependent ?
+                !template.OriginalNamespace.IsDependent ?
-                    classTemplate.OriginalNamespace.Name + '_' : string.Empty,
+                    template.OriginalNamespace.Name + '_' : string.Empty,
-                classTemplate.Name);
+                template.Name);
             WriteOpenBraceAndIndent();
 
-            foreach (var nestedTemplate in classTemplate.Classes.Where(
+            foreach (var nestedTemplate in template.Classes.Where(
                 c => c.IsDependent && !c.Ignore && c.Specializations.Any(s => !s.Ignore)))
                 GenerateClassTemplateSpecializationsInternals(
                     nestedTemplate, nestedTemplate.Specializations);
 
-            foreach (var specialization in generated.KeepSingleAllPointersSpecialization())
+            if (template.HasDependentValueFieldInLayout() ||
-                GenerateClassInternals(specialization);
+                template.Specializations.Intersect(specializations).Count() == specializations.Count)
+                foreach (var specialization in generated)
+                    GenerateClassInternals(specialization);
 
             foreach (var group in specializations.SelectMany(s => s.Classes).Where(
                 c => !c.IsIncomplete).GroupBy(c => c.Name))
             {
-                var nested = classTemplate.Classes.FirstOrDefault(c => c.Name == group.Key);
+                var nested = template.Classes.FirstOrDefault(c => c.Name == group.Key);
                 if (nested != null)
                     GenerateNestedInternals(group.Key, GetGeneratedClasses(nested, group));
             }

src/Generator/Passes/TrimSpecializationsPass.cs

@@ -138,7 +138,9 @@ namespace CppSharp.Passes
                 template.Specializations.All(s => s.Ignore))
                 template.ExplicitlyIgnore();
 
-            if (template.Specializations.Any() && template.HasDependentValueFieldInLayout())
+            if (template.Specializations.Any() &&
+                (template.HasDependentValueFieldInLayout() ||
+                 template.Classes.Any(c => c.HasDependentValueFieldInLayout())))
                 TryMoveExternalSpecializations(template);
         }
 

tests/NamespacesBase/NamespacesBase.h

@@ -73,6 +73,12 @@ void TemplateClass<T>::setField(const T& value)
 template <typename T>
 class IndependentFields
 {
+public:
+    class Nested
+    {
+    private:
+        T field;
+    };
 };
 
 template <typename T>

tests/NamespacesDerived/NamespacesDerived.h

@@ -70,6 +70,7 @@ private:
     TemplateClass<DependentFields<Derived>> nestedSpecialization;
     IndependentFields<int> independentSpecialization;
     IndependentFields<Derived> independentExternalSpecialization;
+    IndependentFields<Derived>::Nested nestedInExternalSpecialization;
 };
 
 class DLL_API HasVirtualInDependency : public HasVirtualInCore