Boo.Lang.Compiler.Steps.ProcessMethodBodies.ResolveCallableReference C# (CSharp) Метод

        private IEntity ResolveCallableReference(MethodInvocationExpression node, Ambiguous entity)
        {
            var genericService = My<GenericsServices>.Instance;
            var methods = entity.Entities
                .OfType<IMethod>()
                .Select(m => {
                    if (m.GenericInfo == null)
                        return m;

                    var inferrer = new GenericParameterInferrer(Context, m, node.Arguments);
                    inferrer.ResolveClosure += ProcessClosureInMethodInvocation;
                    if (!inferrer.Run())
                        return null;
                    var arguments = inferrer.GetInferredTypes();
                    if (arguments == null || !genericService.CheckGenericConstruction(m, arguments))
                        return null;
                    return m.GenericInfo.ConstructMethod(arguments);
                }).Where(m => m != null).ToArray();

            var resolved = CallableResolutionService.ResolveCallableReference(node.Arguments, methods);
            if (null == resolved)
                return null;

            IMember member = (IMember)resolved;
            if (NodeType.ReferenceExpression == node.Target.NodeType)
            {
                ResolveMemberInfo((ReferenceExpression)node.Target, member);
            }
            else
            {
                Bind(node.Target, member);
                BindExpressionType(node.Target, member.Type);
            }
            return resolved;
        }