public void SetMethKind(MethodKindEnum mk) { _methKind = mk; }
///////////////////////////////////////////////////////////////////////////////// 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; }