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

        void SliceMember(SlicingExpression node, IEntity member)
        {
            EnsureRelatedNodeWasVisited(node, member);
            if (node.IsTargetOfAssignment())
            {
                // leave it to LeaveBinaryExpression to resolve
                Bind(node, member);
                return;
            }

            MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
            foreach (Slice index in node.Indices)
            {
                mie.Arguments.Add(index.Begin);
            }

            IMethod getter = null;
            if (member.IsAmbiguous())
            {
                IEntity result = ResolveAmbiguousPropertyReference((ReferenceExpression)node.Target, (Ambiguous)member, mie.Arguments);
                IProperty found = result as IProperty;
                if (null != found)
                {
                    getter = found.GetGetMethod();
                }
                else if (result.IsAmbiguous())
                {
                    Error(node);
                    return;
                }
            }
            else if (EntityType.Property == member.EntityType)
            {
                getter = ((IProperty)member).GetGetMethod();
            }

            if (null != getter)
            {
                if (AssertParameters(node, getter, mie.Arguments))
                {
                    Expression target = GetIndexedPropertySlicingTarget(node);

                    mie.Target = CodeBuilder.CreateMemberReference(target, getter);
                    BindExpressionType(mie, getter.ReturnType);

                    node.ParentNode.Replace(node, mie);
                }
                else
                {
                    Error(node);
                }
            }
            else
            {
                NotImplemented(node, "slice for anything but arrays and default properties");
            }
        }