/// <summary>
/// Called when the user is accessing a protected or private member on a get.
///
/// The default implementation allows access to the fields or properties using reflection.
/// </summary>
public virtual ErrorInfo MakeNonPublicMemberGetError(OverloadResolverFactory resolverFactory, MemberTracker member, Type type, DynamicMetaObject instance) {
switch (member.MemberType) {
case TrackerTypes.Field:
FieldTracker ft = (FieldTracker)member;
return ErrorInfo.FromValueNoError(
Ast.Call(
AstUtils.Convert(AstUtils.Constant(ft.Field), typeof(FieldInfo)),
typeof(FieldInfo).GetMethod("GetValue"),
AstUtils.Convert(instance.Expression, typeof(object))
)
);
case TrackerTypes.Property:
PropertyTracker pt = (PropertyTracker)member;
return ErrorInfo.FromValueNoError(
MemberTracker.FromMemberInfo(pt.GetGetMethod(true)).Call(resolverFactory, this, instance).Expression
);
default:
throw new InvalidOperationException();
}
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
foreach (Type t in binder.GetContributingTypes(type)) {
MemberGroup res = new MemberGroup(
t.GetMember(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
.Where(ProtectedOnly)
.ToArray());
for (int i = 0; i < res.Count; i++) {
MethodTracker meth = res[i] as MethodTracker;
if (meth == null) {
continue;
}
if (meth.Name == "Finalize" && meth.Method.GetBaseDefinition() == typeof(object).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance)) {
MemberTracker[] retained = new MemberTracker[res.Count - 1];
if (res.Count == 1) {
res = MemberGroup.EmptyGroup;
} else {
for (int j = 0; j < i; j++) {
retained[j] = res[j];
}
for (int j = i + 1; j < res.Count; j++) {
retained[j - 1] = res[j];
}
res = new MemberGroup(retained);
}
break;
}
}
return FilterSpecialNames(res, name, action);
}
return MemberGroup.EmptyGroup;
}
private static bool IsTrackerApplicableForType(Type type, MemberTracker mt) {
return mt.DeclaringType == type || type.IsSubclassOf(mt.DeclaringType);
}
/// <summary>
/// Called when a set is attempting to assign to a field or property from a derived class through the base class.
///
/// The default behavior is to allow the assignment.
/// </summary>
public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, DynamicMetaObject assignedValue, OverloadResolverFactory context) {
switch (assigning.MemberType) {
case TrackerTypes.Property:
PropertyTracker pt = (PropertyTracker)assigning;
MethodInfo setter = pt.GetSetMethod() ?? pt.GetSetMethod(true);
return ErrorInfo.FromValueNoError(
AstUtils.SimpleCallHelper(
setter,
ConvertExpression(
assignedValue.Expression,
setter.GetParameters()[0].ParameterType,
ConversionResultKind.ExplicitCast,
context
)
)
);
case TrackerTypes.Field:
FieldTracker ft = (FieldTracker)assigning;
return ErrorInfo.FromValueNoError(
Expression.Assign(
Expression.Field(null, ft.Field),
ConvertExpression(assignedValue.Expression, ft.FieldType, ConversionResultKind.ExplicitCast, context)
)
);
default:
throw new InvalidOperationException();
}
}
public virtual ErrorInfo MakeContainsGenericParametersError(MemberTracker tracker) {
return ErrorInfo.FromException(
Expression.New(
typeof(InvalidOperationException).GetConstructor(new[] { typeof(string) }),
AstUtils.Constant(Strings.InvalidOperation_ContainsGenericParameters(tracker.DeclaringType.Name, tracker.Name))
)
);
}
/// <summary>
/// Provides an opportunity for languages to replace all MemberInfo's with their own type.
///
/// Alternatlely a language can expose MemberInfo's directly.
/// </summary>
/// <param name="memberTracker">The member which is being returned to the user.</param>
/// <param name="type">Tthe type which the memberTrack was accessed from</param>
/// <returns></returns>
public virtual Expression ReturnMemberTracker(Type type, MemberTracker memberTracker) {
if (memberTracker.MemberType == TrackerTypes.Bound) {
BoundMemberTracker bmt = (BoundMemberTracker)memberTracker;
return Expression.New(
typeof(BoundMemberTracker).GetConstructor(new Type[] { typeof(MemberTracker), typeof(object) }),
AstUtils.Constant(bmt.BoundTo),
bmt.Instance);
}
return AstUtils.Constant(memberTracker);
}
public BoundMemberTracker(MemberTracker tracker, DynamicMetaObject instance) {
_tracker = tracker;
_instance = instance;
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, OldDynamicAction/*!*/ action, Type/*!*/ type, string/*!*/ name) {
foreach (Type t in binder.GetContributingTypes(type)) {
MemberGroup res = new MemberGroup(ArrayUtils.FindAll(t.GetMember(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy), ProtectedOnly));
for (int i = 0; i < res.Count; i++) {
MethodTracker meth = res[i] as MethodTracker;
if (meth == null) {
continue;
}
if (meth.Name == "Finalize" && meth.Method.GetBaseDefinition() == typeof(object).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance)) {
MemberTracker[] retained = new MemberTracker[res.Count - 1];
if (res.Count == 1) {
res = MemberGroup.EmptyGroup;
} else {
for (int j = 0; j < i; j++) {
retained[j] = res[j];
}
for (int j = i + 1; j < res.Count; j++) {
retained[j - 1] = res[j];
}
res = new MemberGroup(retained);
}
break;
}
}
res = FilterSpecialNames(res, name, action);
return GetBaseHelperOverloads(PythonTypeOps.GetFinalSystemType(type), name, res);
}
return MemberGroup.EmptyGroup;
}
public BoundMemberTracker(MemberTracker tracker, DynamicMetaObject instance)
{
_tracker = tracker;
_instance = instance;
}
public BoundMemberTracker(MemberTracker tracker, object instance)
{
BoundTo = tracker;
ObjectInstance = instance;
}
public BoundMemberTracker(MemberTracker tracker, DynamicMetaObject instance)
{
BoundTo = tracker;
Instance = instance;
}
/// <summary>
/// Gets the extension members of the given name from the provided type. Subclasses of the
/// type and their extension members are not searched.
/// </summary>
public MemberGroup GetExtensionMembers(Type declaringType, string name)
{
IList <Type> extTypes = GetExtensionTypes(declaringType);
List <MemberTracker> members = new List <MemberTracker>();
foreach (Type ext in extTypes)
{
foreach (MemberInfo mi in ext.GetMember(name, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
{
if (ext != declaringType)
{
members.Add(MemberTracker.FromMemberInfo(mi, declaringType));
}
else
{
members.Add(MemberTracker.FromMemberInfo(mi));
}
}
// TODO: Support indexed getters/setters w/ multiple methods
MethodInfo getter = null, setter = null, deleter = null;
foreach (MemberInfo mi in ext.GetMember("Get" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(getter == null);
getter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Set" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(setter == null);
setter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Delete" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(deleter == null);
deleter = (MethodInfo)mi;
}
if (getter != null || setter != null || deleter != null)
{
members.Add(new ExtensionPropertyTracker(name, getter, setter, deleter, declaringType));
}
}
if (members.Count != 0)
{
return(MemberGroup.CreateInternal(members.ToArray()));
}
return(MemberGroup.EmptyGroup);
}
public MemberReference(MemberTracker tracker)
{
_memberTracker = tracker;
}
public MemberGroup GetExtensionMembers(Type type, string name)
{
Type curType = type;
do
{
IList <Type> extTypes = GetExtensionTypes(curType);
List <MemberTracker> members = new List <MemberTracker>();
foreach (Type ext in extTypes)
{
foreach (MemberInfo mi in ext.GetMember(name))
{
members.Add(MemberTracker.FromMemberInfo(mi, true));
}
// TODO: Support indexed getters/setters w/ multiple methods
MethodInfo getter = null, setter = null, deleter = null;
foreach (MemberInfo mi in ext.GetMember("Get" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(getter == null);
getter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Set" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(setter == null);
setter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Delete" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(deleter == null);
deleter = (MethodInfo)mi;
}
#if FULL
if (getter != null || setter != null || deleter != null)
{
members.Add(new ExtensionPropertyTracker(name, getter, setter, deleter, curType));
}
#endif
}
if (members.Count != 0)
{
return(MemberGroup.CreateInternal(members.ToArray()));
}
curType = curType.BaseType;
} while (curType != null);
return(MemberGroup.EmptyGroup);
}
public override ErrorInfo/*!*/ MakeStaticAssignFromDerivedTypeError(Type accessingType, MemberTracker info, Expression assignedValue, Expression context) {
return MakeMissingMemberError(accessingType, info.Name);
}
private static Expression ReturnMemberTracker(Type type, MemberTracker memberTracker, bool privateBinding) {
switch (memberTracker.MemberType) {
case TrackerTypes.TypeGroup:
return Ast.Constant(memberTracker);
case TrackerTypes.Type:
return ReturnTypeTracker((TypeTracker)memberTracker);
case TrackerTypes.Bound:
return ReturnBoundTracker((BoundMemberTracker)memberTracker, privateBinding);
case TrackerTypes.Property:
return ReturnPropertyTracker((PropertyTracker)memberTracker, privateBinding);
case TrackerTypes.Event:
return Ast.Call(
typeof(PythonOps).GetMethod("MakeBoundEvent"),
Ast.Constant(PythonTypeOps.GetReflectedEvent((EventTracker)memberTracker)),
Ast.Constant(null),
Ast.Constant(type)
);
case TrackerTypes.Field:
return ReturnFieldTracker((FieldTracker)memberTracker);
case TrackerTypes.MethodGroup:
return ReturnMethodGroup((MethodGroup)memberTracker);
case TrackerTypes.Constructor:
MethodBase[] ctors = CompilerHelpers.GetConstructors(type, privateBinding, true);
object val;
if (PythonTypeOps.IsDefaultNew(ctors)) {
if (IsPythonType(type)) {
val = InstanceOps.New;
} else {
val = InstanceOps.NewCls;
}
} else {
val = PythonTypeOps.GetConstructor(type, InstanceOps.NonDefaultNewInst, ctors);
}
return Ast.Constant(val);
case TrackerTypes.Custom:
return Ast.Constant(((PythonCustomTracker)memberTracker).GetSlot(), typeof(PythonTypeSlot));
}
return null;
}
public BoundMemberTracker(MemberTracker tracker, object instance)
{
_tracker = tracker;
_objInst = instance;
}
private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, DynamicMetaObject instance, DynamicMetaObject target, Type type, MemberTracker tracker)
{
if (instance != null)
{
tracker = tracker.BindToInstance(instance);
}
DynamicMetaObject val = tracker.SetValue(memInfo.ResolutionFactory, this, type, target);
if (val != null)
{
memInfo.Body.FinishCondition(val);
}
else
{
memInfo.Body.FinishCondition(
MakeError(tracker.GetError(this), typeof(object))
);
}
}
/// <summary>
/// Called when a set is attempting to assign to a field or property from a derived class through the base class.
///
/// The default behavior is to allow the assignment.
/// </summary>
public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, DynamicMetaObject assignedValue, OverloadResolverFactory context)
{
switch (assigning.MemberType)
{
case TrackerTypes.Property:
PropertyTracker pt = (PropertyTracker)assigning;
MethodInfo setter = pt.GetSetMethod() ?? pt.GetSetMethod(true);
return(ErrorInfo.FromValueNoError(
AstUtils.SimpleCallHelper(
setter,
ConvertExpression(
assignedValue.Expression,
setter.GetParameters()[0].ParameterType,
ConversionResultKind.ExplicitCast,
context
)
)
));
case TrackerTypes.Field:
FieldTracker ft = (FieldTracker)assigning;
return(ErrorInfo.FromValueNoError(
Expression.Assign(
Expression.Field(null, ft.Field),
ConvertExpression(assignedValue.Expression, ft.FieldType, ConversionResultKind.ExplicitCast, context)
)
));
default:
throw new InvalidOperationException();
}
}
public BoundMemberTracker(MemberTracker tracker, object instance) {
_tracker = tracker;
_objInst = instance;
}
/// <summary>
/// Called when the user is accessing a protected or private member on a get.
///
/// The default implementation allows access to the fields or properties using reflection.
/// </summary>
public virtual ErrorInfo MakeNonPublicMemberGetError(OverloadResolverFactory resolverFactory, MemberTracker member, Type type, DynamicMetaObject instance)
{
switch (member.MemberType)
{
case TrackerTypes.Field:
FieldTracker ft = (FieldTracker)member;
return(ErrorInfo.FromValueNoError(
Ast.Call(
AstUtils.Convert(AstUtils.Constant(ft.Field), typeof(FieldInfo)),
typeof(FieldInfo).GetMethod("GetValue"),
AstUtils.Convert(instance.Expression, typeof(object))
)
));
case TrackerTypes.Property:
PropertyTracker pt = (PropertyTracker)member;
return(ErrorInfo.FromValueNoError(
MemberTracker.FromMemberInfo(pt.GetGetMethod(true)).Call(resolverFactory, this, instance).Expression
));
default:
throw new InvalidOperationException();
}
}
private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, Expression instance) {
if (instance != null) {
tracker = tracker.BindToInstance(instance);
}
Expression val = tracker.GetValue(getMemInfo.CodeContext, this, type);
getMemInfo.Body.FinishCondition(
val != null ?
val :
MakeError(tracker.GetError(this))
);
}
private static bool IsTrackerApplicableForType(Type type, MemberTracker mt)
{
return(mt.DeclaringType == type || type.IsSubclassOf(mt.DeclaringType));
}
public virtual ErrorInfo MakeGenericAccessError(MemberTracker info) {
return ErrorInfo.FromException(
Expression.New(
typeof(MemberAccessException).GetConstructor(new[] { typeof(string) }),
AstUtils.Constant(info.Name)
)
);
}
private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type instanceType, MemberTracker tracker, DynamicMetaObject instance)
{
if (instance != null)
{
tracker = tracker.BindToInstance(instance);
}
DynamicMetaObject val = tracker.GetValue(getMemInfo.ResolutionFactory, this, instanceType);
if (val != null)
{
getMemInfo.Body.FinishCondition(val);
}
else
{
ErrorInfo ei = tracker.GetError(this, instanceType);
if (ei.Kind != ErrorInfoKind.Success && getMemInfo.IsNoThrow)
{
getMemInfo.Body.FinishError(MakeOperationFailed());
}
else
{
getMemInfo.Body.FinishError(MakeError(ei, typeof(object)));
}
}
}
/// <summary>
/// Provides an opportunity for languages to replace all MemberTracker's with their own type.
///
/// Alternatlely a language can expose MemberTracker's directly.
/// </summary>
/// <param name="memberTracker">The member which is being returned to the user.</param>
/// <param name="type">Tthe type which the memberTrack was accessed from</param>
/// <returns></returns>
public virtual DynamicMetaObject ReturnMemberTracker(Type type, MemberTracker memberTracker) {
if (memberTracker.MemberType == TrackerTypes.Bound) {
BoundMemberTracker bmt = (BoundMemberTracker)memberTracker;
return new DynamicMetaObject(
Expression.New(
typeof(BoundMemberTracker).GetConstructor(new[] { typeof(MemberTracker), typeof(object) }),
AstUtils.Constant(bmt.BoundTo),
bmt.Instance.Expression
),
BindingRestrictions.Empty
);
}
return new DynamicMetaObject(AstUtils.Constant(memberTracker), BindingRestrictions.Empty, memberTracker);
}
public BoundMemberTracker(MemberTracker tracker, Expression instance)
{
_tracker = tracker;
_instance = instance;
}
private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, Expression instance) {
if (instance != null) {
tracker = tracker.BindToInstance(instance);
}
Expression val = tracker.GetValue(getMemInfo.CodeContext, this, type);
if (val != null) {
getMemInfo.Body.FinishCondition(val);
} else {
ErrorInfo ei = tracker.GetError(this);
if (ei.Kind != ErrorInfoKind.Success && getMemInfo.IsNoThrow) {
getMemInfo.Body.FinishCondition(MakeOperationFailed());
} else {
getMemInfo.Body.FinishCondition(MakeError(tracker.GetError(this), typeof(object)));
}
}
}
public bool TryGetValue(SymbolId name, out MemberTracker value) {
lock (_topPackage.HierarchyLock) {
LoadNamespaces();
if (_dict.TryGetValue(SymbolTable.IdToString(name), out value)) {
return true;
}
MemberTracker existingTypeEntity = null;
string nameString = SymbolTable.IdToString(name);
if (nameString.IndexOf(Type.Delimiter) != -1) {
value = null;
return false;
}
// Look up the type names and load the type if its name exists
foreach (KeyValuePair<Assembly, TypeNames> kvp in _typeNames) {
if (!kvp.Value.Contains(nameString)) {
continue;
}
existingTypeEntity = kvp.Value.UpdateTypeEntity((TypeTracker)existingTypeEntity, nameString);
}
if (existingTypeEntity == null) {
existingTypeEntity = CheckForUnlistedType(nameString);
}
if (existingTypeEntity != null) {
_dict[SymbolTable.IdToString(name)] = existingTypeEntity;
value = existingTypeEntity;
return true;
}
return false;
}
}
public override ErrorInfo/*!*/ MakeNonPublicMemberGetError(Expression codeContext, MemberTracker member, Type type, Expression instance) {
if (PrivateBinding) {
return base.MakeNonPublicMemberGetError(codeContext, member, type, instance);
}
return ErrorInfo.FromValue(
BindingHelpers.TypeErrorForProtectedMember(type, member.Name)
);
}
private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, DynamicMetaObject instance) {
if (instance != null) {
tracker = tracker.BindToInstance(instance);
}
DynamicMetaObject val = tracker.GetValue(getMemInfo.ResolutionFactory, this, type);
if (val != null) {
getMemInfo.Body.FinishCondition(val);
} else {
ErrorInfo ei = tracker.GetError(this);
if (ei.Kind != ErrorInfoKind.Success && getMemInfo.IsNoThrow) {
getMemInfo.Body.FinishError(MakeOperationFailed());
} else {
getMemInfo.Body.FinishError(MakeError(tracker.GetError(this), typeof(object)));
}
}
}
public override Expression ReturnMemberTracker(Type type, MemberTracker memberTracker) {
Expression res = ReturnMemberTracker(type, memberTracker, PrivateBinding);
return res ?? base.ReturnMemberTracker(type, memberTracker);
}
public BoundMemberTracker(MemberTracker tracker, Expression instance) {
_tracker = tracker;
_instance = instance;
}
private bool IsProtectedSetter(MemberTracker mt) {
PropertyTracker pt = mt as PropertyTracker;
if (pt != null) {
MethodInfo mi = pt.GetSetMethod(true);
if (mi != null && (mi.IsFamily || mi.IsFamilyOrAssembly)) {
return true;
}
}
FieldTracker ft = mt as FieldTracker;
if (ft != null) {
return ft.Field.IsFamily || ft.Field.IsFamilyOrAssembly;
}
return false;
}
private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, DynamicMetaObject instance, DynamicMetaObject target, Type type, MemberTracker tracker, DynamicMetaObject errorSuggestion) {
if (instance != null) {
tracker = tracker.BindToInstance(instance);
}
DynamicMetaObject val = tracker.SetValue(memInfo.ResolutionFactory, this, type, target, errorSuggestion);
if (val != null) {
memInfo.Body.FinishCondition(val);
} else {
memInfo.Body.FinishCondition(
MakeError(tracker.GetError(this), typeof(object))
);
}
}
private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, Expression instance, DynamicMetaObject target, Type type, MemberTracker tracker) {
if (instance != null) {
tracker = tracker.BindToInstance(instance);
}
Expression val = tracker.SetValue(memInfo.CodeContext, this, type, target.Expression);
if (val != null) {
memInfo.Body.FinishCondition(val);
} else {
memInfo.Body.FinishCondition(
MakeError(tracker.GetError(this), typeof(object))
);
}
}
private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, Expression instance, MetaObject target, Type type, MemberTracker tracker)
{
if (instance != null)
{
tracker = tracker.BindToInstance(instance);
}
Expression val = tracker.SetValue(memInfo.CodeContext, this, type, target.Expression);
if (val != null)
{
memInfo.Body.FinishCondition(val);
}
else
{
memInfo.Body.FinishCondition(
MakeError(tracker.GetError(this))
);
}
}
