public ApplicableFunction FindConstructor(Type t, Operand[] args) { ApplicableFunction ctor = OverloadResolver.Resolve(GetConstructors(t), TypeMapper, args); if (ctor == null) { throw new MissingMemberException(Messages.ErrMissingConstructor); } return(ctor); }
public ContextualOperand New(Type type, params Operand[] args) { ApplicableFunction ctor = OverloadResolver.Resolve(_typeMapper.TypeInfo.GetConstructors(type), _typeMapper, args); if (ctor == null) { throw new MissingMethodException(Messages.ErrMissingConstructor); } return(new ContextualOperand(new NewObject(ctor, args), _typeMapper)); }
public static Operand New(Type type, params Operand[] args) { ApplicableFunction ctor = OverloadResolver.Resolve(TypeInfo.GetConstructors(type), args); if (ctor == null) { throw new MissingMethodException(Properties.Messages.ErrMissingConstructor); } return(new NewObject(ctor, args)); }
public static ApplicableFunction FindConstructor(Type t, Operand[] args) { ApplicableFunction ctor = OverloadResolver.Resolve(GetConstructors(t), args); if (ctor == null) { throw new MissingMemberException("Cannot find constructor"); } return(ctor); }
public static ApplicableFunction FindMethod(Type t, string name, Operand[] args, bool @static) { for (; t != null; t = t.BaseType) { ApplicableFunction af = OverloadResolver.Resolve(Filter(GetMethods(t), name, false, @static, false), args); if (af != null) { return(af); } } throw new MissingMethodException(Properties.Messages.ErrMissingMethod); }
public ApplicableFunction FindMethod(Type t, string name, Operand[] args, bool @static) { foreach (Type type in SearchableTypes(t)) { IEnumerable <IMemberInfo> methods = GetMethods(type); IEnumerable <IMemberInfo> filter = Filter(methods, name, false, @static, false); ApplicableFunction af = OverloadResolver.Resolve(filter, TypeMapper, args); if (af != null) { return(af); } } throw new MissingMethodException(Messages.ErrMissingMethod); }
public static ApplicableFunction FindMethod(Type t, string name, Operand[] args, bool allowOverrides, bool @static) { Type ot = t; for (; t != null; t = t.BaseType) { ApplicableFunction af = OverloadResolver.Resolve(Filter(GetMethods(t), name, false, @static, allowOverrides), args); if (af != null) { return(af); } } throw new MissingMethodException("Cannot find method" + " " + name + " in " + ot.FullName); }
public static ApplicableFunction FindProperty(Type t, string name, Operand[] indexes, bool @static) { if (name == null) { name = GetDefaultMember(t); } for (; t != null; t = t.BaseType) { ApplicableFunction af = OverloadResolver.Resolve(Filter(GetProperties(t), name, false, @static, false), indexes); if (af != null) { return(af); } } throw new MissingMemberException(Properties.Messages.ErrMissingProperty); }
public ApplicableFunction FindMethod(MethodInfo method) { var t = method.ReflectedType; foreach (Type type in SearchableTypes(t)) { IEnumerable <IMemberInfo> methods = GetMethods(type); IEnumerable <IMemberInfo> filter = Filter(methods, method.Name, false, method.IsStatic, !type.IsValueType); ApplicableFunction af = OverloadResolver.ResolveStrict(filter, TypeMapper, ArrayUtils.GetTypes(method.GetParameters())); if (af != null) { return(af); } } throw new MissingMethodException(Properties.Messages.ErrMissingMethod + ": " + method.ToString()); }
public static ApplicableFunction FindProperty(Type t, string name, Operand[] indexes, bool @static) { if (name == null) { name = GetDefaultMember(t); } var ot = t; for (; t != null; t = t.BaseType) { ApplicableFunction af = OverloadResolver.Resolve(Filter(GetProperties(t), name, false, @static, false), indexes); if (af != null) { return(af); } } throw new MissingMemberException("Cannot find property" + " " + name + " in " + ot.FullName); }
internal List <ApplicableFunction> FindUserCandidates(ITypeMapper typeMapper, params Operand[] args) { List <Type> usedTypes = new List <Type>(); List <ApplicableFunction> candidates = null; string name = "op_" + MethodName; bool expandedCandidates = false; foreach (Operand arg in args) { for (Type t = Operand.GetType(arg, typeMapper); t != null && t != typeMapper.MapType(typeof(object)) && (t.IsClass || t.IsValueType) && !usedTypes.Contains(t); t = t.IsValueType ? null : t.BaseType) { usedTypes.Add(t); OverloadResolver.FindApplicable(ref candidates, ref expandedCandidates, typeMapper.TypeInfo.Filter(typeMapper.TypeInfo.GetMethods(t), name, true, true, false), typeMapper, args); } } if (expandedCandidates) { OverloadResolver.RemoveExpanded(candidates); } return(candidates); }