/// <summary> /// Associates the given arguments with the template parameters specified in the type/method declarations /// and filters out unmatching overloads. /// </summary> /// <param name="rawOverloadList">Can be either type results or method results</param> /// <param name="givenTemplateArguments">A list of already resolved arguments passed explicitly /// in the !(...) section of a template instantiation /// or call arguments given in the (...) appendix /// that follows a method identifier</param> /// <param name="isMethodCall">If true, arguments that exceed the expected parameter count will be ignored as far as all parameters could be satisfied.</param> /// <param name="ctxt"></param> /// <returns>A filtered list of overloads which mostly fit to the specified arguments. /// Usually contains only 1 element. /// The 'TemplateParameters' property of the results will be also filled for further usage regarding smart completion etc.</returns> public static AbstractType[] DeduceParamsAndFilterOverloads(IEnumerable <AbstractType> rawOverloadList, IEnumerable <ISemantic> givenTemplateArguments, bool isMethodCall, ResolverContextStack ctxt) { if (rawOverloadList == null) { return(null); } var filteredOverloads = DeduceOverloads(rawOverloadList, givenTemplateArguments, isMethodCall, ctxt); AbstractType[] sortedAndFilteredOverloads = null; // If there are >1 overloads, filter from most to least specialized template param if (filteredOverloads.Count > 1) { sortedAndFilteredOverloads = SpecializationOrdering.FilterFromMostToLeastSpecialized(filteredOverloads, ctxt); } else if (filteredOverloads.Count == 1) { sortedAndFilteredOverloads = new[] { filteredOverloads[0] } } ; else { return(null); } if (sortedAndFilteredOverloads != null && sortedAndFilteredOverloads.Length == 1 && sortedAndFilteredOverloads[0] is TemplateType) { ImplicitTemplateProperties.TryGetImplicitProperty((TemplateType)sortedAndFilteredOverloads[0], ctxt, out sortedAndFilteredOverloads); } return(sortedAndFilteredOverloads); }
/// <summary> /// Associates the given arguments with the template parameters specified in the type/method declarations /// and filters out unmatching overloads. /// </summary> /// <param name="rawOverloadList">Can be either type results or method results</param> /// <param name="givenTemplateArguments">A list of already resolved arguments passed explicitly /// in the !(...) section of a template instantiation /// or call arguments given in the (...) appendix /// that follows a method identifier</param> /// <param name="isMethodCall">If true, arguments that exceed the expected parameter count will be ignored as far as all parameters could be satisfied.</param> /// <param name="ctxt"></param> /// <returns>A filtered list of overloads which mostly fit to the specified arguments. /// Usually contains only 1 element. /// The 'TemplateParameters' property of the results will be also filled for further usage regarding smart completion etc.</returns> public static AbstractType[] DeduceParamsAndFilterOverloads(IEnumerable <AbstractType> rawOverloadList, IEnumerable <ISemantic> givenTemplateArguments, bool isMethodCall, ResolutionContext ctxt, bool hasUndeterminedArguments = false) { if (rawOverloadList == null) { return(null); } var filteredOverloads = hasUndeterminedArguments ? new List <AbstractType>(rawOverloadList) : DeduceOverloads(rawOverloadList, givenTemplateArguments, isMethodCall, ctxt); AbstractType[] sortedAndFilteredOverloads; // If there are >1 overloads, filter from most to least specialized template param if (filteredOverloads.Count > 1) { sortedAndFilteredOverloads = SpecializationOrdering.FilterFromMostToLeastSpecialized(filteredOverloads, ctxt); } else if (filteredOverloads.Count == 1) { sortedAndFilteredOverloads = new[] { filteredOverloads[0] } } ; else { return(null); } if (hasUndeterminedArguments) { return(sortedAndFilteredOverloads); } if (sortedAndFilteredOverloads != null) { filteredOverloads.Clear(); for (int i = sortedAndFilteredOverloads.Length - 1; i >= 0; i--) { var ds = sortedAndFilteredOverloads[i] as DSymbol; if (ds != null && ds.Definition.TemplateConstraint != null) { ctxt.CurrentContext.IntroduceTemplateParameterTypes(ds); try{ var v = Evaluation.EvaluateValue(ds.Definition.TemplateConstraint, ctxt); if (v is VariableValue) { v = new StandardValueProvider(ctxt)[((VariableValue)v).Variable]; } if (!Evaluation.IsFalseZeroOrNull(v)) { filteredOverloads.Add(ds); } }catch {} //TODO: Handle eval exceptions ctxt.CurrentContext.RemoveParamTypesFromPreferredLocals(ds); } else { filteredOverloads.Add(sortedAndFilteredOverloads[i]); } } if (filteredOverloads.Count == 0) { return(null); } sortedAndFilteredOverloads = filteredOverloads.ToArray(); } if (sortedAndFilteredOverloads != null && sortedAndFilteredOverloads.Length == 1) { var t = sortedAndFilteredOverloads [0]; if (t is TemplateType) { return(TryGetImplicitProperty(t as TemplateType, ctxt) ?? sortedAndFilteredOverloads); } if (t is EponymousTemplateType) { return new[] { DeduceEponymousTemplate(t as EponymousTemplateType, ctxt) } } ; } return(sortedAndFilteredOverloads); }