public IMethodReference Map(IMethodSymbol methodSymbol) { Contract.Requires(methodSymbol != null); IMethodReference mr = null; if (!methodSymbolCache.TryGetValue(methodSymbol, out mr)) { List <IParameterTypeInformation> ps = methodSymbol.Parameters.Length == 0 ? null : new List <IParameterTypeInformation>(); if (methodSymbol.IsGenericMethod && methodSymbol.ConstructedFrom != methodSymbol) { var gArgs = new List <ITypeReference>(); foreach (var a in methodSymbol.TypeArguments) { gArgs.Add(Map(a)); } mr = new Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference() { CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, ContainingType = Map(methodSymbol.ContainingType), GenericArguments = gArgs, GenericMethod = Map(methodSymbol.ConstructedFrom), GenericParameterCount = (ushort)methodSymbol.TypeParameters.Length, InternFactory = this.host.InternFactory, Name = this.nameTable.GetNameFor(methodSymbol.Name), Parameters = ps, Type = Map(methodSymbol.ReturnType), }; } else { var m = new Microsoft.Cci.MutableCodeModel.MethodReference(); // IMPORTANT: Have to add it to the cache before doing anything else because it may // get looked up if it is generic and a parameter's type involves the generic // method parameter. this.methodSymbolCache.Add(methodSymbol, m); m.CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis; m.ContainingType = Map(methodSymbol.ContainingType); m.InternFactory = this.host.InternFactory; m.Name = this.nameTable.GetNameFor(methodSymbol.Name); m.Parameters = ps; m.Type = Map(methodSymbol.ReturnType); mr = m; } foreach (var p in methodSymbol.Parameters) { var p_prime = new ParameterTypeInformation() { ContainingSignature = mr, Index = (ushort)p.Ordinal, Type = Map(p.Type), }; ps.Add(p_prime); } } return(mr); }
public override void RewriteChildren(Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference genericMethodInstanceReference) { base.RewriteChildren(genericMethodInstanceReference); if (genericMethodInstanceReference.GenericMethod.Name.Value.EndsWith("<<>>")) { genericMethodInstanceReference.Name = genericMethodInstanceReference.Name; var newArgs = new List <ITypeReference>(); // add the first generic parameter of the current method. foreach (var gmpr in root.GenericParameters) { newArgs.Add(gmpr); break; } foreach (var arg in ((IGenericMethodInstanceReference)genericMethodInstanceReference).GenericArguments) { newArgs.Add(arg); } genericMethodInstanceReference.GenericArguments = newArgs; } }
public IMethodReference Map(R.IMethodSymbol methodSymbol) { Contract.Requires(methodSymbol != null); IMethodReference mr = null; if (!methodSymbolCache.TryGetValue(methodSymbol, out mr)) { List<IParameterTypeInformation> ps = methodSymbol.Parameters.Count == 0 ? null : new List<IParameterTypeInformation>(); if (methodSymbol.IsGenericMethod && methodSymbol.ConstructedFrom != methodSymbol) { var gArgs = new List<ITypeReference>(); foreach (var a in methodSymbol.TypeArguments){ gArgs.Add(Map(a)); } mr = new Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference() { CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, ContainingType = Map(methodSymbol.ContainingType), GenericArguments = gArgs, GenericMethod = Map(methodSymbol.ConstructedFrom), GenericParameterCount = (ushort) methodSymbol.TypeParameters.Count, InternFactory = this.host.InternFactory, Name = this.nameTable.GetNameFor(methodSymbol.Name), Parameters = ps, Type = Map(methodSymbol.ReturnType), }; } else { var m = new Microsoft.Cci.MutableCodeModel.MethodReference(); // IMPORTANT: Have to add it to the cache before doing anything else because it may // get looked up if it is generic and a parameter's type involves the generic // method parameter. this.methodSymbolCache.Add(methodSymbol, m); m.CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis; m.ContainingType = Map(methodSymbol.ContainingType); m.InternFactory = this.host.InternFactory; m.Name = this.nameTable.GetNameFor(methodSymbol.Name); m.Parameters = ps; m.Type = Map(methodSymbol.ReturnType); mr = m; } foreach (var p in methodSymbol.Parameters) { var p_prime = new ParameterTypeInformation() { ContainingSignature = mr, Index = (ushort)p.Ordinal, Type = Map(p.Type), }; ps.Add(p_prime); } } return mr; }
/// <summary> /// Converts the return value into a call to Contract.Result /// </summary> public override IExpression Rewrite(IReturnValue returnValue) { var mref = this.contractProvider.ContractMethods.Result; var methodToCall = new Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference() { CallingConvention = CallingConvention.Generic, ContainingType = mref.ContainingType, GenericArguments = new List<ITypeReference> { returnValue.Type }, GenericMethod = mref, InternFactory = this.host.InternFactory, Name = mref.Name, Type = returnValue.Type, }; var methodCall = new MethodCall() { IsStaticCall = true, MethodToCall = methodToCall, Type = returnValue.Type, Locations = new List<ILocation>(returnValue.Locations), }; return methodCall; }
/// <summary> /// Converts the old value into a call to Contract.OldValue /// </summary> public override IExpression Rewrite(IOldValue oldValue) { var mref = this.contractProvider.ContractMethods.Old; var methodToCall = new Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference() { CallingConvention = CallingConvention.Generic, ContainingType = mref.ContainingType, GenericArguments = new List<ITypeReference> { oldValue.Type }, GenericMethod = mref, InternFactory = this.host.InternFactory, Name = mref.Name, Parameters = new List<IParameterTypeInformation>{ new ParameterTypeInformation { Type = oldValue.Type, } }, Type = oldValue.Type, }; var methodCall = new MethodCall() { Arguments = new List<IExpression> { oldValue.Expression, }, IsStaticCall = true, MethodToCall = methodToCall, Type = oldValue.Type, Locations = new List<ILocation>(oldValue.Locations), }; return methodCall; }