Generate valid C# for independent external specializations

ddobrev · ddobrev · commit c84a6c606e8c · 2021-12-27T00:44:22.000+02:00
Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/src/AST/ClassExtensions.cs b/src/AST/ClassExtensions.cs
@@ -252,8 +252,19 @@ public static bool HasDependentValueFieldInLayout(this Class @class)
             if (@class.Fields.Any(f => IsValueDependent(f.Type)))
                 return true;
 
-            return @class.Bases.Where(b => b.IsClass).Select(
-                b => b.Class).Any(HasDependentValueFieldInLayout);
+            if (@class.Bases.Where(b => b.IsClass).Select(
+                b => b.Class).Any(HasDependentValueFieldInLayout))
+                return true;
+
+            // HACK: Clang can't always resolve complex templates such as the base of std::atomic in msvc
+            if (@class.IsTemplate && @class.Specializations.Any(
+                s => s.Layout.Fields.Any(
+                    f => f.QualifiedType.Type.TryGetDeclaration(
+                        out ClassTemplateSpecialization specialization) &&
+                        specialization.TemplatedDecl.TemplatedClass.HasDependentValueFieldInLayout())))
+                return true;
+
+            return false;
         }
 
         public static IEnumerable<Property> GetConstCharFieldProperties(this Class @class) =>
diff --git a/src/Generator/Generators/CodeGenerator.cs b/src/Generator/Generators/CodeGenerator.cs
@@ -1322,11 +1322,7 @@ public static string GetSuffixForInternal(Class @class)
                     return "_Ptr";
                 return GetSuffixFor(specialization);
             }
-            // HACK: Clang can't always resolve complex templates such as the base of std::atomic in msvc
-            return (from @base in @class.Bases
-                    let suffix = GetSuffixForInternal(@base.Class)
-                    where suffix.Length > 0
-                    select suffix).DefaultIfEmpty(string.Empty).First();
+            return string.Empty;
         }
 
         public static string GetSuffixFor(Declaration decl)
diff --git a/src/Generator/Passes/TrimSpecializationsPass.cs b/src/Generator/Passes/TrimSpecializationsPass.cs
@@ -138,7 +138,8 @@ private void CleanSpecializations(Class template)
                 template.Specializations.All(s => s.Ignore))
                 template.ExplicitlyIgnore();
 
-            TryMoveExternalSpecializations(template);
+            if (template.Specializations.Any() && template.HasDependentValueFieldInLayout())
+                TryMoveExternalSpecializations(template);
         }
 
         /// <summary>
@@ -174,17 +175,13 @@ private static Module GetExternalModule(ClassTemplateSpecialization specializati
                 {
                     Module module = arg.Type.Type.GetModule();
                     if (module != null)
-                    {
                         modules.Add(module);
-                    }
                 }
                 if (arg.Type.Type.TryGetDeclaration(out ClassTemplateSpecialization nestedSpecialization))
                 {
                     Module module = GetExternalModule(nestedSpecialization);
                     if (module != null)
-                    {
                         modules.Add(module);
-                    }
                 }
             }
             return modules.TopologicalSort(m => m.Dependencies).LastOrDefault();
diff --git a/tests/NamespacesBase/NamespacesBase.h b/tests/NamespacesBase/NamespacesBase.h
@@ -71,7 +71,12 @@ void TemplateClass<T>::setField(const T& value)
 }
 
 template <typename T>
-class TemplateWithIndependentFields
+class IndependentFields
+{
+};
+
+template <typename T>
+class DependentFields
 {
 public:
     class Nested
@@ -85,13 +90,13 @@ class TemplateWithIndependentFields
 };
 
 template <typename T>
-const T& TemplateWithIndependentFields<T>::constField() const
+const T& DependentFields<T>::constField() const
 {
     return *t;
 }
 
 template <typename T>
-typename TemplateWithIndependentFields<T>::Nested TemplateWithIndependentFields<T>::useDependentPointer(const T* t)
+typename DependentFields<T>::Nested DependentFields<T>::useDependentPointer(const T* t)
 {
     return Nested();
 }
diff --git a/tests/NamespacesDerived/Independent.h b/tests/NamespacesDerived/Independent.h
@@ -1,3 +1,3 @@
 class Derived;
