C# TypeSystem.Ambiguous类代码示例

 private IEntity ResolveAmbiguousMethodReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
 {
     //BOO-656
     if (!AstUtil.IsTargetOfMethodInvocation(node)
         && !AstUtil.IsTargetOfSlicing(node)
         && !node.IsTargetOfAssignment())
     {
         return candidates.Entities[0];
     }
     return candidates;
 }

        private IEntity ResolveAmbiguousPropertyReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
        {
            IEntity[] entities = candidates.Entities;
            IEntity[] getters = GetGetMethods(entities);
            IEntity found = GetCorrectCallableReference(node, args, getters);
            if (null != found && EntityType.Method == found.EntityType)
            {
                IProperty property = (IProperty)entities[GetIndex(getters, found)];
                BindProperty(node, property);
                return property;
            }

            return candidates;
        }

 private List<IEntity> GetMatchesByGenericity(ReferenceExpression node, Ambiguous candidates)
 {
     bool isGenericReference = (node.ParentNode is GenericReferenceExpression);
     List<IEntity> matches = new List<IEntity>();
     foreach (IEntity candidate in candidates.Entities)
     {
         IType type = candidate as IType;
         bool isGenericType = (type != null && type.GenericInfo != null);
         if (isGenericType == isGenericReference)
         {
             matches.Add(candidate);
         }
     }
     return matches;
 }

        private IEntity ResolveAmbiguousLValue(Expression sourceNode, Ambiguous candidates, Expression rvalue)
        {
            if (!candidates.AllEntitiesAre(EntityType.Property)) return null;

            IEntity[] entities = candidates.Entities;
            IEntity[] getters = GetSetMethods(entities);
            ExpressionCollection args = new ExpressionCollection();
            args.Add(rvalue);
            IEntity found = GetCorrectCallableReference(sourceNode, args, getters);
            if (null != found && EntityType.Method == found.EntityType)
            {
                IProperty property = (IProperty)entities[GetIndex(getters, found)];
                BindProperty(sourceNode, property);
                return property;
            }
            return null;
        }

 public static IEntity GetEntityFromList(IList list)
 {
     IEntity element = null;
     if (list.Count > 0)
     {
         if (list.Count > 1)
         {
             element = new Ambiguous(list);
         }
         else
         {
             element = (IEntity)list[0];
         }
         list.Clear();
     }
     return element;
 }

        private IEntity ResolveCallableReference(MethodInvocationExpression node, Ambiguous entity)
        {
            IEntity resolved = CallableResolutionService.ResolveCallableReference(node.Arguments, entity.Entities);
            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;
        }

 private IEntity MapAmbiguousEntity(Ambiguous source)
 {
     // Map each individual entity in the ambiguous list
     return new Ambiguous(Array.ConvertAll<IEntity, IEntity>(source.Entities, Map));
 }

        private IEntity ResolveAmbiguousTypeReference(ReferenceExpression node, Ambiguous candidates)
        {
            List<IEntity> matches = GetMatchesByGenericity(node, candidates);
            if (matches.Count > 1)
            {
                PreferInternalEntitiesOverNonInternal(matches);
            }

            if (matches.Count == 1)
            {
                Bind(node, matches[0]);
            }
            else
            {
                Bind(node, new Ambiguous(matches));
            }

            return node.Entity;
        }

        private IEntity ResolveAmbiguousReferenceByAccessibility(Ambiguous candidates)
        {
            List newEntities = new List();
            foreach (IEntity entity in candidates.Entities)
            {
                if (!IsInaccessible(entity))
                { newEntities.Add(entity); }
            }

            if (newEntities.Count == 1)
            { return (IEntity)newEntities[0]; }

            return new Ambiguous(newEntities);
        }

        private IEntity ResolveAmbiguousTypeReference(ReferenceExpression node, Ambiguous candidates)
        {
            bool isGenericReference = (node.ParentNode is GenericReferenceExpression);

            List matches = new List();

            foreach (IEntity candidate in candidates.Entities)
            {
                IType type = candidate as IType;
                bool isGenericType = (type != null && type.GenericInfo != null);
                if (isGenericType == isGenericReference)
                {
                    matches.Add(candidate);
                }
            }

            if (matches.Count == 1)
            {
                Bind(node, (IEntity)matches[0]);
            }
            else
            {
                Bind(node, new Ambiguous(matches));
            }

            return node.Entity;
        }

        private IEntity ResolveAmbiguousReference(ReferenceExpression node, Ambiguous candidates)
        {
            if (!AstUtil.IsTargetOfSlicing(node)
                && !AstUtil.IsLhsOfAssignment(node))
            {
                if (candidates.AllEntitiesAre(EntityType.Property))
                {
                    return ResolveAmbiguousPropertyReference(node, candidates, EmptyExpressionCollection);
                }
                else if (candidates.AllEntitiesAre(EntityType.Method))
                {
                    return ResolveAmbiguousMethodReference(node, candidates, EmptyExpressionCollection);
                    }
                else if (candidates.AllEntitiesAre(EntityType.Type))
                {
                    return ResolveAmbiguousTypeReference(node, candidates);
                }
            }

            return ResolveAmbiguousReferenceByAccessibility(candidates);
        }

        private IEntity ResolveAmbiguousExtension(MethodInvocationExpression node, Ambiguous ambiguous)
        {
            IEntity resolved = ResolveCallableReference(node, ambiguous);
            if (null != resolved) return resolved;

            return CantResolveAmbiguousMethodInvocation(node, ambiguous.Entities);
        }

        protected virtual IEntity ResolveAmbiguousMethodInvocation(MethodInvocationExpression node, Ambiguous entity)
        {
            _context.TraceVerbose("{0}: resolving ambigous method invocation: {1}", node.LexicalInfo, entity);

            IEntity resolved = ResolveCallableReference(node, entity);
            if (null != resolved) return resolved;

            if (TryToProcessAsExtensionInvocation(node)) return null;

            return CantResolveAmbiguousMethodInvocation(node, entity.Entities);
        }

        private IEntity ResolveAmbiguousReference(ReferenceExpression node, Ambiguous candidates)
        {
            var resolved = ResolveAmbiguousReferenceByAccessibility(candidates);
            var accessibleCandidates = resolved as Ambiguous;

            if (accessibleCandidates == null || AstUtil.IsTargetOfSlicing(node) || node.IsTargetOfAssignment())
                return resolved;

            if (accessibleCandidates.AllEntitiesAre(EntityType.Property))
                return ResolveAmbiguousPropertyReference(node, accessibleCandidates, EmptyExpressionCollection);

            if (accessibleCandidates.AllEntitiesAre(EntityType.Method))
                return ResolveAmbiguousMethodReference(node, accessibleCandidates, EmptyExpressionCollection);

            if (accessibleCandidates.AllEntitiesAre(EntityType.Type))
                return ResolveAmbiguousTypeReference(node, accessibleCandidates);

            return resolved;
        }

 IEntity ResolveMacroExtensionType(MacroStatement node, Ambiguous extensions)
 {
     if (null == extensions)
         return null;
     foreach (var entity in extensions.Entities)
     {
         var extensionType = ResolveMacroExtensionType(node, entity as IMethod);
         if (null != extensionType)
             return extensionType;
     }
     return null;
 }