/////////////////////////////////////////////////////////////////////////////////
private MethodSymbol AddMethodToSymbolTable(MemberInfo member, AggregateSymbol callingAggregate, MethodKindEnum kind)
{
MethodInfo method = member as MethodInfo;
ConstructorInfo ctor = member as ConstructorInfo;
Debug.Assert(method != null || ctor != null);
#if UNSUPPORTEDAPI
Debug.Assert(member.DeclaringType == member.ReflectedType);
#endif
// If we are trying to add an actual method via MethodKindEnum.Actual, and
// the memberinfo is a special name, and its not static, then return null.
// We'll re-add the thing later with some other method kind.
//
// This will happen for things like indexers and properties. The ones that have
// special names that we DO want to allow adding are things like operators, which
// are static and will not be added again later.
if (kind == MethodKindEnum.Actual && // MethKindEnum.Actual
(method == null || // Not a ConstructorInfo
(!method.IsStatic && method.IsSpecialName))) // Not static and is a special name
{
return null;
}
MethodSymbol methodSymbol = FindMatchingMethod(member, callingAggregate);
if (methodSymbol != null)
{
return methodSymbol;
}
ParameterInfo[] parameters = method != null ? method.GetParameters() : ctor.GetParameters();
// First create the method.
methodSymbol = _symFactory.CreateMethod(GetName(member.Name), callingAggregate, null);
methodSymbol.AssociatedMemberInfo = member;
methodSymbol.SetMethKind(kind);
if (kind == MethodKindEnum.ExplicitConv || kind == MethodKindEnum.ImplicitConv)
{
callingAggregate.SetHasConversion();
methodSymbol.SetConvNext(callingAggregate.GetFirstUDConversion());
callingAggregate.SetFirstUDConversion(methodSymbol);
}
ACCESS access;
if (method != null)
{
if (method.IsPublic)
{
access = ACCESS.ACC_PUBLIC;
}
else if (method.IsPrivate)
{
access = ACCESS.ACC_PRIVATE;
}
else if (method.IsFamily)
{
access = ACCESS.ACC_PROTECTED;
}
else if (method.IsAssembly || method.IsFamilyAndAssembly)
{
access = ACCESS.ACC_INTERNAL;
}
else
{
Debug.Assert(method.IsFamilyOrAssembly);
access = ACCESS.ACC_INTERNALPROTECTED;
}
}
else
{
Debug.Assert(ctor != null);
if (ctor.IsPublic)
{
access = ACCESS.ACC_PUBLIC;
}
else if (ctor.IsPrivate)
{
access = ACCESS.ACC_PRIVATE;
}
else if (ctor.IsFamily)
{
access = ACCESS.ACC_PROTECTED;
}
else if (ctor.IsAssembly || ctor.IsFamilyAndAssembly)
{
access = ACCESS.ACC_INTERNAL;
}
else
{
Debug.Assert(ctor.IsFamilyOrAssembly);
access = ACCESS.ACC_INTERNALPROTECTED;
}
}
methodSymbol.SetAccess(access);
methodSymbol.isExtension = false; // We don't support extension methods.
methodSymbol.isExternal = false;
if (method != null)
{
methodSymbol.typeVars = GetMethodTypeParameters(method, methodSymbol);
methodSymbol.isVirtual = method.IsVirtual;
methodSymbol.isAbstract = method.IsAbstract;
methodSymbol.isStatic = method.IsStatic;
methodSymbol.isOverride = method.IsVirtual && method.IsHideBySig && method.GetRuntimeBaseDefinition() != method;
methodSymbol.isOperator = IsOperator(method);
methodSymbol.swtSlot = GetSlotForOverride(method);
methodSymbol.isVarargs = (method.CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs;
methodSymbol.RetType = GetCTypeFromType(method.ReturnType);
}
else
{
methodSymbol.typeVars = BSYMMGR.EmptyTypeArray();
methodSymbol.isVirtual = ctor.IsVirtual;
methodSymbol.isAbstract = ctor.IsAbstract;
methodSymbol.isStatic = ctor.IsStatic;
methodSymbol.isOverride = false;
methodSymbol.isOperator = false;
methodSymbol.swtSlot = null;
methodSymbol.isVarargs = false;
methodSymbol.RetType = _typeManager.GetVoid();
}
methodSymbol.modOptCount = GetCountOfModOpts(parameters);
methodSymbol.useMethInstead = false;
methodSymbol.isParamArray = DoesMethodHaveParameterArray(parameters);
methodSymbol.isHideByName = false;
methodSymbol.errExpImpl = null;
methodSymbol.Params = CreateParameterArray(methodSymbol.AssociatedMemberInfo, parameters);
methodSymbol.declaration = null;
SetParameterDataForMethProp(methodSymbol, parameters);
return methodSymbol;
}
