Pull the method signature cache out of a static field so that it doesn't keep leaking memory indefinitely the more it's used.

Add support for manually emptying various cache data structures when they are no longer in use, to reduce GC complexity.
Change the unit tests so that their output directory is the same as everything else.

Author: kg

JSIL.nunit

@@ -0,0 +1,7 @@
+<NUnitProject>
+  <Settings activeconfig="Debug" />
+  <Config name="Debug" binpathtype="Auto">
+    <assembly path="bin\Tests.dll" />
+  </Config>
+  <Config name="Release" binpathtype="Auto" />
+</NUnitProject>

JSIL/AST/JSNodeTypes.cs

@@ -343,6 +343,8 @@ public override string ToString () {
     }
 
     public class JSFunctionExpression : JSExpression {
+        public readonly MethodTypeFactory MethodTypes;
+
         public readonly JSMethod Method;
 
         public readonly Dictionary<string, JSVariable> AllVariables;
@@ -355,12 +357,14 @@ public class JSFunctionExpression : JSExpression {
 
         public JSFunctionExpression (
             JSMethod method, Dictionary<string, JSVariable> allVariables, 
-            IEnumerable<JSVariable> parameters, JSBlockStatement body
+            IEnumerable<JSVariable> parameters, JSBlockStatement body,
+            MethodTypeFactory methodTypes
         ) {
             Method = method;
             AllVariables = allVariables;
             Parameters = parameters;
             Body = body;
+            MethodTypes = methodTypes;
         }
 
         public override IEnumerable<JSNode> Children {
@@ -390,7 +394,7 @@ public override bool Equals (object obj) {
 
         public override TypeReference GetExpectedType (TypeSystem typeSystem) {
             if (Method != null) {
-                var delegateType = ConstructDelegateType(Method.Reference, typeSystem);
+                var delegateType = MethodTypes.Get(Method.Reference, typeSystem);
                 if (delegateType == null)
                     return Method.Reference.ReturnType;
                 else
@@ -895,59 +899,7 @@ public override void ReplaceChild (JSNode oldChild, JSNode newChild) {
     }
 
     public abstract class JSExpression : JSNode {
-        protected struct MethodSignature {
-            public readonly TypeReference ReturnType;
-            public readonly IEnumerable<TypeReference> ParameterTypes;
-            public readonly int ParameterCount;
-            private readonly int HashCode;
-
-            public MethodSignature (TypeReference returnType, IEnumerable<TypeReference> parameterTypes) {
-                ReturnType = returnType;
-                ParameterTypes = parameterTypes;
-                ParameterCount = parameterTypes.Count();
-
-                HashCode = ReturnType.FullName.GetHashCode() ^ ParameterCount;
-
-                int i = 0;
-                foreach (var p in ParameterTypes) {
-                    HashCode ^= (p.FullName.GetHashCode() << i);
-                    i += 1;
-                }
-            }
-
-            public override int GetHashCode () {
-                return HashCode;
-            }
-
-            public bool Equals (MethodSignature rhs) {
-                if (!ILBlockTranslator.TypesAreEqual(
-                    ReturnType, rhs.ReturnType
-                ))
-                    return false;
-
-                if (ParameterCount != rhs.ParameterCount)
-                    return false;
-
-                using (var e1 = ParameterTypes.GetEnumerator())
-                using (var e2 = rhs.ParameterTypes.GetEnumerator())
-                while (e1.MoveNext() && e2.MoveNext()) {
-                    if (!ILBlockTranslator.TypesAreEqual(e1.Current, e2.Current))
-                        return false;
-                }
-
-                return true;
-            }
-
-            public override bool Equals (object obj) {
-                if (obj is MethodSignature)
-                    return Equals((MethodSignature)obj);
-                else
-                    return base.Equals(obj);
-            }
-        }
-
         public static readonly JSNullExpression Null = new JSNullExpression();
-        protected static readonly ConcurrentCache<MethodSignature, TypeReference> MethodTypeCache = new ConcurrentCache<MethodSignature, TypeReference>();
 
         protected readonly IList<JSExpression> Values;
 
@@ -1014,70 +966,6 @@ public static TypeReference SubstituteTypeArgs (ITypeInfoSource typeInfo, TypeRe
             return TypeAnalysis.SubstituteTypeArgs(type, member);
         }
 
-        public static TypeReference ConstructDelegateType (MethodReference method, TypeSystem typeSystem) {
-            return ConstructDelegateType(
-                method.ReturnType,
-                (from p in method.Parameters select p.ParameterType),
-                typeSystem
-            );
-        }
-
-        public static TypeReference ConstructDelegateType (TypeReference returnType, IEnumerable<TypeReference> parameterTypes, TypeSystem typeSystem) {
-            TypeReference result;
-            var ptypes = parameterTypes.ToArray();
-            var signature = new MethodSignature(returnType, ptypes);
-
-            return MethodTypeCache.GetOrCreate(
-                signature, () => {
-                    TypeReference genericDelegateType;
-
-                    var systemModule = typeSystem.Boolean.Resolve().Module;
-                    bool hasReturnType;
-
-                    if (ILBlockTranslator.TypesAreEqual(typeSystem.Void, returnType)) {
-                        hasReturnType = false;
-                        var name = String.Format("System.Action`{0}", signature.ParameterCount);
-                        genericDelegateType = systemModule.GetType(
-                            signature.ParameterCount == 0 ? "System.Action" : name
-                        );
-                    } else {
-                        hasReturnType = true;
-                        genericDelegateType = systemModule.GetType(String.Format(
-                            "System.Func`{0}", signature.ParameterCount + 1
-                        ));
-                    }
-
-                    if (genericDelegateType != null) {
-                        var git = new GenericInstanceType(genericDelegateType);
-                        foreach (var pt in ptypes)
-                            git.GenericArguments.Add(pt);
-
-                        if (hasReturnType)
-                            git.GenericArguments.Add(returnType);
-
-                        return git;
-                    } else {
-                        var baseType = systemModule.GetType("System.MulticastDelegate");
-
-                        var td = new TypeDefinition(
-                            "JSIL.Meta", "MethodSignature", TypeAttributes.Class | TypeAttributes.NotPublic, baseType
-                        );
-                        td.DeclaringType = baseType;
-
-                        var invoke = new MethodDefinition(
-                            "Invoke", MethodAttributes.Public, returnType
-                        );
-                        foreach (var pt in ptypes)
-                            invoke.Parameters.Add(new ParameterDefinition(pt));
-
-                        td.Methods.Add(invoke);
-
-                        return td;
-                    }
-                }
-            );
-        }
-
         public override void ReplaceChild (JSNode oldChild, JSNode newChild) {
             if (oldChild == null)
                 throw new ArgumentNullException();
@@ -1233,7 +1121,8 @@ public static bool TryMaterialize (JSILIdentifier jsil, JSExpression reference,
                         materialized = JSInvocationExpression.InvokeMethod(
                             invocation.JSType, new JSFakeMethod(
                                 "GetReference", new ByReferenceType(jsm.Reference.ReturnType),
-                                (from p in jsm.Reference.Parameters select p.ParameterType).ToArray()
+                                (from p in jsm.Reference.Parameters select p.ParameterType).ToArray(),
+                                jsil.MethodTypes
                             ), invocation.ThisReference, invocation.Arguments.ToArray(), true
                         );
                         return true;
@@ -1501,10 +1390,6 @@ public override TypeReference GetExpectedType (TypeSystem typeSystem) {
             if (property != null)
                 return property.ReturnType;
 
-            var method = Member as MethodInfo;
-            if (method != null)
-                return JSExpression.ConstructDelegateType(method.Member, typeSystem);
-
             return typeSystem.Void;
         }
     }
@@ -2113,16 +1998,22 @@ public override bool IsConstant {
     }
 
     public class JSMethod : JSIdentifier {
+        public readonly MethodTypeFactory MethodTypes;
+
         public readonly IEnumerable<TypeReference> GenericArguments;
         public readonly MethodReference Reference;
         public readonly MethodInfo Method;
 
-        public JSMethod (MethodReference reference, MethodInfo method, IEnumerable<TypeReference> genericArguments = null) {
+        public JSMethod (
+            MethodReference reference, MethodInfo method, MethodTypeFactory methodTypes,
+            IEnumerable<TypeReference> genericArguments = null          
+        ) {
             if ((reference == null) || (method == null))
                 throw new ArgumentNullException();
 
             Reference = reference;
             Method = method;
+            MethodTypes = methodTypes;
 
             if (genericArguments == null) {
                 var gim = Reference as GenericInstanceMethod;
@@ -2146,39 +2037,30 @@ public QualifiedMemberIdentifier QualifiedIdentifier {
         }
 
         public override TypeReference GetExpectedType (TypeSystem typeSystem) {
-            return ConstructDelegateType(Reference, typeSystem);
+            return MethodTypes.Get(Reference, typeSystem);
         }
     }
 
     public class JSFakeMethod : JSIdentifier {
+        public readonly MethodTypeFactory MethodTypes;
+
         public readonly string Name;
         public readonly TypeReference ReturnType;
         public readonly TypeReference[] ParameterTypes;
 
-        public JSFakeMethod (string name, TypeReference returnType, params TypeReference[] parameterTypes) {
+        public JSFakeMethod (string name, TypeReference returnType, TypeReference[] parameterTypes, MethodTypeFactory methodTypes) {
             Name = name;
             ReturnType = returnType;
-            ParameterTypes = parameterTypes;
-
-            /*
-            if (IsOpenGenericType(ReturnType))
-                throw new Exception("Open generic return type");
-            else if (parameterTypes.Any(IsOpenGenericType))
-                throw new Exception("Open generic parameter type");
-             */
-
-            /*
-            if (ReturnType.IsGenericParameter || parameterTypes.Any((p) => p.IsGenericParameter))
-                throw new ArgumentException()
-             */
+            ParameterTypes = parameterTypes ?? new TypeReference[0];
+            MethodTypes = methodTypes;
         }
 
         public override string Identifier {
             get { return Name; }
         }
 
         public override TypeReference GetExpectedType (TypeSystem typeSystem) {
-            return ConstructDelegateType(
+            return MethodTypes.Get(
                 ReturnType, ParameterTypes, typeSystem
             );
         }

JSIL/AssemblyTranslator.cs

@@ -30,6 +30,7 @@ public class AssemblyTranslator : IDisposable {
         public readonly Configuration Configuration;
 
         public readonly SymbolProvider SymbolProvider = new SymbolProvider();
+        public readonly AssemblyCache AssemblyCache = new AssemblyCache();
         public readonly FunctionCache FunctionCache;
         public readonly AssemblyManifest Manifest;
 
@@ -101,7 +102,7 @@ protected virtual ReaderParameters GetReaderParameters (bool useSymbols, string
                 readerParameters.AssemblyResolver = new AssemblyResolver(new string[] { 
                     Path.GetDirectoryName(mainAssemblyPath),
                     Path.GetDirectoryName(Util.GetPathOfAssembly(Assembly.GetExecutingAssembly())) 
-                });
+                }, AssemblyCache);
             }
 
             if (useSymbols)
@@ -522,8 +523,8 @@ protected void TranslateModule (
 
             context.CurrentModule = module;
 
-            var js = new JSSpecialIdentifiers(context.CurrentModule.TypeSystem);
-            var jsil = new JSILIdentifier(context.CurrentModule.TypeSystem, js);
+            var js = new JSSpecialIdentifiers(FunctionCache.MethodTypes, context.CurrentModule.TypeSystem);
+            var jsil = new JSILIdentifier(FunctionCache.MethodTypes, context.CurrentModule.TypeSystem, js);
 
             // Probably should be an argument, not a member variable...
             var astEmitter = new JavascriptAstEmitter(
@@ -1186,7 +1187,7 @@ private void OptimizeFunction (
             ).Visit(function);
 
             new IntroduceEnumCasts(
-                si.TypeSystem, _TypeInfoProvider
+                si.TypeSystem, _TypeInfoProvider, FunctionCache.MethodTypes
             ).Visit(function);
 
             new ExpandCastExpressions(
@@ -1265,7 +1266,7 @@ protected JSExpression TranslateField (
 
                 return JSInvocationExpression.InvokeStatic(
                     JSDotExpression.New(
-                        dollarIdentifier, new JSFakeMethod("Constant", field.Module.TypeSystem.Void)
+                        dollarIdentifier, new JSFakeMethod("Constant", field.Module.TypeSystem.Void, null, FunctionCache.MethodTypes)
                     ), new JSExpression[] {
                         descriptor, JSLiteral.New(fieldInfo.Name), constant
                     }
@@ -1298,7 +1299,8 @@ protected JSExpression TranslateField (
                         new JSVariable[] { new JSParameter("$", field.DeclaringType, null) },
                         new JSBlockStatement(
                             new JSExpressionStatement(new JSReturnExpression(defaultValue))
-                        )
+                        ),
+                        FunctionCache.MethodTypes
                     );
                 }
 
@@ -1321,7 +1323,7 @@ protected JSExpression TranslateField (
                 } else
                     return JSInvocationExpression.InvokeStatic(
                         JSDotExpression.New(
-                            dollarIdentifier, new JSFakeMethod("Field", field.Module.TypeSystem.Void)
+                            dollarIdentifier, new JSFakeMethod("Field", field.Module.TypeSystem.Void, null, FunctionCache.MethodTypes)
                         ), new JSExpression[] {
                             descriptor, JSLiteral.New(fieldInfo.Name), fieldTypeExpression, defaultValue
                         }
@@ -1671,6 +1673,7 @@ public void Dispose () {
                 _TypeInfoProvider.Dispose();
 
             FunctionCache.Dispose();
+            AssemblyCache.Dispose();
         }
 
         public TypeInfoProvider GetTypeInfoProvider () {

JSIL/CILSupport.cs

@@ -11,10 +11,21 @@
 using Mono.Cecil.Pdb;
 
 namespace JSIL.Internal {
+    public class AssemblyCache : ConcurrentCache<string, AssemblyDefinition>, IDisposable {
+        public void Dispose () {
+            Clear();
+        }
+    }
+
     public class AssemblyResolver : BaseAssemblyResolver {
-        protected readonly ConcurrentCache<string, AssemblyDefinition> Cache = new ConcurrentCache<string, AssemblyDefinition>();
+        protected readonly AssemblyCache Cache = new AssemblyCache();
+
+        public AssemblyResolver (IEnumerable<string> dirs, AssemblyCache cache = null) {
+            if (cache != null)
+                Cache = cache;
+            else
+                Cache = new AssemblyCache();
 
-        public AssemblyResolver (IEnumerable<string> dirs) {
             foreach (var dir in dirs)
                 AddSearchDirectory(dir);
         }