C# IEntity.IsAmbiguous方法代码示例

		/// <summary>
		/// Constructs an entity from a generic definition and arguments, after ensuring the construction is valid.
		/// </summary>
		/// <param name="definition">The generic definition entity.</param>
		/// <param name="constructionNode">The node in which construction occurs.</param>
		/// <param name="typeArguments">The generic type arguments to substitute for generic parameters.</param>
		/// <returns>The constructed entity.</returns>
		public IEntity ConstructEntity(Node constructionNode, IEntity definition, IType[] typeArguments)
		{
			// Ensure definition is a valid entity
			if (definition == null || TypeSystemServices.IsError(definition))
			{
				return TypeSystemServices.ErrorEntity;
			}

			// Ambiguous generic constructions are handled separately
			if (definition.IsAmbiguous())
			{
				return ConstructAmbiguousEntity(constructionNode, (Ambiguous)definition, typeArguments);
			}

			// Check that the construction is valid
			if (!CheckGenericConstruction(constructionNode, definition, typeArguments, true))
			{
				return TypeSystemServices.ErrorEntity;
			}

			return MakeGenericEntity(definition, typeArguments);
		}

        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");
            }
        }

        private static IMethod FindMethodOverridenBy(InternalMethod entity, IEntity candidates)
        {
            if (EntityType.Method == candidates.EntityType)
            {
                var candidate = (IMethod)candidates;
                if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
                    return candidate;
            }

            if (candidates.IsAmbiguous())
                foreach (IMethod candidate in ((Ambiguous) candidates).Entities)
                    if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
                        return candidate;

            return null;
        }

        private IMethod ResolveOperatorEntity(IEntity op, ExpressionCollection args)
        {
            if (op.IsAmbiguous())
                return ResolveAmbiguousOperator(((Ambiguous)op).Entities, args);

            if (EntityType.Method == op.EntityType)
            {
                IMethod candidate = (IMethod)op;
                if (HasOperatorSignature(candidate, args))
                    return candidate;
            }
            return null;
        }

        private IMethod FindConflictingMember(IMethod extension, IEntity entity)
        {
            if (entity.IsAmbiguous())
                return FindConflictingMember(extension, ((Ambiguous)entity).Entities);

            var method = (IMethod)entity;
            return IsConflictingMember(extension, method) ? method : null;
        }