Use methodKey accessor to eliminate closures in signature calls.

Author: iskiselev

JSIL.Libraries/Sources/JSIL.Core.js

@@ -8081,6 +8081,10 @@ JSIL.InterfaceMethod = function (typeObject, methodName, methodInfo) {
     return this.signature != null ? JSIL.$GetSignaturePrefixForType(typeObject) + this.methodNonQualifiedKey : this.qualifiedName;
   });
 
+  JSIL.SetLazyValueProperty(this, "methodKeyNonVirtual", function () {
+    return "i$" + this.methodKey;
+  });
+
   JSIL.SetLazyValueProperty(this, "methodNonQualifiedKey", function () {
     return this.signature != null ? this.signature.GetNamedKey(this.methodName, true) : this.methodName;
   });
@@ -8263,7 +8267,7 @@ JSIL.InterfaceMethod.prototype.$MakeCallMethod = function (isVirtual, isStatic)
         ? "CallVariantInterface"
         : "CallInterface");
 
-    var methodKey = isStatic? this.methodNonQualifiedKey : (isVirtual ? this.methodKey : "i$" + this.methodKey);
+    var methodKey = isStatic ? this.methodNonQualifiedKey : (isVirtual ? this.methodKey : this.methodKeyNonVirtual);
 
     return this.$MakeInlineCacheBody(callType, methodKey, this.fallbackMethod);
   } else {

JSIL/JavascriptAstEmitter.cs

@@ -2338,26 +2338,53 @@ public void VisitNode (JSInvocationExpression invocation) {
                 };
 
                 if (isOverloaded) {
-                    ReferenceContext.InvokingMethod = jsm.Reference;
-                    SignatureCacher.WriteQualifiedSignatureToOutput(
-                        Output, this, Stack.OfType<JSFunctionExpression>().FirstOrDefault(),
-                        jsm,
-                        ReferenceContext
-                        );
+                    if (!method.DeclaringType.IsInterface) {
+                        if (isStatic) {
+                            Visit(invocation.Type);
+                        } else {
+                            Visit(invocation.ThisReference, "ThisReference");
+                        }
 
-                    Output.Dot();
-                    Output.WriteRaw(isStatic ? "CallStatic" : invocation.ExplicitThis ? "CallNonVirtual" : "Call");
+                        Output.OpenBracket();
+                        ReferenceContext.InvokingMethod = jsm.Reference;
+                        SignatureCacher.WriteQualifiedSignatureToOutput(
+                            Output, this, Stack.OfType<JSFunctionExpression>().FirstOrDefault(),
+                            jsm,
+                            ReferenceContext
+                            );
+                        Output.Dot();
+                        Output.WriteRaw(isStatic ? "methodNonQualifiedKey" : (invocation.ExplicitThis ? "methodKeyNonVirtual" : "methodKey"));
+                        Output.CloseBracket();
 
-                    Output.LPar();
-                    if (!isStatic) {
-                        Visit(invocation.ThisReference, "ThisReference");
-                        Output.Comma();
-                    }
+                        Output.LPar();
+                        if (hasGenericArguments) {
+                            Output.CommaSeparatedList(invocation.GenericArguments, ReferenceContext, ListValueType.TypeIdentifier);
 
-                    genericArgs();
+                            if (hasArguments)
+                                Output.Comma();
+                        }
+                    } else {
+                        ReferenceContext.InvokingMethod = jsm.Reference;
+                        SignatureCacher.WriteQualifiedSignatureToOutput(
+                            Output, this, Stack.OfType<JSFunctionExpression>().FirstOrDefault(),
+                            jsm,
+                            ReferenceContext
+                            );
 
-                    if (hasArguments)
-                        Output.Comma();
+                        Output.Dot();
+                        Output.WriteRaw(isStatic ? "CallStatic" : invocation.ExplicitThis ? "CallNonVirtual" : "Call");
+
+                        Output.LPar();
+                        if (!isStatic) {
+                            Visit(invocation.ThisReference, "ThisReference");
+                            Output.Comma();
+                        }
+
+                        genericArgs();
+
+                        if (hasArguments)
+                            Output.Comma();
+                    }
                 } else {
                     if (isStatic) {
                         if (!invocation.Type.IsNull) {