IkvmReflectionSymbol.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
 
using IKVM.Reflection;
 
using ConstructorInfo = IKVM.Reflection.ConstructorInfo;
using EventInfo = IKVM.Reflection.EventInfo;
using FieldInfo = IKVM.Reflection.FieldInfo;
using MemberInfo = IKVM.Reflection.MemberInfo;
using MethodBase = IKVM.Reflection.MethodBase;
using MethodInfo = IKVM.Reflection.MethodInfo;
using Module = IKVM.Reflection.Module;
using ParameterInfo = IKVM.Reflection.ParameterInfo;
using PropertyInfo = IKVM.Reflection.PropertyInfo;
using Type = IKVM.Reflection.Type;
 
namespace IKVM.CoreLib.Symbols.IkvmReflection
{
 
    abstract class IkvmReflectionSymbol : ISymbol
    {
 
        readonly IkvmReflectionSymbolContext _context;
 
        public IkvmReflectionSymbol(IkvmReflectionSymbolContext context)
        {
            _context = context ?? throw new ArgumentNullException(nameof(context));
        }
 
        protected IkvmReflectionSymbolContext Context => _context;
 
        public virtual bool IsMissing => false;
 
        protected virtual internal IkvmReflectionModuleSymbol ResolveModuleSymbol(Module module)
        {
            return _context.GetOrCreateModuleSymbol(module);
        }
 
        protected internal ImmutableArray<IkvmReflectionModuleSymbol> ResolveModuleSymbols(Module[] modules)
        {
            var a = ImmutableArray.CreateBuilder<IkvmReflectionModuleSymbol>(modules.Length);
            for (int i = 0; i < modules.Length; i++)
                a.Add(ResolveModuleSymbol(modules[i]));
 
            return a.DrainToImmutable();
        }
 
        protected internal IEnumerable<IkvmReflectionModuleSymbol> 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] = ((IkvmReflectionModuleSymbol)modules[i]).UnderlyingModule;
 
