clojure.lang.GenClass.EmitMethods C# (CSharp) Метод

        private static void EmitMethods(TypeBuilder proxyTB, 
            List<MethodSignature> sigs,
            Dictionary<string,List<MethodSignature>> overloads,
            Dictionary<string,FieldBuilder> varMap,
            IPersistentMap exposesMethods)
        {
            foreach (MethodSignature sig in sigs)
            {
                FieldBuilder regularFB = varMap[sig.Name];
                FieldBuilder overloadFB = null;
                if (overloads.ContainsKey(sig.Name))
                    overloadFB = varMap[OverloadName(sig)];

                switch (sig.Source)
                {
                    case "super":
                        EmitForwardingMethod(proxyTB, false, regularFB, overloadFB, sig,
                            delegate(ILGen gen)
                            {
                                gen.EmitLoadArg(0);                             // gen.Emit(OpCodes.Ldarg_0);
                                for (int i = 0; i < sig.ParamTypes.Length; i++)
                                    gen.EmitLoadArg(i + 1);                     // gen.Emit(OpCodes.Ldarg, (i + 1));
                                gen.Emit(OpCodes.Call, sig.Method);             // not gen.EmitCall(sig.Method) -- we need call versus callvirt
                            });
                        break;
                    case "interface":
                        EmitForwardingMethod(proxyTB, false, regularFB, overloadFB, sig,
                            delegate(ILGen gen)
                            {
                                EmitUnsupported(gen, sig.Name);
                            });
                        break;
                    default:
                        EmitForwardingMethod(proxyTB, sig.IsStatic, regularFB, overloadFB, sig,
                            delegate(ILGen gen)
                            {
                                EmitUnsupported(gen, sig.Name);
                            });
                        break;
                }
            }

            if (exposesMethods != null)
            {
                foreach (MethodSignature sig in sigs)
                {
                    if (sig.Source == "super")
                    {
                        Symbol name = Symbol.intern(sig.Name);
                        if (exposesMethods.containsKey(name))
                            CreateSuperCall(proxyTB, (Symbol)exposesMethods.valAt(name), sig.Method);
                    }
                }
            }
        }