public override MemberGroup GetMember(MemberRequestKind action, Type type, string name)
{
if (type == typeof(string))
{
var method = typeof(IronTjs.Builtins.String).GetMethod(name);
if (method != null)
{
return(new MemberGroup(MemberTracker.FromMemberInfo(method, typeof(string))));
}
var property = typeof(IronTjs.Builtins.String).GetField(name + "Property");
if (property != null && property.FieldType == typeof(ExtensionPropertyTracker))
{
return(new MemberGroup((ExtensionPropertyTracker)property.GetValue(null)));
}
return(MemberGroup.EmptyGroup);
}
else if (type.IsSubclassOf(typeof(Exception)))
{
var property = typeof(IronTjs.Builtins.Exception).GetField(name + "Property");
if (property != null && property.FieldType == typeof(ExtensionPropertyTracker))
{
return(new MemberGroup((ExtensionPropertyTracker)property.GetValue(null)));
}
}
return(base.GetMember(action, type, name));
}
public override MemberGroup GetMember(MemberRequestKind actionKind, Type type, string name)
{
var res = base.GetMember(actionKind, type, name);
if (res.Count == 0)
{
List <MemberTracker> trackers = new List <MemberTracker>();
foreach (var method in _extMethodSet.GetExtensionMethods(name))
{
var parameters = method.GetParameters();
if (parameters.Length == 0)
{
continue;
}
var paramType = parameters[0].ParameterType;
if (IsApplicableExtensionMethod(type, paramType))
{
trackers.Add(MemberTracker.FromMemberInfo(method, paramType));
}
}
if (trackers.Count > 0)
{
return(new MemberGroup(trackers.ToArray()));
}
}
return(res);
}
/// <summary>
/// Gets the members that are visible from the provided type of the specified name.
///
/// The default implemetnation first searches the type, then the flattened heirachy of the type, and then
/// registered extension methods.
/// </summary>
public virtual MemberGroup GetMember(MemberRequestKind action, Type type, string name)
{
IEnumerable <MemberInfo> foundMembers = type.GetInheritedMembers(name);
if (!PrivateBinding)
{
foundMembers = CompilerHelpers.FilterNonVisibleMembers(type, foundMembers);
}
MemberGroup members = new MemberGroup(foundMembers.ToArray());
// check for generic types w/ arity...
string genName = name + ReflectionUtils.GenericArityDelimiter;
List <TypeInfo> genTypes = null;
foreach (TypeInfo t in type.GetDeclaredNestedTypes())
{
if (t.IsPublic && t.Name.StartsWith(genName))
{
if (genTypes == null)
{
genTypes = new List <TypeInfo>();
}
genTypes.Add(t);
}
}
if (genTypes != null)
{
List <MemberTracker> mt = new List <MemberTracker>(members);
foreach (TypeInfo t in genTypes)
{
mt.Add(MemberTracker.FromMemberInfo(t));
}
return(MemberGroup.CreateInternal(mt.ToArray()));
}
if (members.Count == 0)
{
members = new MemberGroup(
type.GetInheritedMembers(name, flattenHierarchy: true).WithBindingFlags(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).ToArray()
);
if (members.Count == 0)
{
members = GetAllExtensionMembers(type, name);
}
}
return(members);
}
public override MemberGroup GetMember(MemberRequestKind actionKind, Type type, string name) {
var res = base.GetMember(actionKind, type, name);
if (res.Count == 0) {
List<MemberTracker> trackers = new List<MemberTracker>();
foreach (var method in _extMethodSet.GetExtensionMethods(name)) {
var parameters = method.GetParameters();
if (parameters.Length == 0) {
continue;
}
var paramType = parameters[0].ParameterType;
if (IsApplicableExtensionMethod(type, paramType)) {
trackers.Add(MemberTracker.FromMemberInfo(method, paramType));
}
}
if (trackers.Count > 0) {
return new MemberGroup(trackers.ToArray());
}
}
return res;
}
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
if (!binder.DomainManager.Configuration.PrivateBinding) {
yield break;
}
foreach (MemberInfo mi in type.GetMembers(_privateFlags | BindingFlags.FlattenHierarchy)) {
yield return String.Concat("_", mi.DeclaringType.Name, "__", mi.Name);
}
}
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
EnsureOperatorTable();
foreach (string si in _pythonOperatorTable.Keys) {
yield return si;
}
yield return "__call__";
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
if (binder.DomainManager.Configuration.PrivateBinding) {
// in private binding mode Python exposes private members under a mangled name.
string header = "_" + type.Name + "__";
if (name.StartsWith(header)) {
string memberName = name.Substring(header.Length);
MemberGroup res = new MemberGroup(type.GetMember(memberName, _privateFlags));
if (res.Count > 0) {
return FilterFieldAndEvent(res);
}
res = new MemberGroup(type.GetMember(memberName, BindingFlags.FlattenHierarchy | _privateFlags));
if (res.Count > 0) {
return FilterFieldAndEvent(res);
}
}
}
return MemberGroup.EmptyGroup;
}
/// <summary>
/// Returns a list of members that exist on the type. The ResolvedMember structure indicates both
/// the name and provides the MemberGroup.
/// </summary>
public IList<ResolvedMember/*!*/>/*!*/ ResolveMembers(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
Dictionary<string, ResolvedMember> members = new Dictionary<string, ResolvedMember>();
foreach (string name in GetCandidateNames(binder, action, type)) {
if (members.ContainsKey(name)) {
continue;
}
MemberGroup member = ResolveMember(binder, action, type, name);
if (member.Count > 0) {
members[name] = new ResolvedMember(name, member);
}
}
ResolvedMember[] res = new ResolvedMember[members.Count];
members.Values.CopyTo(res, 0);
return res;
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
if (type.IsSealed() && type.IsAbstract()) {
// static types don't have PythonOperationKind
return MemberGroup.EmptyGroup;
}
// try mapping __*__ methods to .NET method names
PythonOperationKind opMap;
EnsureOperatorTable();
if (_pythonOperatorTable.TryGetValue(name, out opMap)) {
if (IncludeOperatorMethod(type, opMap)) {
OperatorMapping opInfo;
if (IsReverseOperator(opMap)) {
opInfo = OperatorMapping.GetOperatorMapping(opMap & ~PythonOperationKind.Reversed);
} else {
opInfo = OperatorMapping.GetOperatorMapping(opMap);
}
if (opInfo != null) {
foreach (Type curType in binder.GetContributingTypes(type)) {
#if !CLR2
if (curType == typeof(double)) {
if ((opInfo.Operator & PythonOperationKind.Comparison) != 0) {
// we override these with our own comparisons in DoubleOps
continue;
}
} else
#endif
if (curType == typeof(BigInteger)) {
if (opInfo.Operator == PythonOperationKind.Mod ||
opInfo.Operator == PythonOperationKind.RightShift ||
opInfo.Operator == PythonOperationKind.LeftShift ||
opInfo.Operator == PythonOperationKind.Compare ||
opInfo.Operator == PythonOperationKind.Divide) {
// we override these with our own modulus/power PythonOperationKind which are different from BigInteger.
continue;
}
#if !CLR2
} else if (curType == typeof(Complex) && opInfo.Operator == PythonOperationKind.Divide) {
// we override this with our own division PythonOperationKind which is different from .NET Complex.
continue;
#endif
}
Debug.Assert(opInfo.Name != "Equals");
MemberGroup res = binder.GetMember(curType, opInfo.Name);
if (res.Count == 0 && opInfo.AlternateName != null) {
res = binder.GetMember(curType, opInfo.AlternateName);
if (opInfo.AlternateName == "Equals") {
// "Equals" is available as an alternate method name. Because it's also on object and Python
// doesn't define it on object we need to filter it out.
res = FilterObjectEquality(res);
}
res = FilterAlternateMethods(opInfo, res);
}
if (res.Count > 0) {
return FilterForwardReverseMethods(name, res, type, opMap);
}
}
}
}
}
if (name == "__call__") {
MemberGroup res = binder.GetMember(type, "Call");
if (res.Count > 0) {
return res;
}
}
return MemberGroup.EmptyGroup;
}
/// <summary>
/// Gets the statically known member from the type with the specific name. Searches only the specified type to find the member.
/// </summary>
public static MemberGroup/*!*/ GetMember(PythonBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
Assert.NotNull(binder, action, type, name);
PerfTrack.NoteEvent(PerfTrack.Categories.ReflectedTypes, String.Format("LookupMember: {0} {1}", type.Name, name));
return GetMemberGroup(new LookupBinder(binder), action, type, name);
}
/// <summary>
/// Gets the members that are visible from the provided type of the specified name.
///
/// The default implemetnation first searches the type, then the flattened heirachy of the type, and then
/// registered extension methods.
/// </summary>
public virtual MemberGroup GetMember(MemberRequestKind action, Type type, string name) {
IEnumerable<MemberInfo> foundMembers = type.GetInheritedMembers(name);
if (!PrivateBinding) {
foundMembers = CompilerHelpers.FilterNonVisibleMembers(type, foundMembers);
}
MemberGroup members = new MemberGroup(foundMembers.ToArray());
// check for generic types w/ arity...
string genName = name + ReflectionUtils.GenericArityDelimiter;
List<TypeInfo> genTypes = null;
foreach (TypeInfo t in type.GetDeclaredNestedTypes()) {
if (t.IsPublic && t.Name.StartsWith(genName)) {
if (genTypes == null) {
genTypes = new List<TypeInfo>();
}
genTypes.Add(t);
}
}
if (genTypes != null) {
List<MemberTracker> mt = new List<MemberTracker>(members);
foreach (TypeInfo t in genTypes) {
mt.Add(MemberTracker.FromMemberInfo(t));
}
return MemberGroup.CreateInternal(mt.ToArray());
}
if (members.Count == 0) {
members = new MemberGroup(
type.GetInheritedMembers(name, flattenHierarchy: true).WithBindingFlags(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).ToArray()
);
if (members.Count == 0) {
members = GetAllExtensionMembers(type, name);
}
}
return members;
}
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
foreach (Type curType in binder.GetContributingTypes(type)) {
foreach (MemberInfo mi in curType.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) {
if (mi.MemberType == MemberTypes.Method) {
MethodInfo meth = (MethodInfo)mi;
if (meth.IsSpecialName) {
if (meth.IsDefined(typeof(PropertyMethodAttribute), true)) {
if (meth.Name.StartsWith("Get") || meth.Name.StartsWith("Set")) {
yield return meth.Name.Substring(3);
} else {
Debug.Assert(meth.Name.StartsWith("Delete"));
yield return meth.Name.Substring(6);
}
}
continue;
}
}
yield return mi.Name;
}
}
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
Assert.NotNull(binder, action, type, name);
bool equality;
switch (name) {
case "__eq__": equality = true; break;
case "__ne__": equality = false; break;
default:
return MemberGroup.EmptyGroup;
}
if (typeof(IStructuralEquatable).IsAssignableFrom(type)) {
return new MemberGroup(
GetEqualityMethods(type, equality ? "StructuralEqualityMethod" : "StructuralInequalityMethod")
);
#if CLR2
} else if (typeof(IValueEquality).IsAssignableFrom(type)) {
return new MemberGroup(
GetEqualityMethods(type, equality ? "ValueEqualsMethod" : "ValueNotEqualsMethod")
);
#endif
}
return MemberGroup.EmptyGroup;
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
Assert.NotNull(binder, action, type, name);
if (name == _name) {
return _resolver(binder, type);
}
return MemberGroup.EmptyGroup;
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
if (name == ".ctor" || name == ".cctor") return MemberGroup.EmptyGroup;
// normal binding
MemberGroup res;
foreach (Type curType in binder.GetContributingTypes(type)) {
res = FilterSpecialNames(binder.GetMember(curType, name), name, action);
if (res.Count > 0) {
return res;
}
}
if (type.IsInterface) {
foreach (Type t in type.GetInterfaces()) {
res = FilterSpecialNames(binder.GetMember(t, name), name, action);
if (res.Count > 0) {
return res;
}
}
}
return MemberGroup.EmptyGroup;
}
private static MemberGroup/*!*/ FilterSpecialNames(MemberGroup/*!*/ group, string/*!*/ name, MemberRequestKind/*!*/ action) {
Assert.NotNull(group, name, action);
bool filter = true;
if (action == MemberRequestKind.Invoke ||
action == MemberRequestKind.Convert ||
action == MemberRequestKind.Operation) {
filter = false;
}
if (!IsPythonRecognizedOperator(name)) {
filter = false;
}
List<MemberTracker> mts = null;
for (int i = 0; i < group.Count; i++) {
MemberTracker mt = group[i];
bool skip = false;
if (mt.MemberType == TrackerTypes.Method) {
MethodTracker meth = (MethodTracker)mt;
if (meth.Method.IsSpecialName && mt.Name != "op_Implicit" && mt.Name != "op_Explicit") {
if (!IsPropertyWithParameters(meth)) {
skip = true;
}
}
if (meth.Method.IsDefined(typeof(ClassMethodAttribute), true)) {
return new MemberGroup(new ClassMethodTracker(group));
}
} else if (mt.MemberType == TrackerTypes.Property) {
PropertyTracker pt = (PropertyTracker)mt;
if (name == pt.Name && pt.GetIndexParameters().Length > 0 && IsPropertyDefaultMember(pt)) {
// exposed via __*item__, not the property name
skip = true;
}
} else if (mt.MemberType == TrackerTypes.Field) {
FieldInfo fi = ((FieldTracker)mt).Field;
if (fi.IsDefined(typeof(SlotFieldAttribute), false)) {
if (mts == null) {
mts = MakeListWithPreviousMembers(group, mts, i);
mt = new CustomAttributeTracker(mt.DeclaringType, mt.Name, (PythonTypeSlot)fi.GetValue(null));
}
}
}
if (skip && filter) {
if (mts == null) {
// add any ones we skipped...
mts = MakeListWithPreviousMembers(group, mts, i);
}
} else if (mts != null) {
mts.Add(mt);
}
}
if (mts != null) {
if (mts.Count == 0) {
return MemberGroup.EmptyGroup;
}
return new MemberGroup(mts.ToArray());
}
return group;
}
/// <summary> /// Returns a list of possible members which could exist. ResolveMember needs to be called to verify their existance. Duplicate /// names can also be returned. /// </summary> protected abstract IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type);
/// <summary>
/// Primary worker for returning a list of all members in a type. Can be called with different MemberBinder's to alter the scope
/// of the search.
/// </summary>
private static IList<ResolvedMember/*!*/>/*!*/ GetResolvedMembers(MemberBinder/*!*/ memberBinder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
List<ResolvedMember> res = new List<ResolvedMember>();
foreach (MemberResolver resolver in _resolvers) {
res.AddRange(resolver.ResolveMembers(memberBinder, action, type));
}
return res;
}
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;
}
/// <summary> /// Looks up an individual member and returns a MemberGroup with the given members. /// </summary> public abstract MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name);
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
// these members are visible but only accept derived types.
foreach (Type t in binder.GetContributingTypes(type)) {
foreach (MemberInfo mi in t.GetMembers(BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)) {
if (ProtectedOnly(mi)) {
yield return mi.Name;
}
}
}
}
public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
Assert.NotNull(binder, action, type, name);
// Do not map IComparable if this is a primitive builtin type.
if (_excludePrimitiveTypes) {
if (type.IsPrimitive() || type == typeof(BigInteger) ||
type == typeof(string) || type == typeof(decimal)) {
return MemberGroup.EmptyGroup;
}
}
string helperName;
if (_helperMap.TryGetValue(name, out helperName) &&
_comparable.IsAssignableFrom(type)) {
return new MemberGroup(GetEqualityMethods(type, helperName));
}
return MemberGroup.EmptyGroup;
}
/// <summary>
/// Gets all the statically known members from the specified type. Searches only the specified type to find the members.
///
/// The result may include multiple resolution. It is the callers responsibility to only treat the 1st one by name as existing.
/// </summary>
public static IList<ResolvedMember/*!*/>/*!*/ GetMembers(PythonBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
Assert.NotNull(binder, action, type);
return GetResolvedMembers(new LookupBinder(binder), action, type);
}
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
return _helperMap.Keys;
}
protected override IEnumerable<string/*!*/>/*!*/ GetCandidateNames(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type) {
yield return "__eq__";
yield return "__ne__";
}
/// <summary>
/// Primary worker for getting the member(s) associated with a single name. Can be called with different MemberBinder's to alter the
/// scope of the search.
/// </summary>
private static MemberGroup/*!*/ GetMemberGroup(MemberBinder/*!*/ memberBinder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
foreach (MemberResolver resolver in _resolvers) {
MemberGroup/*!*/ group = resolver.ResolveMember(memberBinder, action, type, name);
if (group.Count > 0) {
return group;
}
}
return MemberGroup.EmptyGroup;
}
