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

        protected virtual void ProcessMemberReferenceExpression(MemberReferenceExpression node)
        {
            var entity = ResolveMember(node);
            if (null == entity)
                return;

            EnsureRelatedNodeWasVisited(node, entity);
            if (EntityType.Namespace == entity.EntityType)
                MarkRelatedImportAsUsed(node);

            var member = entity as IMember;
            if (member != null)
            {
                if (!AssertTargetContext(node, member))
                {
                    Error(node);
                    return;
                }

                if (EntityType.Method != member.EntityType)
                    BindExpressionType(node, GetInferredType(member));
                else
                    BindExpressionType(node, member.Type);
            }

            // TODO: check for generic methods with no generic args here
            if (EntityType.Property == entity.EntityType)
            {
                IProperty property = (IProperty)entity;
                if (property.IsIndexedProperty())
                {
                    if (!AstUtil.IsTargetOfSlicing(node)
                        && (!property.IsExtension || property.GetParameters().Length > 1))
                    {
                        Error(node, CompilerErrorFactory.PropertyRequiresParameters(MemberAnchorFor(node), entity));
                        return;
                    }
                }
                if (IsWriteOnlyProperty(property) && !IsBeingAssignedTo(node))
                {
                    Error(node, CompilerErrorFactory.PropertyIsWriteOnly(MemberAnchorFor(node), entity));
                }
            }
            else if (EntityType.Event == entity.EntityType)
            {
                if (!AstUtil.IsTargetOfMethodInvocation(node) &&
                    !AstUtil.IsLhsOfInPlaceAddSubtract(node))
                {
                    if (CurrentType == member.DeclaringType)
                    {
                        InternalEvent ev = (InternalEvent)entity;
                        node.Name = ev.BackingField.Name;
                        node.Entity = ev.BackingField;
                        BindExpressionType(node, ev.BackingField.Type);
                        return;
                    }
                    else if (!node.IsTargetOfAssignment()
                             || !IsNull(((BinaryExpression)node.ParentNode).Right))
                    {
                        Error(node, CompilerErrorFactory.EventIsNotAnExpression(node, entity));
                    }
                    else //event=null
                    {
                        EnsureInternalEventInvocation((IEvent) entity, node);
                    }
                }
            }

            Bind(node, entity);
            PostProcessReferenceExpression(node);
        }