public void AddGenericParameter(MethodDefinition method) { var oneMoreGP = new List <IGenericMethodParameter>(); var gp1 = new GenericMethodParameter(); gp1.Name = this.host.NameTable.GetNameFor("_SX_"); gp1.DefiningMethod = method; gp1.Index = 0; gp1.InternFactory = this.host.InternFactory; oneMoreGP.Add(gp1); if (method.GenericParameterCount > 0) { foreach (GenericMethodParameter gp in method.GenericParameters) { gp.Index++; oneMoreGP.Add(gp); } } method.GenericParameters = oneMoreGP; }
/// <summary> /// Creates either a generic method parameter or a generic type parameter /// and adds it to the type symbol cache. /// </summary> /// <param name="typeSymbol"></param> /// <returns></returns> private GenericParameter CreateTypeDefinition(ITypeParameterSymbol typeSymbol) { Contract.Requires(typeSymbol != null); Contract.Ensures(Contract.Result <GenericParameter>() != null); GenericParameter cciType; var containingSymbol = typeSymbol.ContainingSymbol; if (containingSymbol is IMethodSymbol) { cciType = new GenericMethodParameter() { DefiningMethod = (IMethodDefinition)this.Map((IMethodSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } else { // assume it is a class parameter? cciType = new GenericTypeParameter() { DefiningType = (ITypeDefinition)this.Map((ITypeSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } var constraints = new List <ITypeReference>(); foreach (var c in typeSymbol.ConstraintTypes) { var c2 = this.Map(c); constraints.Add(c2); } cciType.Constraints = constraints; this.typeSymbolCache.Add(typeSymbol, cciType); return(cciType); }
/// <summary> /// Copies the generic parameters from this.method to the given delegate method and fixes up /// the delegate method signature to refer to its own type parameters, rather than those of this.method. /// </summary> private void MakeDelegateMethodGeneric(MethodDefinition delegateMethod) { delegateMethod.CallingConvention |= CallingConvention.Generic; var savedGenericMethodParameterMap = this.genericMethodParameterMap; this.genericMethodParameterMap = new Dictionary<ushort, IGenericParameterReference>(); delegateMethod.GenericParameters = new List<IGenericMethodParameter>(this.method.GenericParameterCount); foreach (var genericParameter in this.method.GenericParameters) { var delPar = new GenericMethodParameter(); delPar.Copy(genericParameter, this.host.InternFactory); delPar.DefiningMethod = delegateMethod; delegateMethod.GenericParameters.Add(delPar); this.genericMethodParameterMap.Add(genericParameter.Index, delPar); } new GenericParameterRewriter(this.host, this.genericMethodParameterMap).RewriteChildren(delegateMethod); this.genericMethodParameterMap = savedGenericMethodParameterMap; }
private IMethodReference CreateThreeArgVersionOfMethod(string originalMethodName, string keyName, ushort genericParameters, bool backwardCompat) { MethodBody body = new MethodBody() { Operations = new List<IOperation>{ new Operation() { OperationCode = OperationCode.Ret, } }, }; MethodDefinition threeArgVersion = new MethodDefinition() { Body = body, CallingConvention = CallingConvention.Default, // Isn't it the default for the calling convention to be the default? ContainingTypeDefinition = this.classHoldingThreeArgVersions, GenericParameters = new List<IGenericMethodParameter>(genericParameters), Name = backwardCompat ? this.host.NameTable.GetNameFor("Requires") : this.host.NameTable.GetNameFor(originalMethodName), Type = this.systemVoidType, Visibility = TypeMemberVisibility.Public, IsStatic = true, InternFactory = this.host.InternFactory, // NB: without this, the method has an interned key of zero, which gets confused with other dummy interned keys!! }; if (genericParameters != 0) { threeArgVersion.CallingConvention = CallingConvention.Generic; var typeArg = new GenericMethodParameter() { Name = this.host.NameTable.GetNameFor("TException"), DefiningMethod = threeArgVersion, InternFactory = this.host.InternFactory, }; // TODO: add SystemException base type? threeArgVersion.GenericParameters.Add(typeArg); } List<IParameterDefinition> paramList = new List<IParameterDefinition>(); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("condition"), Type = this.systemBooleanType, Index = 0, }); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("userSuppliedString"), Type = this.systemStringType, Index = 1, }); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("sourceText"), Type = this.systemStringType, Index = 2, }); threeArgVersion.Parameters = paramList; body.MethodDefinition = threeArgVersion; this.threeArgumentVersionofContractMethod.Add(keyName, threeArgVersion); if (this.classHoldingThreeArgVersions.Methods == null) this.classHoldingThreeArgVersions.Methods = new List<IMethodDefinition>(1); this.classHoldingThreeArgVersions.Methods.Add(threeArgVersion); return threeArgVersion; }
private IMethodReference CreateThreeArgVersionOfMethod(string originalMethodName, string keyName, ushort genericParameters, bool backwardCompat) { MethodBody body = new MethodBody() { Operations = new List <IOperation> { new Operation() { OperationCode = OperationCode.Ret, } }, }; MethodDefinition threeArgVersion = new MethodDefinition() { Body = body, CallingConvention = CallingConvention.Default, // Isn't it the default for the calling convention to be the default? ContainingTypeDefinition = this.classHoldingThreeArgVersions, GenericParameters = new List <IGenericMethodParameter>(genericParameters), Name = backwardCompat ? this.host.NameTable.GetNameFor("Requires") : this.host.NameTable.GetNameFor(originalMethodName), Type = this.systemVoidType, Visibility = TypeMemberVisibility.Public, IsStatic = true, InternFactory = this.host.InternFactory, // NB: without this, the method has an interned key of zero, which gets confused with other dummy interned keys!! }; if (genericParameters != 0) { threeArgVersion.CallingConvention = CallingConvention.Generic; var typeArg = new GenericMethodParameter() { Name = this.host.NameTable.GetNameFor("TException"), DefiningMethod = threeArgVersion, InternFactory = this.host.InternFactory, }; // TODO: add SystemException base type? threeArgVersion.GenericParameters.Add(typeArg); } List <IParameterDefinition> paramList = new List <IParameterDefinition>(); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("condition"), Type = this.systemBooleanType, Index = 0, }); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("userSuppliedString"), Type = this.systemStringType, Index = 1, }); paramList.Add( new ParameterDefinition() { ContainingSignature = threeArgVersion, Name = this.host.NameTable.GetNameFor("sourceText"), Type = this.systemStringType, Index = 2, }); threeArgVersion.Parameters = paramList; body.MethodDefinition = threeArgVersion; this.threeArgumentVersionofContractMethod.Add(keyName, threeArgVersion); if (this.classHoldingThreeArgVersions.Methods == null) { this.classHoldingThreeArgVersions.Methods = new List <IMethodDefinition>(1); } this.classHoldingThreeArgVersions.Methods.Add(threeArgVersion); return(threeArgVersion); }
/// <summary> /// Creates either a generic method parameter or a generic type parameter /// and adds it to the type symbol cache. /// </summary> /// <param name="typeSymbol"></param> /// <returns></returns> private GenericParameter CreateTypeDefinition(R.ITypeParameterSymbol typeSymbol) { Contract.Requires(typeSymbol != null); Contract.Ensures(Contract.Result<GenericParameter>() != null); GenericParameter cciType; var containingSymbol = typeSymbol.ContainingSymbol; if (containingSymbol is R.IMethodSymbol) { cciType = new GenericMethodParameter() { DefiningMethod = (IMethodDefinition)this.Map((R.IMethodSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } else { // assume it is a class parameter? cciType = new GenericTypeParameter() { DefiningType = (ITypeDefinition)this.Map((R.ITypeSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } var constraints = new List<ITypeReference>(); foreach (var c in typeSymbol.ConstraintTypes) { var c2 = this.Map(c); constraints.Add(c2); } cciType.Constraints = constraints; this.typeSymbolCache.Add(typeSymbol, cciType); return cciType; }