private IEntity[] FindExtension(IType fromType, string name) { IEntity extension = _context.NameResolutionService.ResolveExtension(fromType, name); if (null == extension) { return(Ambiguous.NoEntities); } Ambiguous a = extension as Ambiguous; if (null != a) { return(a.Entities); } return(new IEntity[] { extension }); }
/// <summary> /// Constructs generic entities out of an ambiguous definition. /// </summary> private IEntity ConstructAmbiguousEntity(Ambiguous ambiguousDefinition, Node constructionNode, TypeReferenceCollection argumentNodes) { GenericConstructionChecker checker = new GenericConstructionChecker( TypeSystemServices, constructionNode, argumentNodes, new CompilerErrorCollection()); List <IEntity> matches = new List <IEntity>(ambiguousDefinition.Entities); // Filter matches by genericness, generity and constraints Predicate <IEntity>[] filters = new Predicate <IEntity>[] { checker.NotGenericDefinition, checker.IncorrectGenerity, checker.ViolatesParameterConstraints }; foreach (Predicate <IEntity> filter in filters) { checker.Errors.Clear(); matches.RemoveAll(filter); // If no matches pass the filter, record the first error only // (providing all the distinct errors that occured would be superfluous) if (matches.Count == 0) { Errors.Add(checker.Errors[0]); return(TypeSystemServices.ErrorEntity); } // If only one match passes the filter, continue construction normally if (matches.Count == 1) { return(ConstructEntity(matches[0], constructionNode, argumentNodes)); } } // Several matches have passed the filter - // construct all of them and return another Ambiguous entity IEntity[] constructed = Array.ConvertAll <IEntity, IEntity>( matches.ToArray(), delegate(IEntity def) { return(ConstructEntity(def, constructionNode, argumentNodes)); }); return(new Ambiguous(constructed)); }
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 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; }
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 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; }
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; }
/// <summary> /// Constructs generic entities out of an ambiguous definition. /// </summary> private IEntity ConstructAmbiguousEntity(Node constructionNode, Ambiguous ambiguousDefinition, IType[] typeArguments) { GenericConstructionChecker checker = new GenericConstructionChecker( TypeSystemServices, constructionNode, typeArguments, new CompilerErrorCollection()); List<IEntity> matches = new List<IEntity>(ambiguousDefinition.Entities); // Filter matches by genericness, generity and constraints Predicate<IEntity>[] filters = new Predicate<IEntity>[] { checker.NotGenericDefinition, checker.IncorrectGenerity, checker.ViolatesParameterConstraints }; foreach (Predicate<IEntity> filter in filters) { checker.Errors.Clear(); matches.RemoveAll(filter); // If no matches pass the filter, record the first error only // (providing all the distinct errors that occured would be superfluous) if (matches.Count == 0) { Errors.Add(checker.Errors[0]); return TypeSystemServices.ErrorEntity; } // If only one match passes the filter, continue construction normally if (matches.Count == 1) { return ConstructEntity(constructionNode, matches[0], typeArguments); } } // Several matches have passed the filter - // construct all of them and return another Ambiguous entity IEntity[] constructed = Array.ConvertAll<IEntity, IEntity>( matches.ToArray(), delegate(IEntity def) { return ConstructEntity(constructionNode, def, typeArguments); }); return new Ambiguous(constructed); }
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; }
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 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 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; }
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 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 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 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 IEntity AmbiguousReference(SimpleTypeReference node, Ambiguous entity) { _context.Errors.Add(CompilerErrorFactory.AmbiguousReference(node, node.Name, entity.Entities)); return(TypeSystemServices.ErrorEntity); }
private IEntity ResolveAmbiguousReferenceByAccessibility(Ambiguous candidates) { var newEntities = new List<IEntity>(); foreach (IEntity entity in candidates.Entities) if (!IsInaccessible(entity)) newEntities.Add(entity); return Entities.EntityFromList(newEntities); }
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 ResolveCallableReference(MethodInvocationExpression node, Ambiguous entity) { var genericService = My<GenericsServices>.Instance; var methods = entity.Entities .OfType<IMethod>() .Select(m => { if (m.GenericInfo == null) return m; var inferrer = new GenericParameterInferrer(Context, m, node.Arguments); inferrer.ResolveClosure += ProcessClosureInMethodInvocation; if (!inferrer.Run()) return null; var arguments = inferrer.GetInferredTypes(); if (arguments == null || !genericService.CheckGenericConstruction(m, arguments)) return null; return m.GenericInfo.ConstructMethod(arguments); }).Where(m => m != null).ToArray(); var resolved = CallableResolutionService.ResolveCallableReference(node.Arguments, methods); 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 AmbiguousReference(SimpleTypeReference node, Ambiguous entity) { _context.Errors.Add(CompilerErrorFactory.AmbiguousReference(node, node.Name, entity.Entities)); return TypeSystemServices.ErrorEntity; }