            return a;
        }
 
        protected virtual IkvmReflectionMemberSymbol 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 IkvmReflectionMemberSymbol[] ResolveMemberSymbols(MemberInfo[] types)
        {
            var a = new IkvmReflectionMemberSymbol[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] = ((IkvmReflectionMemberSymbol)members[i]).UnderlyingMember;
 
            return a;
        }
 
        protected virtual internal IkvmReflectionTypeSymbol ResolveTypeSymbol(Type type)
        {
            return _context.GetOrCreateTypeSymbol(type);
        }
 
        protected internal IkvmReflectionTypeSymbol[] ResolveTypeSymbols(Type[] types)
        {
            var a = new IkvmReflectionTypeSymbol[types.Length];
            for (int i = 0; i < types.Length; i++)
                a[i] = ResolveTypeSymbol(types[i]);
 
            return a;
        }
 
        protected internal IEnumerable<IkvmReflectionTypeSymbol> 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] = ((IkvmReflectionTypeSymbol)types[i]).UnderlyingType;
 
            return a;
        }
 
        protected virtual internal IkvmReflectionMethodBaseSymbol ResolveMethodBaseSymbol(MethodBase method)
        {
            if (method.IsConstructor)
                return ResolveConstructorSymbol((ConstructorInfo)method);
            else
                return ResolveMethodSymbol((MethodInfo)method);
        }
 
        protected virtual internal IkvmReflectionConstructorSymbol ResolveConstructorSymbol(ConstructorInfo ctor)
        {
            return _context.GetOrCreateConstructorSymbol(ctor);
        }
 
        protected internal IkvmReflectionConstructorSymbol[] ResolveConstructorSymbols(ConstructorInfo[] ctors)
        {
            var a = new IkvmReflectionConstructorSymbol[ctors.Length];
            for (int i = 0; i < ctors.Length; i++)
                a[i] = ResolveConstructorSymbol(ctors[i]);
 
            return a;
        }
 
        protected virtual internal IkvmReflectionMethodSymbol ResolveMethodSymbol(MethodInfo method)
        {
            return _context.GetOrCreateMethodSymbol(method);
        }
 
        protected internal IkvmReflectionMethodSymbol[] ResolveMethodSymbols(MethodInfo[] methods)
        {
            var a = new IkvmReflectionMethodSymbol[methods.Length];
            for (int i = 0; i < methods.Length; i++)
                a[i] = ResolveMethodSymbol(methods[i]);
 
            return a;
        }
 
        protected virtual internal IkvmReflectionParameterSymbol ResolveParameterSymbol(ParameterInfo parameter)
        {
            return _context.GetOrCreateParameterSymbol(parameter);
        }
 
        protected internal IkvmReflectionParameterSymbol[] ResolveParameterSymbols(ParameterInfo[] parameters)
        {
            var a = new IkvmReflectionParameterSymbol[parameters.Length];
            for (int i = 0; i < parameters.Length; i++)
                a[i] = ResolveParameterSymbol(parameters[i]);
 
            return a;
        }
 
        protected virtual internal IkvmReflectionFieldSymbol ResolveFieldSymbol(FieldInfo field)
        {
            return _context.GetOrCreateFieldSymbol(field);
        }
 
        protected internal IkvmReflectionFieldSymbol[] ResolveFieldSymbols(FieldInfo[] fields)
        {
            var a = new IkvmReflectionFieldSymbol[fields.Length];
            for (int i = 0; i < fields.Length; i++)
                a[i] = ResolveFieldSymbol(fields[i]);
 
            return a;
        }
 
        protected virtual internal IkvmReflectionPropertySymbol ResolvePropertySymbol(PropertyInfo property)
        {
            return _context.GetOrCreatePropertySymbol(property);
        }
 
        protected internal IkvmReflectionPropertySymbol[] ResolvePropertySymbols(PropertyInfo[] properties)
        {
            var a = new IkvmReflectionPropertySymbol[properties.Length];
            for (int i = 0; i < properties.Length; i++)
                a[i] = ResolvePropertySymbol(properties[i]);
 
            return a;
        }
 
        protected virtual internal IkvmReflectionEventSymbol ResolveEventSymbol(EventInfo @event)
        {
            return _context.GetOrCreateEventSymbol(@event);
        }
 
        protected internal IkvmReflectionEventSymbol[] ResolveEventSymbols(EventInfo[] events)
        {
            var a = new IkvmReflectionEventSymbol[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)
        {
            var a = ImmutableArray.CreateBuilder<CustomAttributeSymbol>(attributes.Count);
            for (int i = 0; i < attributes.Count; 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 = ImmutableArray.CreateBuilder<CustomAttributeSymbolTypedArgument>(args.Count);
            for (int i = 0; i < args.Count; i++)
                a.Add(ResolveCustomAttributeTypedArgument(args[i]));
 
            return a.DrainToImmutable();
        }
 
        CustomAttributeSymbolTypedArgument ResolveCustomAttributeTypedArgument(CustomAttributeTypedArgument arg)
        {
            return new CustomAttributeSymbolTypedArgument(ResolveTypeSymbol(arg.ArgumentType), arg.Value);
        }
 
        ImmutableArray<CustomAttributeSymbolNamedArgument> ResolveCustomAttributeNamedArguments(IList<CustomAttributeNamedArgument> args)
        {
            var a = ImmutableArray.CreateBuilder<CustomAttributeSymbolNamedArgument>(args.Count);
            for (int i = 0; i < args.Count; i++)
                a.Add(ResolveCustomAttributeNamedArgument(args[i]));
 
            return a.DrainToImmutable();
        }
 
        CustomAttributeSymbolNamedArgument ResolveCustomAttributeNamedArgument(CustomAttributeNamedArgument arg)
        {
            return new CustomAttributeSymbolNamedArgument(arg.IsField, ResolveMemberSymbol(arg.MemberInfo), arg.MemberName, ResolveCustomAttributeTypedArgument(arg.TypedValue));
        }
 
    }
 
}