ReflectionMemberSymbol.cs

Go to the documentation of this file.

using System;
using System.Collections.Immutable;
using System.Linq;
using System.Reflection;
 
namespace IKVM.CoreLib.Symbols.Reflection
{
 
    abstract class ReflectionMemberSymbol : ReflectionSymbol, IMemberSymbol
    {
 
        readonly ReflectionModuleSymbol _module;
        readonly ReflectionTypeSymbol? _type;
        readonly MemberInfo _underlyingMember;
 
        public ReflectionMemberSymbol(ReflectionSymbolContext context, ReflectionModuleSymbol module, ReflectionTypeSymbol? type, MemberInfo underlyingMember) :
            base(context)
        {
            _module = module ?? throw new ArgumentNullException(nameof(module));
            _type = type;
            _underlyingMember = underlyingMember ?? throw new ArgumentNullException(nameof(underlyingMember));
        }
 
        protected internal override ReflectionTypeSymbol ResolveTypeSymbol(Type type)
        {
            if (_type != null && type == _type.UnderlyingType)
                return _type;
            else if (type.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(type);
            else
                return base.ResolveTypeSymbol(type);
        }
 
        protected internal override ReflectionConstructorSymbol ResolveConstructorSymbol(ConstructorInfo ctor)
        {
            if (_type != null && ctor.DeclaringType == _type.UnderlyingType)
                return _type.GetOrCreateConstructorSymbol(ctor);
            else if (ctor.DeclaringType != null && ctor.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(ctor.DeclaringType).GetOrCreateConstructorSymbol(ctor);
            else
                return base.ResolveConstructorSymbol(ctor);
        }
 
        protected internal override ReflectionMethodSymbol ResolveMethodSymbol(MethodInfo method)
        {
            if (_type != null && method.DeclaringType == _type.UnderlyingType)
                return _type.GetOrCreateMethodSymbol(method);
            else if (method.DeclaringType != null && method.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(method.DeclaringType).GetOrCreateMethodSymbol(method);
            else
                return base.ResolveMethodSymbol(method);
        }
 
        protected internal override ReflectionFieldSymbol ResolveFieldSymbol(FieldInfo field)
        {
            if (_type != null && field.DeclaringType == _type.UnderlyingType)
                return _type.GetOrCreateFieldSymbol(field);
            else if (field.DeclaringType != null && field.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(field.DeclaringType).GetOrCreateFieldSymbol(field);
            else
                return base.ResolveFieldSymbol(field);
        }
 
 
        protected internal override ReflectionPropertySymbol ResolvePropertySymbol(PropertyInfo property)
        {
 
            if (_type != null && property.DeclaringType == _type.UnderlyingType)
                return _type.GetOrCreatePropertySymbol(property);
            else if (property.DeclaringType != null && property.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(property.DeclaringType).GetOrCreatePropertySymbol(property);
            else
                return base.ResolvePropertySymbol(property);
        }
 
        protected internal override ReflectionEventSymbol ResolveEventSymbol(EventInfo @event)
        {
            if (_type != null && @event.DeclaringType == _type.UnderlyingType)
                return _type.GetOrCreateEventSymbol(@event);
            else if (@event.DeclaringType != null && @event.Module == _underlyingMember.Module)
                return _module.GetOrCreateTypeSymbol(@event.DeclaringType).GetOrCreateEventSymbol(@event);
            else
                return base.ResolveEventSymbol(@event);
        }
 
        internal MemberInfo UnderlyingMember => _underlyingMember;
 
        internal ReflectionModuleSymbol ContainingModule => _module;
 
        internal ReflectionTypeSymbol? ContainingType => _type;
 
        public virtual IModuleSymbol Module => Context.GetOrCreateModuleSymbol(_underlyingMember.Module);
 
        public virtual ITypeSymbol? DeclaringType => _underlyingMember.DeclaringType is Type t ? Context.GetOrCreateTypeSymbol(t) : null;
 
        public virtual MemberTypes MemberType => _underlyingMember.MemberType;
 
        public virtual int MetadataToken => _underlyingMember.MetadataToken;
 
        public virtual string Name => _underlyingMember.Name;
 
        public virtual ImmutableArray<CustomAttributeSymbol> GetCustomAttributes()
        {
            return ResolveCustomAttributes(_underlyingMember.GetCustomAttributesData());
        }
 
        public virtual ImmutableArray<CustomAttributeSymbol> GetCustomAttributes(ITypeSymbol attributeType)
        {
            return ResolveCustomAttributes(_underlyingMember.GetCustomAttributesData()).Where(i => i.AttributeType == attributeType).ToImmutableArray();
        }
 
        public virtual bool IsDefined(ITypeSymbol attributeType)
        {
            return _underlyingMember.IsDefined(((ReflectionTypeSymbol)attributeType).UnderlyingType);
        }
 
    }
 
}