-template<typename T> class TemplateWithIndependentFields;
-typedef TemplateWithIndependentFields<Derived*> ForwardedInIndependentHeader;
+template<typename T> class DependentFields;
+typedef DependentFields<Derived*> ForwardedInIndependentHeader;
diff --git a/tests/NamespacesDerived/NamespacesDerived.cpp b/tests/NamespacesDerived/NamespacesDerived.cpp
@@ -62,6 +62,11 @@ TemplateClass<int> Derived2::getTemplate()
     return t;
 }
 
+IndependentFields<int> Derived2::getIndependentSpecialization()
+{
+    return independentSpecialization;
+}
+
 Derived2::LocalTypedefSpecialization Derived2::getLocalTypedefSpecialization()
 {
     return LocalTypedefSpecialization();
@@ -73,13 +78,13 @@ Abstract* Derived2::getAbstract()
 }
 
 DerivedFromExternalSpecialization::DerivedFromExternalSpecialization(int i,
-                                                                     TemplateWithIndependentFields<HasVirtualInDependency> defaultExternalSpecialization)
+                                                                     DependentFields<HasVirtualInDependency> defaultExternalSpecialization)
 {
 }
 
-TemplateWithIndependentFields<Base3> DerivedFromExternalSpecialization::returnExternalSpecialization()
+DependentFields<Base3> DerivedFromExternalSpecialization::returnExternalSpecialization()
 {
-    return TemplateWithIndependentFields<Base3>();
+    return DependentFields<Base3>();
 }
 
 int HasVirtualInDependency::callManagedOverride()
diff --git a/tests/NamespacesDerived/NamespacesDerived.h b/tests/NamespacesDerived/NamespacesDerived.h
@@ -60,13 +60,16 @@ class DLL_API Derived2 : public Base3
     void defaultEnumValueFromDependency(OverlappingNamespace::ColorsEnum c = OverlappingNamespace::ColorsEnum::black);
 
     TemplateClass<int> getTemplate();
-    typedef TemplateWithIndependentFields<int> LocalTypedefSpecialization;
+    IndependentFields<int> getIndependentSpecialization();
+    typedef DependentFields<int> LocalTypedefSpecialization;
     LocalTypedefSpecialization getLocalTypedefSpecialization();
     Abstract* getAbstract();
 private:
     TemplateClass<int> t;
     TemplateClass<Derived> d;
-    TemplateClass<TemplateWithIndependentFields<Derived>> nestedSpecialization;
+    TemplateClass<DependentFields<Derived>> nestedSpecialization;
+    IndependentFields<int> independentSpecialization;
+    IndependentFields<Derived> independentExternalSpecialization;
 };
 
 class DLL_API HasVirtualInDependency : public HasVirtualInCore
@@ -76,13 +79,13 @@ class DLL_API HasVirtualInDependency : public HasVirtualInCore
     int callManagedOverride();
 };
 
-class DLL_API DerivedFromExternalSpecialization : public TemplateWithIndependentFields<Derived>
+class DLL_API DerivedFromExternalSpecialization : public DependentFields<Derived>
 {
 public:
     DerivedFromExternalSpecialization(int i,
-                                      TemplateWithIndependentFields<HasVirtualInDependency> defaultExternalSpecialization =
-                                          TemplateWithIndependentFields<HasVirtualInDependency>());
-    TemplateWithIndependentFields<Base3> returnExternalSpecialization();
+                                      DependentFields<HasVirtualInDependency> defaultExternalSpecialization =
+                                          DependentFields<HasVirtualInDependency>());
+    DependentFields<Base3> returnExternalSpecialization();
 };
 
 class DLL_API DerivedFromSecondaryBaseInDependency : public Derived, public SecondaryBase

Original file line number	Diff line number	Diff line change
`@@ -1322,11 +1322,7 @@ public static string GetSuffixForInternal(Class @class)`
`1322`	`1322`	`return "_Ptr";`
`1323`	`1323`	`return GetSuffixFor(specialization);`
`1324`	`1324`	`}`
`1325`		`- // HACK: Clang can't always resolve complex templates such as the base of std::atomic in msvc`
`1326`		`- return (from @base in @class.Bases`
`1327`		`- let suffix = GetSuffixForInternal(@base.Class)`
`1328`		`- where suffix.Length > 0`
`1329`		`- select suffix).DefaultIfEmpty(string.Empty).First();`
	`1325`	`+ return string.Empty;`
