ReflectionMethodBaseSymbol.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
 
namespace IKVM.CoreLib.Symbols.Reflection
{
 
    abstract class ReflectionMethodBaseSymbol : ReflectionMemberSymbol, IMethodBaseSymbol
    {
 
        readonly MethodBase _underlyingMethodBase;
 
        ParameterInfo[]? _parametersSource;
        ReflectionParameterSymbol?[]? _parameters;
        ReflectionParameterSymbol? _returnParameter;
 
        public ReflectionMethodBaseSymbol(ReflectionSymbolContext context, ReflectionModuleSymbol module, ReflectionTypeSymbol? type, MethodBase underlyingMethodBase) :
            base(context, module, type, underlyingMethodBase)
        {
            _underlyingMethodBase = underlyingMethodBase ?? throw new ArgumentNullException(nameof(underlyingMethodBase));
        }
 
        internal ReflectionParameterSymbol GetOrCreateParameterSymbol(ParameterInfo parameter)
        {
            if (parameter is null)
                throw new ArgumentNullException(nameof(parameter));
 
            Debug.Assert(parameter.Member == _underlyingMethodBase);
 
            if (_parametersSource == null)
                Interlocked.CompareExchange(ref _parametersSource, _underlyingMethodBase.GetParameters().OrderBy(i => i.Position).ToArray(), null);
            if (_parameters == null)
                Interlocked.CompareExchange(ref _parameters, new ReflectionParameterSymbol?[_parametersSource.Length], null);
 
            // index of current record
            var idx = parameter.Position;
            Debug.Assert(idx >= -1);
            Debug.Assert(idx < _parametersSource.Length);
 
            // check that our list is long enough to contain the entire table
            if (idx >= 0 && _parameters.Length < idx)
                throw new IndexOutOfRangeException();
 
            // if not yet created, create, allow multiple instances, but only one is eventually inserted
            ref var rec = ref _returnParameter;
            if (idx >= 0)
                rec = ref _parameters[idx];
            if (rec == null)
                Interlocked.CompareExchange(ref rec, new ReflectionParameterSymbol(Context, this, parameter), null);
 
            // this should never happen
            if (rec is not ReflectionParameterSymbol sym)
                throw new InvalidOperationException();
 
            return sym;
        }
 
        internal MethodBase UnderlyingMethodBase => _underlyingMethodBase;
 
        public MethodAttributes Attributes => _underlyingMethodBase.Attributes;
 
        public CallingConventions CallingConvention => _underlyingMethodBase.CallingConvention;
 
        public bool ContainsGenericParameters => _underlyingMethodBase.ContainsGenericParameters;
 
        public bool IsAbstract => _underlyingMethodBase.IsAbstract;
 
        public bool IsAssembly => _underlyingMethodBase.IsAssembly;
 
        public bool IsConstructor => _underlyingMethodBase.IsConstructor;
 
        public bool IsFamily => _underlyingMethodBase.IsFamily;
 
        public bool IsFamilyAndAssembly => _underlyingMethodBase.IsFamilyAndAssembly;
 
        public bool IsFamilyOrAssembly => _underlyingMethodBase.IsFamilyOrAssembly;
 
        public bool IsFinal => _underlyingMethodBase.IsFinal;
 
        public bool IsGenericMethod => _underlyingMethodBase.IsGenericMethod;
 
        public bool IsGenericMethodDefinition => _underlyingMethodBase.IsGenericMethodDefinition;
 
        public bool IsHideBySig => _underlyingMethodBase.IsHideBySig;
 
        public bool IsPrivate => _underlyingMethodBase.IsPrivate;
 
        public bool IsPublic => _underlyingMethodBase.IsPublic;
 
        public bool IsStatic => _underlyingMethodBase.IsStatic;
 
        public bool IsVirtual => _underlyingMethodBase.IsVirtual;
 
        public bool IsSpecialName => _underlyingMethodBase.IsSpecialName;
 
        public MethodImplAttributes MethodImplementationFlags => _underlyingMethodBase.MethodImplementationFlags;
 
        public ITypeSymbol[] GetGenericArguments()
        {
            return ResolveTypeSymbols(_underlyingMethodBase.GetGenericArguments());
        }
 
        public MethodImplAttributes GetMethodImplementationFlags()
        {
            return _underlyingMethodBase.GetMethodImplementationFlags();
        }
 
        public IParameterSymbol[] GetParameters()
        {
            return ResolveParameterSymbols(_underlyingMethodBase.GetParameters());
        }
 
    }
 
}