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

        void PostProcessReferenceExpression(ReferenceExpression node)
        {
            var entity = GetEntity(node);
            switch (entity.EntityType)
            {
                case EntityType.Type:
                    {
                        BindNonGenericTypeReferenceExpressionType(node, (IType)entity);
                        break;
                    }

                case EntityType.Method:
                    {
                        var method = entity as IMethod;
                        if (null != method && IsGenericMethod(method) && IsStandaloneReference(node) && !IsSubjectToGenericArgumentInference(node))
                            CannotInferGenericMethodArguments(node, method);
                        break;
                    }

                case EntityType.Ambiguous:
                    {
                        var ambiguous = (Ambiguous) entity;
                        var resolvedEntity = ResolveAmbiguousReference(node, ambiguous);
                        var resolvedMember = resolvedEntity as IMember;
                        if (null != resolvedMember)
                        {
                            ResolveMemberInfo(node, resolvedMember);
                            break;
                        }
                        if (resolvedEntity is IType)
                        {
                            BindNonGenericTypeReferenceExpressionType(node, (IType)resolvedEntity);
                            break;
                        }
                        if (!AstUtil.IsTargetOfMethodInvocation(node)
                            && !AstUtil.IsTargetOfSlicing(node)
                            && !node.IsTargetOfAssignment())
                        {
                            Error(node, CompilerErrorFactory.AmbiguousReference(
                                node,
                                node.Name,
                                ambiguous.Entities));
                        }
                        break;
                    }

                case EntityType.Namespace:
                    {
                        if (IsStandaloneReference(node))
                            Error(node, CompilerErrorFactory.NamespaceIsNotAnExpression(node, entity.Name));
                        break;
                    }

                case EntityType.Parameter:
                case EntityType.Local:
                    {
                        var local = (ILocalEntity)node.Entity;
                        local.IsUsed = true;
                        BindExpressionType(node, local.Type);
                        break;
                    }

                default:
                    {
                        if (EntityType.BuiltinFunction == entity.EntityType)
                        {
                            CheckBuiltinUsage(node, entity);
                        }
                        else
                        {
                            if (node.ExpressionType == null)
                            {
                                BindExpressionType(node, ((ITypedEntity)entity).Type);
                            }
                        }
                        break;
                    }
            }
        }