[generator] Cache finding descendants of a GenBase (#441)

Finding the descendants of a `GenBase` is relatively expensive.
Caching the results causes the `GenBase.UpdateEnums()` method to drop
from ~9.5s to ~1s when generating `Mono.Android.dll`.

Author: jpobst

tools/generator/CodeGenerationOptions.cs

@@ -68,7 +68,6 @@ internal CodeGenerator CreateCodeGenerator (TextWriter writer)
 		public bool IgnoreNonPublicType { get; set; }
 		public string AssemblyName { get; set; }
 		public bool UseShortFileNames { get; set; }
-		public IList<GenBase> Gens {get;set;}
 		public int ProductVersion { get; set; }
 		public bool SupportInterfaceConstants { get; set; }
 

tools/generator/CodeGenerator.cs

@@ -11,6 +11,7 @@
 using Java.Interop.Tools.Cecil;
 using Java.Interop.Tools.Diagnostics;
 using Java.Interop.Tools.TypeNameMappings;
+using MonoDroid.Generation.Utilities;
 
 namespace Xamarin.Android.Binder
 {
@@ -130,7 +131,6 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve
 				return;
 			}
 			apiSource = p.ApiSource;
-			opt.Gens = gens;
 
 			// disable interface default methods here, especially before validation.
 			gens = gens.Where (g => !g.IsObfuscated && g.Visibility != "private").ToList ();
@@ -148,8 +148,10 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve
 			foreach (GenBase gen in gens)
 				gen.FillProperties ();
 
+			var cache = new AncestorDescendantCache (gens);
+
 			foreach (var gen in gens)
-				gen.UpdateEnums (opt);
+				gen.UpdateEnums (opt, cache);
 
 			foreach (GenBase gen in gens)
 				gen.FixupMethodOverrides (opt);

tools/generator/Java.Interop.Tools.Generator.ObjectModel/GenBase.cs

@@ -10,6 +10,7 @@
 using System.Collections;
 using System.Security.Policy;
 using System.Text;
+using MonoDroid.Generation.Utilities;
 
 namespace MonoDroid.Generation {
 
@@ -798,24 +799,24 @@ GenBase GetBaseGen (CodeGenerationOptions opt)
 
 		bool enum_updated;
 
-		public virtual void UpdateEnums (CodeGenerationOptions opt)
+		public virtual void UpdateEnums (CodeGenerationOptions opt, AncestorDescendantCache cache)
 		{
 			if (enum_updated || !IsGeneratable)
 				return;
 			enum_updated = true;
 			var baseGen = GetBaseGen (opt);
 			if (baseGen != null)
-				baseGen.UpdateEnums (opt);
+				baseGen.UpdateEnums (opt, cache);
 
 			foreach (Method m in methods) {
-				AutoDetectEnumifiedOverrideParameters (m, opt);
-				AutoDetectEnumifiedOverrideReturn (m, opt);
+				AutoDetectEnumifiedOverrideParameters (m, cache);
+				AutoDetectEnumifiedOverrideReturn (m, cache);
 			}
 			foreach (Property p in Properties)
-				AutoDetectEnumifiedOverrideProperties (p, opt);
+				AutoDetectEnumifiedOverrideProperties (p, cache);
 			UpdateEnumsInInterfaceImplementation ();
 			foreach (var ngen in NestedTypes)
-				ngen.UpdateEnums (opt);
+				ngen.UpdateEnums (opt, cache);
 		}
 
 		public virtual void UpdateEnumsInInterfaceImplementation ()
@@ -951,11 +952,11 @@ static IEnumerable<Method> GetAllMethods (GenBase t)
 			return t.Methods.Concat (t.Properties.Select (p => p.Getter)).Concat (t.Properties.Select (p => p.Setter).Where (m => m != null));
 		}
 
-		static string [] AutoDetectEnumifiedOverrideParameters (MethodBase method, CodeGenerationOptions opt)
+		static string [] AutoDetectEnumifiedOverrideParameters (MethodBase method, AncestorDescendantCache cache)
 		{
 			if (method.Parameters.All (p => p.Type != "int"))
 				return null;
-			var classes = method.DeclaringType.Ancestors ().Concat (method.DeclaringType.Descendants (opt.Gens));
+			var classes = cache.GetAncestorsAndDescendants (method.DeclaringType);
 			classes = classes.Concat (classes.SelectMany(x => x.GetAllImplementedInterfaces ()));
 			foreach (var t in classes) {
 				foreach (var candidate in GetAllMethods (t).Where (m => m.Name == method.Name
@@ -982,11 +983,11 @@ static string [] AutoDetectEnumifiedOverrideParameters (MethodBase method, CodeG
 			return null;
 		}
 
-		static string AutoDetectEnumifiedOverrideReturn (Method method, CodeGenerationOptions opt)
+		static string AutoDetectEnumifiedOverrideReturn (Method method, AncestorDescendantCache cache)
 		{
 			if (method.RetVal.FullName != "int")
 				return null;
-			var classes = method.DeclaringType.Ancestors ().Concat (method.DeclaringType.Descendants (opt.Gens));
+			var classes = cache.GetAncestorsAndDescendants (method.DeclaringType);
 			classes = classes.Concat (classes.SelectMany(x => x.GetAllImplementedInterfaces ()));
 			foreach (var t in classes) {
 				foreach (var candidate in GetAllMethods (t).Where (m => m.Name == method.Name && m.Parameters.Count == method.Parameters.Count)) {
@@ -999,11 +1000,11 @@ static string AutoDetectEnumifiedOverrideReturn (Method method, CodeGenerationOp
 			return null;
 		}
 
-		void AutoDetectEnumifiedOverrideProperties (Property prop, CodeGenerationOptions opt)
+		void AutoDetectEnumifiedOverrideProperties (Property prop, AncestorDescendantCache cache)
 		{
 			if (prop.Type != "int")
 				return;
-			var classes = prop.Getter.DeclaringType.Ancestors ().Concat (prop.Getter.DeclaringType.Descendants (opt.Gens));
+			var classes = cache.GetAncestorsAndDescendants (prop.Getter.DeclaringType);
 			classes = classes.Concat (classes.SelectMany(x => x.GetAllImplementedInterfaces ()));
 			foreach (var t in classes) {
 				foreach (var candidate in t.Properties.Where (p => p.Name == prop.Name)) {

tools/generator/Utilities/AncestorDescendantCache.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MonoDroid.Generation.Utilities
+{
+	// Finding all descendants of a type is expensive, so we cache the results here
+	public class AncestorDescendantCache
+	{
+		readonly List<GenBase> gens;
+		readonly Dictionary<GenBase, IEnumerable<GenBase>> cache = new Dictionary<GenBase, IEnumerable<GenBase>> ();
+
+		public AncestorDescendantCache (List<GenBase> gens)
+		{
+			this.gens = gens;
+		}
+
+		public IEnumerable<GenBase> GetAncestorsAndDescendants (GenBase gen)
+		{
+			if (cache.TryGetValue (gen, out var value))
+				return value;
+
+			var new_value = GetAncestors (gen).Concat (GetDescendants (gen)).ToList ();
+
+			cache [gen] = new_value;
+
+			return new_value;
+		}
+
+		IEnumerable<GenBase> GetAncestors (GenBase gen)
+		{
+			for (var g = gen.BaseGen; g != null; g = g.BaseGen)
+				yield return g;
+		}
+
+		IEnumerable<GenBase> GetDescendants (GenBase gen)
+		{
+			foreach (var directDescendants in gens.Where (x => x.BaseGen == gen)) {
+				yield return directDescendants;
+
+				foreach (var indirectDescendants in GetDescendants (directDescendants))
+					yield return indirectDescendants;
+			}
+		}
+	}
+}

tools/generator/generator.csproj

@@ -105,6 +105,7 @@
     <Compile Include="Java.Interop.Tools.Generator.ObjectModel\Parameter.cs" />
     <Compile Include="Java.Interop.Tools.Generator.ObjectModel\ParameterList.cs" />
     <Compile Include="Java.Interop.Tools.Generator.Transformation\Parser.cs" />
+    <Compile Include="Utilities\AncestorDescendantCache.cs" />
     <Compile Include="Utilities\ProcessRocks.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Java.Interop.Tools.Generator.ObjectModel\Property.cs" />