ReflectionSymbol.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Reflection;
 
namespace IKVM.CoreLib.Symbols.Reflection
{
 
    abstract class ReflectionSymbol : ISymbol
    {
 
        readonly ReflectionSymbolContext _context;
 
        public ReflectionSymbol(ReflectionSymbolContext context)
        {
            _context = context ?? throw new ArgumentNullException(nameof(context));
        }
 
        protected ReflectionSymbolContext Context => _context;
 
        public virtual bool IsMissing => false;
 
        protected virtual internal ReflectionModuleSymbol ResolveModuleSymbol(Module module)
        {
            return _context.GetOrCreateModuleSymbol(module);
        }
 
        protected internal ImmutableArray<ReflectionModuleSymbol> ResolveModuleSymbols(Module[] modules)
        {
            var a = ImmutableArray.CreateBuilder<ReflectionModuleSymbol>(modules.Length);
            for (int i = 0; i < modules.Length; i++)
                a.Add(ResolveModuleSymbol(modules[i]));
 
            return a.DrainToImmutable();
        }
 
        protected internal IEnumerable<ReflectionModuleSymbol> ResolveModuleSymbols(IEnumerable<Module> modules)
        {
            foreach (var module in modules)
                yield return ResolveModuleSymbol(module);
        }
 
        protected internal Module[] UnpackModuleSymbols(IModuleSymbol[] modules)
        {
            var a = new Module[modules.Length];
            for (int i = 0; i < modules.Length; i++)
                a[i] = ((ReflectionModuleSymbol)modules[i]).UnderlyingModule;
 
            return a;
        }
 
        protected virtual ReflectionMemberSymbol ResolveMemberSymbol(MemberInfo member)
        {
            return member.MemberType switch
            {
                MemberTypes.Constructor => ResolveConstructorSymbol((ConstructorInfo)member),
                MemberTypes.Event => ResolveEventSymbol((EventInfo)member),
                MemberTypes.Field => ResolveFieldSymbol((FieldInfo)member),
                MemberTypes.Method => ResolveMethodSymbol((MethodInfo)member),
                MemberTypes.Property => ResolvePropertySymbol((PropertyInfo)member),
                MemberTypes.TypeInfo => ResolveTypeSymbol((Type)member),
                MemberTypes.NestedType => ResolveTypeSymbol((Type)member),
                MemberTypes.Custom => throw new NotImplementedException(),
                MemberTypes.All => throw new NotImplementedException(),
                _ => throw new InvalidOperationException(),
            };
        }
 
        protected internal ReflectionMemberSymbol[] ResolveMemberSymbols(MemberInfo[] types)
        {
            var a = new ReflectionMemberSymbol[types.Length];
            for (int i = 0; i < types.Length; i++)
                a[i] = ResolveMemberSymbol(types[i]);
 
            return a;
        }
 
        protected internal MemberInfo[] UnpackMemberSymbols(IMemberSymbol[] members)
        {
            var a = new MemberInfo[members.Length];
            for (int i = 0; i < members.Length; i++)
                a[i] = ((ReflectionMemberSymbol)members[i]).UnderlyingMember;
 
            return a;
        }
 
        protected virtual internal ReflectionTypeSymbol ResolveTypeSymbol(Type type)
        {
            return _context.GetOrCreateTypeSymbol(type);
        }
 
        protected internal ReflectionTypeSymbol[] ResolveTypeSymbols(Type[] types)
        {
            var a = new ReflectionTypeSymbol[types.Length];
            for (int i = 0; i < types.Length; i++)
                a[i] = ResolveTypeSymbol(types[i]);
 
            return a;
        }
 
        protected internal IEnumerable<ReflectionTypeSymbol> ResolveTypeSymbols(IEnumerable<Type> types)
        {
            foreach (var type in types)
                yield return ResolveTypeSymbol(type);
        }
 
        protected internal Type[] UnpackTypeSymbols(ITypeSymbol[] types)
        {
            var a = new Type[types.Length];
            for (int i = 0; i < types.Length; i++)
                a[i] = ((ReflectionTypeSymbol)types[i]).UnderlyingType;
 
            return a;
        }
 
        protected virtual internal ReflectionMethodBaseSymbol ResolveMethodBaseSymbol(MethodBase method)
        {
            if (method.IsConstructor)
                return ResolveConstructorSymbol((ConstructorInfo)method);
            else
                return ResolveMethodSymbol((MethodInfo)method);
        }
 
        protected virtual internal ReflectionConstructorSymbol ResolveConstructorSymbol(ConstructorInfo ctor)
        {
            return _context.GetOrCreateConstructorSymbol(ctor);
        }
 
        protected internal ReflectionConstructorSymbol[] ResolveConstructorSymbols(ConstructorInfo[] ctors)
        {
            var a = new ReflectionConstructorSymbol[ctors.Length];
            for (int i = 0; i < ctors.Length; i++)
                a[i] = ResolveConstructorSymbol(ctors[i]);
 
            return a;
        }
 
