internal void AddTypeName(string typeName, Assembly assem) { // lock is held when this is called Assert.NotNull(typeName, assem); Debug.Assert(typeName.IndexOf('.') == -1); // This is the simple name, not the full name if (!_typeNames.ContainsKey(assem)) { _typeNames[assem] = new TypeNames(assem, _fullName); } _typeNames[assem].AddTypeName(typeName); string normalizedTypeName = ReflectionUtils.GetNormalizedTypeName(typeName); if (_dict.ContainsKey(normalizedTypeName)) { // A similarly named type, namespace, or module already exists. Type newType = LoadType(assem, GetFullChildName(typeName)); if (newType != null) { object existingValue = _dict[normalizedTypeName]; TypeTracker existingTypeEntity = existingValue as TypeTracker; if (existingTypeEntity == null) { // Replace the existing namespace or module with the new type Debug.Assert(existingValue is NamespaceTracker); _dict[normalizedTypeName] = MemberTracker.FromMemberInfo(newType.GetTypeInfo()); } else { // Unify the new type with the existing type _dict[normalizedTypeName] = TypeGroup.UpdateTypeEntity(existingTypeEntity, TypeTracker.GetTypeTracker(newType)); } } } }
public override Expression GetValue(ActionBinder binder, Type type) { if (!IsStatic || GetIndexParameters().Length > 0) { // need to bind to a value or parameters to get the value. return(binder.ReturnMemberTracker(type, this)); } MethodInfo getter = ResolveGetter(); if (getter == null || getter.ContainsGenericParameters) { // no usable getter return(null); } if (getter.IsPublic && getter.DeclaringType.IsPublic) { return(binder.MakeCallExpression(getter)); } // private binding is just a call to the getter method... return(MemberTracker.FromMemberInfo(getter).Call(binder)); }
public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type instanceType) { if (!IsStatic || GetIndexParameters().Length > 0) { // need to bind to a value or parameters to get the value. return(binder.ReturnMemberTracker(instanceType, this)); } MethodInfo getter = ResolveGetter(instanceType, binder.PrivateBinding); if (getter == null || getter.ContainsGenericParameters) { // no usable getter return(null); } if (getter.IsPublic && getter.DeclaringType.IsPublic()) { return(binder.MakeCallExpression(resolverFactory, getter)); } // private binding is just a call to the getter method... return(MemberTracker.FromMemberInfo(getter).Call(resolverFactory, binder)); }
/// <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)) { MemberInfo newMember = mi; if (PrivateBinding || (newMember = CompilerHelpers.TryGetVisibleMember(mi)) != null) { if (ext != declaringType) { members.Add(MemberTracker.FromMemberInfo(newMember, declaringType)); } else { members.Add(MemberTracker.FromMemberInfo(newMember)); } } } // 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 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); }