Considered dependent fields when generating internals for types nested in templates.

Signed-off-by: Dimitar Dobrev <[email protected]>

Author: ddobrev

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -286,7 +286,7 @@ private void GenerateClassTemplateSpecializationsInternals(Class classTemplate,
             IList<ClassTemplateSpecialization> specializations)
         {
             PushBlock(BlockKind.Namespace);
-            var generated = GetGenerated(specializations);
+            var generated = GetGeneratedClasses(classTemplate, specializations);
             WriteLine("namespace {0}{1}",
                 classTemplate.OriginalNamespace is Class &&
                 !classTemplate.OriginalNamespace.IsDependent ?
@@ -304,7 +304,11 @@ classTemplate.OriginalNamespace is Class &&
 
             foreach (var group in generated.SelectMany(s => s.Classes).Where(
                 c => !c.IsIncomplete).GroupBy(c => c.Name))
-                GenerateNestedInternals(group.Key, group);
+            {
+                var nested = classTemplate.Classes.FirstOrDefault(c => c.Name == group.Key);
+                if (nested != null)
+                    GenerateNestedInternals(group.Key, GetGeneratedClasses(nested, group));
+            }
 
             WriteCloseBraceIndent();
             PopBlock(NewLineKind.BeforeNextBlock);
@@ -324,17 +328,16 @@ private void GenerateNestedInternals(string name, IEnumerable<Class> nestedClass
             NewLine();
         }
 
-        private IEnumerable<ClassTemplateSpecialization> GetGenerated(
-            IList<ClassTemplateSpecialization> specializations)
+        private IEnumerable<Class> GetGeneratedClasses(
+            Class dependentClass, IEnumerable<Class> specializedClasses)
         {
-            var specialization = specializations.FirstOrDefault(s => s.IsGenerated) ??
-                specializations[0];
+            var specialization = specializedClasses.FirstOrDefault(s => s.IsGenerated) ??
+                specializedClasses.First();
 
-            Class classTemplate = specialization.TemplatedDecl.TemplatedClass;
-            if (classTemplate.HasDependentValueFieldInLayout())
-                return specializations;
+            if (dependentClass.HasDependentValueFieldInLayout())
+                return specializedClasses;
 
-            return new List<ClassTemplateSpecialization> { specialization };
+            return new[] { specialization };
         }
 
         public override void GenerateDeclarationCommon(Declaration decl)

src/Generator/Generators/CodeGenerator.cs

@@ -530,18 +530,20 @@ public static class Helpers
 
         public static string GetSuffixForInternal(DeclarationContext @class)
         {
-            ClassTemplateSpecialization specialization = null;
-            DeclarationContext declContext = @class;
-            while (declContext != null)
+            if (@class == null)
+                return string.Empty;
+
+            Class template = null;
+            var specialization = @class as ClassTemplateSpecialization ??
+                @class.Namespace as ClassTemplateSpecialization;
+            if (specialization != null)
             {
-                specialization = declContext as ClassTemplateSpecialization;
-                if (specialization != null)
-                    break;
-                declContext = declContext.Namespace;
+                template = specialization.TemplatedDecl.TemplatedClass;
+                if (@class != specialization)
+                    template = template.Classes.FirstOrDefault(c => c.Name == @class.Name);
             }
 
-            if (specialization == null ||
-                !specialization.TemplatedDecl.TemplatedClass.HasDependentValueFieldInLayout())
+            if (template == null || !template.HasDependentValueFieldInLayout())
                 return string.Empty;
 
             if (specialization.Arguments.All(