`1330`	`1326`	`}`
`1331`	`1327`
`1332`	`1328`	`public static string GetSuffixFor(Declaration decl)`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,8 @@ private void CleanSpecializations(Class template)`
`138`	`138`	`template.Specializations.All(s => s.Ignore))`
`139`	`139`	`template.ExplicitlyIgnore();`
`140`	`140`
`141`		`- TryMoveExternalSpecializations(template);`
	`141`	`+ if (template.Specializations.Any() && template.HasDependentValueFieldInLayout())`
	`142`	`+ TryMoveExternalSpecializations(template);`
`142`	`143`	`}`
`143`	`144`
`144`	`145`	`/// <summary>`
`@@ -174,17 +175,13 @@ private static Module GetExternalModule(ClassTemplateSpecialization specializati`
`174`	`175`	`{`
`175`	`176`	`Module module = arg.Type.Type.GetModule();`
`176`	`177`	`if (module != null)`
`177`		`- {`
`178`	`178`	`modules.Add(module);`
`179`		`- }`
`180`	`179`	`}`
`181`	`180`	`if (arg.Type.Type.TryGetDeclaration(out ClassTemplateSpecialization nestedSpecialization))`
`182`	`181`	`{`
`183`	`182`	`Module module = GetExternalModule(nestedSpecialization);`
`184`	`183`	`if (module != null)`
`185`		`- {`
`186`	`184`	`modules.Add(module);`
`187`		`- }`
`188`	`185`	`}`
`189`	`186`	`}`
`190`	`187`	`return modules.TopologicalSort(m => m.Dependencies).LastOrDefault();`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,12 @@ void TemplateClass<T>::setField(const T& value)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`template <typename T>`
`74`		`-class TemplateWithIndependentFields`
	`74`	`+class IndependentFields`
	`75`	`+{`
	`76`	`+};`
	`77`	`+`
	`78`	`+template <typename T>`
	`79`	`+class DependentFields`
`75`	`80`	`{`
`76`	`81`	`public:`
`77`	`82`	`class Nested`
`@@ -85,13 +90,13 @@ class TemplateWithIndependentFields`
`85`	`90`	`};`
`86`	`91`
`87`	`92`	`template <typename T>`
`88`		`-const T& TemplateWithIndependentFields<T>::constField() const`
	`93`	`+const T& DependentFields<T>::constField() const`
`89`	`94`	`{`
`90`	`95`	`return *t;`
`91`	`96`	`}`
`92`	`97`
`93`	`98`	`template <typename T>`
`94`		`-typename TemplateWithIndependentFields<T>::Nested TemplateWithIndependentFields<T>::useDependentPointer(const T* t)`
	`99`	`+typename DependentFields<T>::Nested DependentFields<T>::useDependentPointer(const T* t)`
`95`	`100`	`{`
`96`	`101`	`return Nested();`
`97`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,11 @@ TemplateClass<int> Derived2::getTemplate()`
`62`	`62`	`return t;`
`63`	`63`	`}`
`64`	`64`
	`65`	`+IndependentFields<int> Derived2::getIndependentSpecialization()`
	`66`	`+{`
	`67`	`+ return independentSpecialization;`
	`68`	`+}`
	`69`	`+`
`65`	`70`	`Derived2::LocalTypedefSpecialization Derived2::getLocalTypedefSpecialization()`
`66`	`71`	`{`
`67`	`72`	`return LocalTypedefSpecialization();`
`@@ -73,13 +78,13 @@ Abstract* Derived2::getAbstract()`
`73`	`78`	`}`
`74`	`79`
`75`	`80`	`DerivedFromExternalSpecialization::DerivedFromExternalSpecialization(int i,`
`76`		`- TemplateWithIndependentFields<HasVirtualInDependency> defaultExternalSpecialization)`
	`81`	`+ DependentFields<HasVirtualInDependency> defaultExternalSpecialization)`
`77`	`82`	`{`
`78`	`83`	`}`
`79`	`84`
`80`		`-TemplateWithIndependentFields<Base3> DerivedFromExternalSpecialization::returnExternalSpecialization()`
	`85`	`+DependentFields<Base3> DerivedFromExternalSpecialization::returnExternalSpecialization()`
`81`	`86`	`{`
`82`		`- return TemplateWithIndependentFields<Base3>();`
	`87`	`+ return DependentFields<Base3>();`
`83`	`88`	`}`
`84`	`89`
`85`	`90`	`int HasVirtualInDependency::callManagedOverride()`