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