public static MemberTracker FromMemberInfo(MemberInfo member, Type extending) { ContractUtils.RequiresNotNull(member, nameof(member)); lock (_trackers) { MemberTracker res; MemberKey key = new MemberKey(member, extending); if (_trackers.TryGetValue(key, out res)) { return(res); } ConstructorInfo ctor; EventInfo evnt; FieldInfo field; MethodInfo method; TypeInfo type; PropertyInfo property; if ((method = member as MethodInfo) != null) { if (extending != null) { res = new ExtensionMethodTracker(method, member.IsDefined(typeof(StaticExtensionMethodAttribute), false), extending); } else { res = new MethodTracker(method); } } else if ((ctor = member as ConstructorInfo) != null) { res = new ConstructorTracker(ctor); } else if ((field = member as FieldInfo) != null) { res = new FieldTracker(field); } else if ((property = member as PropertyInfo) != null) { res = new ReflectedPropertyTracker(property); } else if ((evnt = member as EventInfo) != null) { res = new EventTracker(evnt); } else if ((type = member as TypeInfo) != null) { res = new NestedTypeTracker(type); } else { throw Error.UnknownMemberType(member); } _trackers[key] = res; return(res); } }
public static MethodGroup GetMethodGroup(string name, MemberGroup mems) { MethodTracker[] trackers = new MethodTracker[mems.Count]; for (int i = 0; i < trackers.Length; i++) { trackers[i] = (MethodTracker)mems[i]; } return new MethodGroup(trackers); }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private void MakeConversionTarget(MethodTracker method, Type fromType, bool isImplicit) { Expression ret = _rule.MakeReturn( Binder, Binder.MakeCallExpression(_rule.Context, method.Method, Ast.Convert(_rule.Parameters[0], fromType)) ); ret = WrapForThrowingTry(isImplicit, ret); _rule.Target = ret; }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private void MakeExtensibleConversionTarget(MethodTracker method, Type fromType, bool isImplicit) { Expression ret = _rule.MakeReturn( Binder, Binder.MakeCallExpression(_rule.Context, method.Method, GetExtensibleValue(fromType)) ); ret = WrapForThrowingTry(isImplicit, ret); _rule.Target = ret; }
public static MemberTracker FromMemberInfo(MemberInfo member, bool isExtension) { Contract.RequiresNotNull(member, "member"); lock (_trackers) { MemberTracker res; if (_trackers.TryGetValue(member, out res)) { return(res); } switch (member.MemberType) { case MemberTypes.Constructor: res = new ConstructorTracker((ConstructorInfo)member); break; case MemberTypes.Event: res = new EventTracker((EventInfo)member); break; case MemberTypes.Field: res = new FieldTracker((FieldInfo)member); break; case MemberTypes.Method: MethodInfo mi = (MethodInfo)member; #if FULL if (isExtension) { res = new MethodTracker(mi, member.IsDefined(typeof(StaticExtensionMethodAttribute), false)); } else { #endif res = new MethodTracker(mi); #if FULL } #endif break; case MemberTypes.TypeInfo: case MemberTypes.NestedType: res = new NestedTypeTracker((Type)member); break; case MemberTypes.Property: res = new ReflectedPropertyTracker((PropertyInfo)member); break; default: throw new InvalidOperationException("unknown type: " + member.MemberType); } _trackers[member] = res; return(res); } }
public static MemberTracker FromMemberInfo(MemberInfo member, Type extending) { ContractUtils.RequiresNotNull(member, "member"); lock (_trackers) { MemberTracker res; MemberKey key = new MemberKey(member, extending); if (_trackers.TryGetValue(key, out res)) { return(res); } switch (member.MemberType) { case MemberTypes.Constructor: res = new ConstructorTracker((ConstructorInfo)member); break; case MemberTypes.Event: res = new EventTracker((EventInfo)member); break; case MemberTypes.Field: res = new FieldTracker((FieldInfo)member); break; case MemberTypes.Method: MethodInfo mi = (MethodInfo)member; if (extending != null) { res = new ExtensionMethodTracker(mi, member.IsDefined(typeof(StaticExtensionMethodAttribute), false), extending); } else { res = new MethodTracker(mi); } break; case MemberTypes.TypeInfo: case MemberTypes.NestedType: res = new NestedTypeTracker((Type)member); break; case MemberTypes.Property: res = new ReflectedPropertyTracker((PropertyInfo)member); break; default: throw Error.UnknownMemberType(member.MemberType); } _trackers[key] = res; return(res); } }
public static MethodGroup GetMethodGroup(string name, MemberGroup mems) { MethodGroup res = null; MethodBase[] bases = new MethodBase[mems.Count]; MethodTracker[] trackers = new MethodTracker[mems.Count]; for (int i = 0; i < bases.Length; i++) { trackers[i] = (MethodTracker)mems[i]; bases[i] = trackers[i].Method; } if (mems.Count != 0) { MethodBaseCache cache = new MethodBaseCache(name, bases); lock (_functions) { if (!_functions.TryGetValue(cache, out res)) { _functions[cache] = res = new MethodGroup(trackers); } } } return res; }
/// <summary> /// Checks if any of the members of the MemberGroup provide the applicable conversion and /// if so uses it to build a conversion rule. /// </summary> private bool TryUserDefinedConversion(Type toType, Type type, MemberGroup conversions, bool isImplicit) { Type checkType = GetUnderlyingType(type); foreach (MemberTracker mt in conversions) { if (mt.MemberType != TrackerTypes.Method) { continue; } MethodTracker method = (MethodTracker)mt; if (isImplicit && method.Method.IsDefined(typeof(ExplicitConversionMethodAttribute), true)) { continue; } if (method.Method.ReturnType == toType) // TODO: IsAssignableFrom? IsSubclass? { ParameterInfo[] pis = method.Method.GetParameters(); if (pis.Length == 1 && pis[0].ParameterType.IsAssignableFrom(checkType)) { // we can use this method if (type == checkType) { MakeConversionTarget(method, type, isImplicit); } else { MakeExtensibleConversionTarget(method, type, isImplicit); } return(true); } } } return(false); }
/// <summary> /// Checks if any of the members of the MemberGroup provide the applicable conversion and /// if so uses it to build a conversion rule. /// </summary> private static DynamicMetaObject TryUserDefinedConversion(ConversionResultKind kind, Type toType, Type type, MemberGroup conversions, bool isImplicit, BindingRestrictions restrictions, DynamicMetaObject arg) { Type checkType = GetUnderlyingType(type); foreach (MemberTracker mt in conversions) { if (mt.MemberType != TrackerTypes.Method) { continue; } MethodTracker method = (MethodTracker)mt; if (isImplicit && method.Method.IsDefined(typeof(ExplicitConversionMethodAttribute), true)) { continue; } if (method.Method.ReturnType == toType) // TODO: IsAssignableFrom? IsSubclass? { ParameterInfo[] pis = method.Method.GetParameters(); if (pis.Length == 1 && pis[0].ParameterType.IsAssignableFrom(checkType)) { // we can use this method if (type == checkType) { return(MakeConversionTarget(kind, method, type, isImplicit, restrictions, arg)); } else { return(MakeExtensibleConversionTarget(kind, method, type, isImplicit, restrictions, arg)); } } } } return(null); }
public static MemberTracker FromMemberInfo(MemberInfo member, Type extending) { ContractUtils.RequiresNotNull(member, "member"); lock (_trackers) { MemberTracker res; MemberKey key = new MemberKey(member, extending); if (_trackers.TryGetValue(key, out res)) return res; switch (member.MemberType) { case MemberTypes.Constructor: res = new ConstructorTracker((ConstructorInfo)member); break; case MemberTypes.Event: res = new EventTracker((EventInfo)member); break; case MemberTypes.Field: res = new FieldTracker((FieldInfo)member); break; case MemberTypes.Method: MethodInfo mi = (MethodInfo)member; if (extending != null) { res = new ExtensionMethodTracker(mi, member.IsDefined(typeof(StaticExtensionMethodAttribute), false), extending); } else { res = new MethodTracker(mi); } break; case MemberTypes.TypeInfo: case MemberTypes.NestedType: res = new NestedTypeTracker((Type)member); break; case MemberTypes.Property: res = new ReflectedPropertyTracker((PropertyInfo)member); break; default: throw Error.UnknownMemberType(member.MemberType); } _trackers[key] = res; return res; } }
public static MemberTracker FromMemberInfo(MemberInfo member, Type extending) { ContractUtils.RequiresNotNull(member, "member"); lock (_trackers) { MemberTracker res; MemberKey key = new MemberKey(member, extending); if (_trackers.TryGetValue(key, out res)) { return res; } ConstructorInfo ctor; EventInfo evnt; FieldInfo field; MethodInfo method; TypeInfo type; PropertyInfo property; if ((method = member as MethodInfo) != null) { if (extending != null) { res = new ExtensionMethodTracker(method, member.IsDefined(typeof(StaticExtensionMethodAttribute), false), extending); } else { res = new MethodTracker(method); } } else if ((ctor = member as ConstructorInfo) != null) { res = new ConstructorTracker(ctor); } else if ((field = member as FieldInfo) != null) { res = new FieldTracker(field); } else if ((property = member as PropertyInfo) != null) { res = new ReflectedPropertyTracker(property); } else if ((evnt = member as EventInfo) != null) { res = new EventTracker(evnt); } else if ((type = member as TypeInfo) != null) { res = new NestedTypeTracker(type.AsType()); } else { throw Error.UnknownMemberType(member); } _trackers[key] = res; return res; } }
/// <summary> /// Helper to produce a conversion rule by calling the method to do the convert. This version takes the parameter /// to be passed to the conversion function and we call it w/ our own value or w/ our Extensible.Value. /// </summary> private static DynamicMetaObject MakeConversionTargetWorker(ConversionResultKind kind, MethodTracker method, bool isImplicit, BindingRestrictions restrictions, Expression param) { return new DynamicMetaObject( WrapForThrowingTry( kind, isImplicit, AstUtils.SimpleCallHelper( method.Method, param ), method.Method.ReturnType ), restrictions ); }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private static DynamicMetaObject MakeExtensibleConversionTarget(ConversionResultKind kind, MethodTracker method, Type fromType, bool isImplicit, BindingRestrictions restrictions, DynamicMetaObject arg) { return MakeConversionTargetWorker(kind, method, isImplicit, restrictions, GetExtensibleValue(fromType, arg)); }
private static bool IsPropertyWithParameters(MethodTracker/*!*/ meth) { if (meth.Method.Name.StartsWith("get_")) { if (!IsMethodDefaultMember(meth)) { ParameterInfo[] args = meth.Method.GetParameters(); if (args.Length > 0) { return true; } } } else if (meth.Method.Name.StartsWith("set_")) { if (!IsMethodDefaultMember(meth)) { ParameterInfo[] args = meth.Method.GetParameters(); if (args.Length > 1) { return true; } } } return false; }
private static MethodTracker/*!*/[]/*!*/ GetEqualityMethods(Type type, string name) { MethodInfo[] mis = GetMethodSet(name, 3); MethodTracker[] trackers = new MethodTracker[mis.Length]; for (int i = 0; i < mis.Length; i++) { trackers[i] = (MethodTracker)MethodTracker.FromMemberInfo(mis[i].MakeGenericMethod(type), type); } return trackers; }
/// <summary> /// Helper to produce a conversion rule by calling the method to do the convert. This version takes the parameter /// to be passed to the conversion function and we call it w/ our own value or w/ our Extensible.Value. /// </summary> private static DynamicMetaObject MakeConversionTargetWorker(ConversionResultKind kind, MethodTracker method, bool isImplicit, BindingRestrictions restrictions, Expression param) { return(new DynamicMetaObject( WrapForThrowingTry( kind, isImplicit, AstUtils.SimpleCallHelper( method.Method, param ), method.Method.ReturnType ), restrictions )); }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private static DynamicMetaObject MakeExtensibleConversionTarget(ConversionResultKind kind, MethodTracker method, Type fromType, bool isImplicit, BindingRestrictions restrictions, DynamicMetaObject arg) { return(MakeConversionTargetWorker(kind, method, isImplicit, restrictions, GetExtensibleValue(fromType, arg))); }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private static DynamicMetaObject MakeConversionTarget(ConversionResultKind kind, MethodTracker method, Type fromType, bool isImplicit, BindingRestrictions restrictions, DynamicMetaObject arg) { Expression param = AstUtils.Convert(arg.Expression, fromType); return(MakeConversionTargetWorker(kind, method, isImplicit, restrictions, param)); }
/// <summary> /// Helper to get a MemberGroup for methods declared on InstanceOps /// </summary> private static MemberGroup/*!*/ GetInstanceOpsMethod(Type/*!*/ extends, params string[]/*!*/ names) { Assert.NotNull(extends, names); MethodTracker[] trackers = new MethodTracker[names.Length]; for (int i = 0; i < names.Length; i++) { trackers[i] = (MethodTracker)MemberTracker.FromMemberInfo(typeof(InstanceOps).GetMethod(names[i]), extends); } return new MemberGroup(trackers); }
/// <summary> /// Helper to produce a conversion rule by calling the helper method to do the convert /// </summary> private static DynamicMetaObject MakeConversionTarget(ConversionResultKind kind, MethodTracker method, Type fromType, bool isImplicit, BindingRestrictions restrictions, DynamicMetaObject arg) { Expression param = AstUtils.Convert(arg.Expression, fromType); return MakeConversionTargetWorker(kind, method, isImplicit, restrictions, param); }
private static bool IsMethodDefaultMember(MethodTracker pt) { foreach (MemberInfo mem in pt.DeclaringType.GetDefaultMembers()) { if (mem.MemberType == MemberTypes.Property) { PropertyInfo pi = (PropertyInfo)mem; if (pi.GetGetMethod() == pt.Method || pi.GetSetMethod() == pt.Method) { return true; } } } return false; }
public static MemberTracker FromMemberInfo(MemberInfo member, bool isExtension) { Contract.RequiresNotNull(member, "member"); lock (_trackers) { MemberTracker res; if (_trackers.TryGetValue(member, out res)) return res; switch (member.MemberType) { case MemberTypes.Constructor: res = new ConstructorTracker((ConstructorInfo)member); break; case MemberTypes.Event: res = new EventTracker((EventInfo)member); break; case MemberTypes.Field: res = new FieldTracker((FieldInfo)member); break; case MemberTypes.Method: MethodInfo mi = (MethodInfo)member; #if FULL if (isExtension) { res = new MethodTracker(mi, member.IsDefined(typeof(StaticExtensionMethodAttribute), false)); } else { #endif res = new MethodTracker(mi); #if FULL } #endif break; case MemberTypes.TypeInfo: case MemberTypes.NestedType: res = new NestedTypeTracker((Type)member); break; case MemberTypes.Property: res = new ReflectedPropertyTracker((PropertyInfo)member); break; default: throw new InvalidOperationException("unknown type: " + member.MemberType); } _trackers[member] = res; return res; } }