        protected virtual internal ReflectionMethodSymbol ResolveMethodSymbol(MethodInfo method)
        {
            return _context.GetOrCreateMethodSymbol(method);
        }
 
        protected internal ReflectionMethodSymbol[] ResolveMethodSymbols(MethodInfo[] methods)
        {
            var a = new ReflectionMethodSymbol[methods.Length];
            for (int i = 0; i < methods.Length; i++)
                a[i] = ResolveMethodSymbol(methods[i]);
 
            return a;
        }
 
        protected virtual internal ReflectionParameterSymbol ResolveParameterSymbol(ParameterInfo parameter)
        {
            return _context.GetOrCreateParameterSymbol(parameter);
        }
 
        protected internal ReflectionParameterSymbol[] ResolveParameterSymbols(ParameterInfo[] parameters)
        {
            var a = new ReflectionParameterSymbol[parameters.Length];
            for (int i = 0; i < parameters.Length; i++)
                a[i] = ResolveParameterSymbol(parameters[i]);
 
            return a;
        }
 
        protected virtual internal ReflectionFieldSymbol ResolveFieldSymbol(FieldInfo field)
        {
            return _context.GetOrCreateFieldSymbol(field);
        }
 
        protected internal ReflectionFieldSymbol[] ResolveFieldSymbols(FieldInfo[] fields)
        {
            var a = new ReflectionFieldSymbol[fields.Length];
            for (int i = 0; i < fields.Length; i++)
                a[i] = ResolveFieldSymbol(fields[i]);
 
            return a;
        }
 
        protected virtual internal ReflectionPropertySymbol ResolvePropertySymbol(PropertyInfo property)
        {
            return _context.GetOrCreatePropertySymbol(property);
        }
 
        protected internal ReflectionPropertySymbol[] ResolvePropertySymbols(PropertyInfo[] properties)
        {
            var a = new ReflectionPropertySymbol[properties.Length];
            for (int i = 0; i < properties.Length; i++)
                a[i] = ResolvePropertySymbol(properties[i]);
 
            return a;
        }
 
        protected virtual internal ReflectionEventSymbol ResolveEventSymbol(EventInfo @event)
        {
            return _context.GetOrCreateEventSymbol(@event);
        }
 
        protected internal ReflectionEventSymbol[] ResolveEventSymbols(EventInfo[] events)
        {
            var a = new ReflectionEventSymbol[events.Length];
            for (int i = 0; i < events.Length; i++)
                a[i] = ResolveEventSymbol(events[i]);
 
            return a;
        }
 
        protected internal ImmutableArray<CustomAttributeSymbol> ResolveCustomAttributes(IList<CustomAttributeData> attributes, Predicate<CustomAttributeData>? filter = null)
        {
            var a = ImmutableArray.CreateBuilder<CustomAttributeSymbol>(attributes.Count);
            for (int i = 0; i < attributes.Count; i++)
                if (filter == null || filter(attributes[i]))
                    a.Add(ResolveCustomAttribute(attributes[i]));
 
            return a.DrainToImmutable();
        }
 
        protected internal CustomAttributeSymbol ResolveCustomAttribute(CustomAttributeData customAttributeData)
        {
            return new CustomAttributeSymbol(
                ResolveTypeSymbol(customAttributeData.AttributeType),
                ResolveConstructorSymbol(customAttributeData.Constructor),
                ResolveCustomAttributeTypedArguments(customAttributeData.ConstructorArguments),
                ResolveCustomAttributeNamedArguments(customAttributeData.NamedArguments));
        }
 
        ImmutableArray<CustomAttributeSymbolTypedArgument> ResolveCustomAttributeTypedArguments(IList<CustomAttributeTypedArgument> args)
        {
            var a = new CustomAttributeSymbolTypedArgument[args.Count];
            for (int i = 0; i < args.Count; i++)
                a[i] = ResolveCustomAttributeTypedArgument(args[i]);
 
            return a.ToImmutableArray();
        }
 
        CustomAttributeSymbolTypedArgument ResolveCustomAttributeTypedArgument(CustomAttributeTypedArgument arg)
        {
            return new CustomAttributeSymbolTypedArgument(ResolveTypeSymbol(arg.ArgumentType), arg.Value);
        }
 
        ImmutableArray<CustomAttributeSymbolNamedArgument> ResolveCustomAttributeNamedArguments(IList<CustomAttributeNamedArgument> args)
        {
            var a = new CustomAttributeSymbolNamedArgument[args.Count];
            for (int i = 0; i < args.Count; i++)
                a[i] = ResolveCustomAttributeNamedArgument(args[i]);
 
            return ImmutableArray.Create(a);
        }
 
        CustomAttributeSymbolNamedArgument ResolveCustomAttributeNamedArgument(CustomAttributeNamedArgument arg)
        {
            return new CustomAttributeSymbolNamedArgument(arg.IsField, ResolveMemberSymbol(arg.MemberInfo), arg.MemberName, ResolveCustomAttributeTypedArgument(arg.TypedValue));
        }
 
    }
 
}