Worked around duplication of types nested in templates and forwarded.

Since all template specialisations are incomplete by default, so are classes nested in them. When such classes are also forwarded, there are two incomplete declarations with the same name and in the same scope. Our parser searches by name and completion and it can therefore not make a difference between the two. Consequently, it always returns the first type it finds even if it isn't the right one. When clang::Sema later completes the specialisations, it completes the nested types too which leads to two identical complete types in the same scope.

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

Author: ddobrev

src/AST/Class.cs

@@ -270,6 +270,11 @@ public List<ClassTemplateSpecialization> Specializations
             }
         }
 
+        public bool IsTemplate
+        {
+            get { return IsDependent && TemplateParameters.Count > 0; }
+        }
+
         public override IEnumerable<Function> FindOperator(CXXOperatorKind kind)
         {
             return Methods.Where(m => m.OperatorKind == kind);

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -271,7 +271,16 @@ classTemplate.OriginalNamespace is Class ?
                 GenerateClassInternals(specialization);
 
             foreach (var group in generated.SelectMany(s => s.Classes).Where(
-                c => !c.IsIncomplete).GroupBy(c => c.Name))
+                // HACK: the distinction is needed to eliminate duplicate nested types
+                // Since all template specialisations are incomplete by default,
+                // so are classes nested in them.
+                // When such classes are also forwarded, there are two incomplete declarations
+                // with the same name and in the same scope. Our parser searches by name and
+                // completion and it can therefore not make a difference between the two.
+                // Consequently, it always returns the first type it finds even if it isn't the right one.
+                // When clang::Sema later completes the specialisations, it completes the nested
+                // types too which leads to two identical complete types in the same scope.
+                c => !c.IsIncomplete).Distinct().GroupBy(c => c.Name))
                 GenerateNestedInternals(group.Key, group);
 
             WriteCloseBraceIndent();
@@ -329,7 +338,7 @@ public override bool VisitClassDecl(Class @class)
             foreach (var nestedTemplate in @class.Classes.Where(c => !c.IsIncomplete && c.IsDependent))
                 GenerateClassTemplateSpecializationInternal(nestedTemplate);
 
-            if (@class.IsDependent)
+            if (@class.IsTemplate)
             {
                 if (!(@class.Namespace is Class))
                     GenerateClassTemplateSpecializationInternal(@class);

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -570,7 +570,7 @@ public override TypePrinterResult VisitClassDecl(Class @class)
                     Helpers.InternalStruct}{Helpers.GetSuffixForInternal(@class)}";
 
             var printed = VisitDeclaration(@class).Type;
-            if (!@class.IsDependent)
+            if (!@class.IsTemplate)
                 return printed;
             return $@"{printed}<{string.Join(", ",
                 @class.TemplateParameters.Select(p => p.Name))}>";
@@ -638,9 +638,7 @@ string GetName(Declaration decl)
 
             while (!(ctx is TranslationUnit))
             {
-                var isInlineNamespace = ctx is Namespace && ((Namespace)ctx).IsInline;
-                if (!string.IsNullOrWhiteSpace(ctx.Name) && !isInlineNamespace)
-                    names.Push(ctx.Name);
+                AddContextName(names, ctx);
 
                 ctx = ctx.Namespace;
             }
@@ -802,6 +800,38 @@ private static bool IsValid(TemplateArgument a)
             return templateParam == null || templateParam.Parameter != null;
         }
 
+        private void AddContextName(Stack<string> names, Declaration ctx)
+        {
+            var isInlineNamespace = ctx is Namespace && ((Namespace) ctx).IsInline;
+            if (string.IsNullOrWhiteSpace(ctx.Name) || isInlineNamespace)
+                return;
+
+            if (ContextKind != TypePrinterContextKind.Managed)
+            {
+                names.Push(ctx.Name);
+                return;
+            }
+
+            string name = null;
+            var @class = ctx as Class;
+            if (@class != null)
+            {
+                if (@class.IsTemplate)
+                    name = $@"{ctx.Name}<{string.Join(", ",
+                        @class.TemplateParameters.Select(p => p.Name))}>";
+                else
+                {
+                    var specialization = @class as ClassTemplateSpecialization;
+                    if (specialization != null)
+                    {
+                        name = $@"{ctx.Name}<{string.Join(", ",
+                            specialization.Arguments.Select(VisitTemplateArgument))}>";
+                    }
+                }
+            }
+            names.Push(name ?? ctx.Name);
+        }
+
         private CSharpExpressionPrinter expressionPrinter => new CSharpExpressionPrinter(this);
     }
 }

src/Generator/Passes/CheckIgnoredDecls.cs

@@ -36,7 +36,7 @@ public override bool VisitClassDecl(Class @class)
             if (@class.IsInjected)
                 injectedClasses.Add(@class);
 
-            if (!@class.IsDependent)
+            if (!@class.IsTemplate)
                 return true;
 
             if (Options.GenerateClassTemplates)

src/Generator/Passes/TrimSpecializationsPass.cs

@@ -37,7 +37,7 @@ public override bool VisitClassDecl(Class @class)
             if (!base.VisitClassDecl(@class))
                 return false;
 
-            if (@class.IsDependent)
+            if (@class.IsTemplate)
             {
                 templates.Add(@class);
                 foreach (var specialization in @class.Specializations.Where(

tests/CSharp/CSharp.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 using CppSharp.AST;

tests/CSharp/CSharpTemplates.h

@@ -136,6 +136,7 @@ class DLL_API DependentValueFields : public Base<T>
     DependentValueFields operator+(const DependentValueFields& other);
     T getDependentValue();
     void setDependentValue(const T& value);
+    IndependentFields<Nested> returnNestedInTemplate();
 private:
     T field{};
     union {
@@ -165,6 +166,12 @@ void DependentValueFields<T>::setDependentValue(const T& value)
     field = value;
 }
 
+template <typename T>
+IndependentFields<typename DependentValueFields<T>::Nested> DependentValueFields<T>::returnNestedInTemplate()
+{
+    return DependentValueFields<T>::Nested();
+}
+
 template <typename T>
 DependentValueFields<T>& DependentValueFields<T>::returnInjectedClass()
 {
@@ -532,6 +539,7 @@ template class DLL_API IndependentFields<T1>;
 template class DLL_API IndependentFields<std::string>;
 template class DLL_API Base<int>;
 template class DLL_API DependentValueFields<int>;
+template DLL_API IndependentFields<DependentValueFields<int>::Nested> DependentValueFields<int>::returnNestedInTemplate();
 template class DLL_API VirtualTemplate<int>;
 template class DLL_API VirtualTemplate<bool>;
 template class DLL_API HasDefaultTemplateArgument<int, int>;