private static void SwapParameterTypes(MethodDefinition method, TypeDefinition targetDependency, TypeReference interfaceType, HashSet<MethodReference> modifiedMethods) { if (method.IsAbstract || !method.HasBody) return; bool modified = false; var parameters = method.Parameters.Cast<ParameterDefinition>(); foreach (var parameter in parameters) { var parameterType = parameter.ParameterType; if (parameterType != targetDependency) continue; parameter.ParameterType = interfaceType; modified = true; } if (!modified) return; modifiedMethods.Add(method); }
private AnalysisNet.Types.TypeDefinition ExtractClass(Cecil.TypeDefinition cecilType, AnalysisNet.Types.TypeKind typeKind, AnalysisNet.Types.TypeDefinitionKind typeDefinitionKind) { string name = UnmangleName(cecilType); AnalysisNet.Types.TypeDefinition type = new AnalysisNet.Types.TypeDefinition(name, typeKind, typeDefinitionKind); Cecil.TypeReference basedef = cecilType.BaseType; type.IsAbstract = cecilType.IsAbstract; type.IsSealed = cecilType.IsSealed; if (basedef != null) { type.Base = ExtractType(basedef) as AnalysisNet.Types.IBasicType; } ExtractCustomAttributes(type.Attributes, cecilType.CustomAttributes); ExtractGenericTypeParameters(type, cecilType); ExtractInterfaces(type.Interfaces, cecilType.Interfaces); ExtractFields(type, type.Fields, cecilType.Fields); ExtractMethods(type, type.Methods, cecilType.Methods); ExtractPropertyDefinitions(type, cecilType); ExtractExplicitMethodOverrides(type, cecilType); ExtractLayoutInformation(type, cecilType); return(type); }
public override void ImportReferences(ModuleDefinition module) { // Import the references from the base class base.ImportReferences(module); _modifiableInterfaceType = module.ImportType<IModifiableType>(); }
public void FindDerivedFrom(TypeReference baseTypeRef) { foreach (var td in _module.Types) { if(IsDerivedFrom(td, baseTypeRef)) Console.WriteLine (td.FullName); } }
public Tuple<TypeDefinition, AssemblyDefinition> this[TypeReference typ, AssemblyNameReference assembly] { get { return typ == null ? null : this[assembly.BuildAssemblyQualifiedName (typ)]; } }
public EventDefinition(string name, TypeReference eventType, EventAttributes attrs) : base(name) { m_eventType = eventType; m_attributes = attrs; }
private bool ShouldAddCast(Expression argument, List<MethodDefinition> sameNameMethods, int argumentIndex, TypeReference calledMethodParamType) { if (!argument.HasType) { return true; } TypeReference expressionType = argument.ExpressionType; //if (argument.ExpressionType.IsGenericParameter) //{ // return false; //} foreach (MethodDefinition method in sameNameMethods) { TypeReference parameterType = method.Parameters[argumentIndex].ParameterType; if (IsTypeDescendantOf(calledMethodParamType, parameterType) || calledMethodParamType.FullName == parameterType.FullName) { /// Either the called method has more specific type, /// or the types match. continue; } if (IsTypeDescendantOf(expressionType, parameterType) || expressionType.FullName == parameterType.FullName) { return true; } if (argument.CodeNodeType == CodeNodeType.LiteralExpression && ((LiteralExpression)argument).Value == null) { if (!parameterType.IsValueType) { return true; } } } return false; }
public MethodDefinition createMethod(String sMethodName, MethodAttributes maMethodAttributes, TypeReference trReturnType) { var newMethod = new MethodDefinition(sMethodName, maMethodAttributes, trReturnType); newMethod.Body.CilWorker.Emit(OpCodes.Ret); return newMethod; }
public TypeDefinition addType(String sTypeNameSpace, String sTypeName, TypeAttributes taTypeAttributes, TypeReference trTypeReference) { var tdNewType = new TypeDefinition(sTypeName, sTypeNameSpace, taTypeAttributes, trTypeReference); mainModule.Types.Add(tdNewType); return tdNewType; }
/// <summary> /// Make minor fixes after the implementation phase. /// </summary> public void FixUp(DexTargetPackage targetPackage) { var iMethod = method.GetBaseInterfaceMethod(); Mono.Cecil.TypeReference inheritedReturnType = null; //var iMethod = method.Overrides.Select(x => x.Resolve()).Where(x => x != null).FirstOrDefault(x => x.DeclaringType.IsInterface); if (iMethod != null) { inheritedReturnType = iMethod.ReturnType; } var baseMethod = method.GetBaseMethod(); if (baseMethod != null) { inheritedReturnType = baseMethod.ReturnType; } if (inheritedReturnType != null) { var inheritedTargetReturnType = inheritedReturnType.GetReference(targetPackage, compiler.Module); if (inheritedTargetReturnType.Descriptor != dmethod.Prototype.ReturnType.Descriptor) { dmethod.Prototype.Unfreeze(); dmethod.Prototype.ReturnType = inheritedTargetReturnType; dmethod.Prototype.Freeze(); //// update the original method's return type as well, //// to make sure the code generation later knows what it is handling. //// TODO: this seems to be a hack. shouldn't this have been handled //// during the IL-conversion phase? xMethod.SetInheritedReturnType(inheritedReturnType); } } }
public static TypeDefinition Resolve(IAssemblyResolver resolver, TypeReference type) { type = type.GetElementType (); var scope = type.Scope; switch (scope.MetadataScopeType) { case MetadataScopeType.AssemblyNameReference: var assembly = resolver.Resolve ((AssemblyNameReference) scope); if (assembly == null) return null; return GetType (assembly.MainModule, type); case MetadataScopeType.ModuleDefinition: return GetType ((ModuleDefinition) scope, type); case MetadataScopeType.ModuleReference: var modules = type.Module.Assembly.Modules; var module_ref = (ModuleReference) scope; for (int i = 0; i < modules.Count; i++) { var netmodule = modules [i]; if (netmodule.Name == module_ref.Name) return GetType (netmodule, type); } break; } throw new NotSupportedException (); }
public TypeNode(string name, string parent = "", bool builtIn = false, TypeReference type = null) { Name = name; Type = type; Parent = parent; BuiltIn = builtIn; }
public MethodDefinition(string name, MethodAttributes attributes, TypeReference returnType) : base(name, returnType) { this.attributes = (ushort) attributes; this.HasThis = !this.IsStatic; this.token = new MetadataToken (TokenType.Method); }
static MethodDefinition CreateTestMethod(Emitter emitter) { TypeReference type = new TypeReference("", "Test", null, null); MethodDefinition test = new MethodDefinition("Test", MethodAttributes.Public, type); emitter(test.Body.GetILProcessor()); return test; }
public TypeDefinition GetTypeDefinition (TypeReference type) { if (type == null) return null; TypeDefinition typeDef = type as TypeDefinition; if (typeDef != null) return typeDef; AssemblyNameReference name = type.Scope as AssemblyNameReference; if (name == null) { GenericInstanceType gi = type as GenericInstanceType; return gi == null ? null : GetTypeDefinition (gi.ElementType); } AssemblyDefinition assmDef; try { assmDef = Resolve (name); } catch (FileNotFoundException) { throw new ObfuscarException ("Unable to resolve dependency: " + name.Name); } string fullName = type.GetFullName (); typeDef = assmDef.MainModule.GetType (fullName); return typeDef; }
public EmitDelegateConvert(ILEmitter preceedingCode, ILEmitter itemToConvert, TypeReference targetType) : base(preceedingCode) { _inner = new EmptyEmitter(preceedingCode) .Call(Importer.DelegateConvertChangeType, itemToConvert, new EmptyEmitter(preceedingCode).TypeOf(targetType)) .CastClass(targetType); }
public Tuple<TypeDefinition, AssemblyDefinition> this[TypeReference typ, AssemblyDefinition assembly] { get { return this[typ, assembly.Name]; } }
/// <summary> /// Is the given attribute type ApplicationRootAttribute or derived of that type? /// </summary> private bool IsApplicationRootAttribute(TypeReference attributeType) { var typeDef = attributeType.Resolve(); if (typeDef == null) { return(false); } // Try the cache bool result; if (isApplicationRootTypes.TryGetValue(typeDef, out result)) { return(result); } // No in cache yet, find out if ((typeDef.Namespace == AttributeConstants.Dot42AttributeNamespace) && (typeDef.Name == AttributeConstants.ApplicationRootAttributeName)) { result = true; } else { // Try base type result = (typeDef.BaseType != null) && IsApplicationRootAttribute(typeDef.BaseType); } isApplicationRootTypes[typeDef] = result; return(result); }
public static string PickMemoryTypeSuffix(TypeReference type, bool isStore) { switch (type.FullName) { case "System.Byte": if (isStore) return "8"; else return "8_u"; case "System.SByte": return "8"; case "System.UInt16": if (isStore) return "16"; else return "16_u"; case "System.Int16": return "16"; // FIXME: i8 or i16 for char? } return ""; }
public Cecil.MethodDefinition MethodDefinition(AnalysisNet.Types.MethodDefinition methodDefinition) { Cecil.MethodDefinition cecilMethodDefinition = new Cecil.MethodDefinition(methodDefinition.Name, 0, Context.CurrentModule.TypeSystem.Void); GenerateMethodAttributes(methodDefinition, cecilMethodDefinition); cecilMethodDefinition.CreateGenericParameters(methodDefinition.GenericParameters.Count); Cecil.TypeReference returnType = ReferenceGenerator.TypeReference(methodDefinition.ReturnType); cecilMethodDefinition.ReturnType = returnType; AddConstraintsToGenericParameters(methodDefinition, cecilMethodDefinition); Cecil.TypeReference typeRef = ReferenceGenerator.TypeReference(methodDefinition.ContainingType); Cecil.TypeDefinition containingType = typeRef.Resolve(); cecilMethodDefinition.DeclaringType = containingType as Cecil.TypeDefinition; SetOverrides(methodDefinition, cecilMethodDefinition); SetCustomAttributes(methodDefinition.Attributes, cecilMethodDefinition.CustomAttributes); IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> parameterDefinitions = CreateParameters(methodDefinition, cecilMethodDefinition); if (methodDefinition.HasBody) { cecilMethodDefinition.Body.MaxStackSize = methodDefinition.Body.MaxStack; cecilMethodDefinition.Body.InitLocals = methodDefinition.Body.LocalVariables.Count > 0; IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> variableDefinitions = CreateLocalVariables(methodDefinition, cecilMethodDefinition); InstructionGenerator instructionGenerator = new InstructionGenerator(ReferenceGenerator); // analysis-net instruction -> [cecil instruction] IDictionary <AnalysisNet.Bytecode.Instruction, IList <Cecil.Cil.Instruction> > mapInstructions = instructionGenerator.CreateInstructions(methodDefinition, cecilMethodDefinition, variableDefinitions, parameterDefinitions); CreateExceptionHandlers(mapInstructions, methodDefinition.Body, cecilMethodDefinition.Body); } return(cecilMethodDefinition); }
private DynamicIndexerExpression(Expression target, ExpressionCollection indices, TypeReference expressionType, IEnumerable<Instruction> instructions) :base(instructions) { this.Target = target; this.Indices = indices; this.ExpressionType = expressionType; }
public JSInvocationExpression CreateInstanceOfType(TypeReference type) { return JSInvocationExpression.InvokeStatic( Dot(new JSFakeMethod("CreateInstanceOfType", type, new[] { TypeSystem.Object }, MethodTypes)), new[] { new JSTypeOfExpression(type) } ); }
public string create(TypeReference typeRef) { if (typeRef.IsGenericInstance) { var git = (GenericInstanceType)typeRef; if (git.ElementType.FullName == "System.Nullable`1" && git.GenericArguments.Count == 1 && git.GenericArguments[0] != null) { typeRef = git.GenericArguments[0]; } } string prefix = getPrefix(typeRef); var elementType = typeRef.GetElementType(); if (elementType is GenericParameter) return genericParamNameCreator.create(); NameCreator nc; var typeFullName = typeRef.FullName; if (typeNames.TryGetValue(typeFullName, out nc)) return nc.create(); var name = elementType.FullName; var parts = name.Replace('/', '.').Split(new char[] { '.' }); var newName = parts[parts.Length - 1]; int tickIndex = newName.LastIndexOf('`'); if (tickIndex > 0) newName = newName.Substring(0, tickIndex); return addTypeName(typeFullName, newName, prefix).create(); }
public TypeReference convert(TypeReference typeRef) { if (typeRef == null) return null; typeRef = new TypeReferenceConverter(this).convert(typeRef); return tryGetTypeDefinition(typeRef); }
private TypeReference ResolveGenericParameters(TypeReference typeReference) { if (typeReference.IsGenericParameter) { GenericParameter parameter = (GenericParameter) typeReference; return Enumerable.ElementAt<TypeReference>(this.GenericArguments, parameter.Position); } if (typeReference.IsGenericInstance) { GenericInstanceType type = (GenericInstanceType) typeReference; GenericInstanceType type2 = new GenericInstanceType(this.ResolveGenericParameters(type.ElementType)); foreach (TypeReference reference2 in type.GenericArguments) { type2.GenericArguments.Add(this.ResolveGenericParameters(reference2)); } return type2; } if (typeReference.IsArray) { ArrayType type3 = (ArrayType) typeReference; return new ArrayType(this.ResolveGenericParameters(type3.ElementType), type3.Rank); } if (typeReference.IsPointer) { return new PointerType(this.ResolveGenericParameters(((PointerType) typeReference).ElementType)); } if (typeReference.IsByReference) { return new ByReferenceType(this.ResolveGenericParameters(((ByReferenceType) typeReference).ElementType)); } return typeReference; }
/// <summary> /// Gets the human readable name of the given type. /// </summary> public static string GetShortTypeName(TypeReference type, bool includeGenericParameters, bool includeGenericArguments) { if (type.IsNested) { var result = GetShortTypeName(type.DeclaringType, includeGenericParameters, includeGenericArguments) + "." + StripGenericParameterCount(type.Name); if (includeGenericParameters) result += GetGenericParameters(type); return result; } if (type.IsArray) { return GetShortTypeName(((ArrayType)type).ElementType) + "[]"; } if (type.IsGenericParameter) return type.Name; if (type.IsGenericInstance) { var git = (GenericInstanceType)type; var arguments = includeGenericArguments ? git.GenericArguments.Select(x => GetShortTypeName(x, includeGenericParameters, includeGenericArguments)) : git.ElementType.GenericParameters.Select(x => x.Name); return GetShortTypeName(git.ElementType, false, false) + '<' + string.Join(",", arguments) + '>'; } if (type.IsByReference) { return "ref " + GetShortTypeName(((ByReferenceType)type).ElementType); } var fullName = type.FullName; string replacement; if (typeReplacements.TryGetValue(fullName, out replacement)) return replacement; var prefix = (type.DeclaringType != null) ? GetShortTypeName(type.DeclaringType) + "." : string.Empty; var name = StripGenericParameterCount(type.Name); if (includeGenericParameters) name += GetGenericParameters(type); return prefix + name; }
private AnalysisNet.IInstruction ProcessConversion(Cecil.Cil.Instruction op) { AnalysisNetBytecode.ConvertOperation operation = OperationHelper.ToConvertOperation(op.OpCode.Code); bool overflow = OperationHelper.PerformsOverflowCheck(op.OpCode.Code); bool unsigned = OperationHelper.OperandsAreUnsigned(op.OpCode.Code); Cecil.TypeReference cciType = op.Operand as Cecil.TypeReference; AnalysisNet.Types.IType ourType = OperationHelper.GetOperationType(op.OpCode.Code); if (operation == AnalysisNetBytecode.ConvertOperation.Box) { ourType = typeExtractor.ExtractType(cciType); } else if (operation == AnalysisNetBytecode.ConvertOperation.Conv) { ourType = OperationHelper.GetOperationType(op.OpCode.Code); } else if (operation == AnalysisNetBytecode.ConvertOperation.Cast) { ourType = typeExtractor.ExtractType(op.Operand as Cecil.TypeReference); } AnalysisNetBytecode.ConvertInstruction instruction = new AnalysisNetBytecode.ConvertInstruction((uint)op.Offset, operation, ourType) { OverflowCheck = overflow, UnsignedOperands = unsigned }; return(instruction); }
private Cecil.FieldDefinition CreateFieldDefinition(AnalysisNet.Types.FieldDefinition fieldDefinition) { Cecil.FieldAttributes fieldAttribute = Cecil.FieldAttributes.Public; if (fieldDefinition.IsStatic) { fieldAttribute |= Cecil.FieldAttributes.Static; } Cecil.TypeReference fieldType = ReferenceGenerator.TypeReference(fieldDefinition.Type); Cecil.FieldDefinition cecilField = new Cecil.FieldDefinition(fieldDefinition.Name, fieldAttribute, fieldType); if (fieldDefinition.Value != null) { cecilField.Constant = fieldDefinition.Value.Value; cecilField.HasConstant = true; } byte[] newArray = new byte[fieldDefinition.InitialValue.Length]; Array.Copy(fieldDefinition.InitialValue, newArray, newArray.Length); cecilField.InitialValue = newArray; if (newArray.Length > 0) { cecilField.Attributes |= Cecil.FieldAttributes.HasFieldRVA; } return(cecilField); }
public BinaryExpression(BinaryOperator @operator, Expression left, Expression right, TypeReference expressionType, TypeSystem typeSystem, IEnumerable<Instruction> instructions, bool isOverridenOperation = false) : this(@operator, left, right, DetermineIsChecked(instructions), instructions, isOverridenOperation) { this.ExpressionType = expressionType; this.typeSystem = typeSystem; }
internal static Type GetActualType(this MemberType memberType) { Mono.Cecil.TypeReference typeReference = null; object type = memberType.Annotations.First(); TypeDefinition typeDefinition = type as TypeDefinition; if (typeDefinition != null) { return(typeDefinition.GetActualType()); } typeReference = type as Mono.Cecil.TypeReference; if (typeReference != null) { if (typeReference.HasGenericParameters) { Type[] parameters = new Type[typeReference.GenericParameters.Count]; Type genericType = typeReference.GetActualType(); var simpleType = memberType.Target as SimpleType; simpleType.TypeArguments .ForEach((p, i) => { Type parameterType = p.GetActualType(); parameters[i] = parameterType; }); return(genericType.MakeGenericType(parameters)); } return(typeReference.GetActualType()); } return(null); }
public void InsertInstruction() { var object_ref = new TypeReference ("System", "Object", null, false); var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref); var body = new MethodBody (method); var il = body.GetILProcessor (); var first = il.Create (OpCodes.Nop); var second = il.Create (OpCodes.Nop); var third = il.Create (OpCodes.Nop); body.Instructions.Add (first); body.Instructions.Add (third); Assert.IsNull (first.Previous); Assert.AreEqual (third, first.Next); Assert.AreEqual (first, third.Previous); Assert.IsNull (third.Next); body.Instructions.Insert (1, second); Assert.IsNull (first.Previous); Assert.AreEqual (second, first.Next); Assert.AreEqual (first, second.Previous); Assert.AreEqual (third, second.Next); Assert.AreEqual (second, third.Previous); Assert.IsNull (third.Next); }
public static string PickTypeKeyword(TypeReference type) { // FIXME switch (type.FullName) { case "System.Void": return "void"; case "System.Boolean": case "System.Int32": case "System.UInt32": return "i32"; case "System.Int64": case "System.UInt64": return "i64"; case "System.Single": return "f32"; case "System.Double": return "f64"; case "System.Byte": case "System.UInt16": case "System.SByte": case "System.Int16": return "i32"; } return null; }
public ArrayCreationExpression(TypeReference type, InitializerExpression initializer, IEnumerable<Instruction> instructions) :base(instructions) { this.ElementType = type; this.Initializer = initializer; this.Dimensions = new ExpressionCollection(); }
public JSInvocationExpression Coalesce(JSExpression left, JSExpression right, TypeReference expectedType) { return JSInvocationExpression.InvokeStatic( Dot("Coalesce", expectedType), new[] { left, right }, true ); }
public static string[] GetPackedArrayArgumentNames (MethodInfo method, out TypeReference packedArrayAttributeType) { packedArrayAttributeType = null; AttributeGroup packedArrayAttribute; if ( (method != null) && ((packedArrayAttribute = method.Metadata.GetAttribute("JSIL.Meta.JSPackedArrayArgumentsAttribute")) != null) ) { var result = new List<string>(); foreach (var entry in packedArrayAttribute.Entries) { packedArrayAttributeType = entry.Type; var argumentNames = entry.Arguments[0].Value as IList<CustomAttributeArgument>; if (argumentNames == null) throw new ArgumentException("Arguments to JSPackedArrayArguments must be strings"); foreach (var attributeArgument in argumentNames) { var argumentName = attributeArgument.Value as string; if (argumentName == null) throw new ArgumentException("Arguments to JSPackedArrayArguments must be strings"); result.Add(argumentName); } } return result.ToArray(); } return null; }
public static bool ContainsPositionalGenericParameter(TypeReference type) { type = DereferenceType(type); var gp = type as GenericParameter; var git = type as GenericInstanceType; var at = type as ArrayType; var byref = type as ByReferenceType; if (gp != null) return IsPositionalGenericParameter(gp); if (git != null) { var elt = git.ElementType; foreach (var ga in git.GenericArguments) { if (IsPositionalGenericParameter(ga)) return true; } return IsPositionalGenericParameter(elt); } if (at != null) return IsPositionalGenericParameter(at.ElementType); if (byref != null) return IsPositionalGenericParameter(byref.ElementType); return false; }
public OptionalModifierType(TypeReference modifierType, TypeReference type) : base(type) { Mixin.CheckModifier (modifierType, type); this.modifier_type = modifierType; this.etype = MD.ElementType.CModOpt; }
public Cecil.MethodReference MethodReference(AnalysisNet.Types.IMethodReference methodReference) { if (methodsCache.TryGetValue(methodReference, out Cecil.MethodReference cecilMethodReference)) { return(cecilMethodReference); } Cecil.TypeReference dummyReturnType = Context.CurrentModule.TypeSystem.Void; Cecil.TypeReference declaringType = TypeReference(methodReference.ContainingType); string name = methodReference.Name; cecilMethodReference = new Cecil.MethodReference(name, dummyReturnType, declaringType) { HasThis = !methodReference.IsStatic }; if (methodReference.GenericParameterCount > 0) { cecilMethodReference.CreateGenericParameters(methodReference.GenericParameterCount); MapGenericParameters(cecilMethodReference, methodReference); // should we add constraints? if (methodReference.GenericArguments.Count == 0) { Cecil.GenericInstanceMethod instantiated = new Cecil.GenericInstanceMethod(cecilMethodReference); instantiated.GenericArguments.AddRange(cecilMethodReference.GenericParameters); cecilMethodReference = instantiated; } else { IEnumerable <Cecil.TypeReference> arguments = methodReference.GenericArguments.Select(ga => TypeReference(ga)); Cecil.GenericInstanceMethod instantiated = new Cecil.GenericInstanceMethod(cecilMethodReference); instantiated.GenericArguments.AddRange(arguments); cecilMethodReference = instantiated; } } cecilMethodReference.ReturnType = TypeReference(methodReference.ReturnType); foreach (AnalysisNet.Types.IMethodParameterReference parameter in methodReference.Parameters) { Cecil.ParameterDefinition cecilParam = new Cecil.ParameterDefinition(TypeReference(parameter.Type)); if (parameter.Kind == AnalysisNet.Types.MethodParameterKind.In) { cecilParam.IsIn = true; } else if (parameter.Kind == AnalysisNet.Types.MethodParameterKind.Out) { cecilParam.IsOut = true; } cecilMethodReference.Parameters.Add(cecilParam); } cecilMethodReference = Context.CurrentModule.ImportReference(cecilMethodReference); methodsCache[methodReference] = cecilMethodReference; return(cecilMethodReference); }
public static IndexBase.TypeReference ToIndexBaseTypeReference(this Mono.Cecil.TypeReference typeReference) { return(new IndexBase.TypeReference { AssemblyName = typeReference.Module.Assembly.Name.Name, FullName = typeReference.FullName }); }
private AnalysisNet.IInstruction ProcessSizeof(Cecil.Cil.Instruction op) { Cecil.TypeReference cciType = op.Operand as Cecil.TypeReference; AnalysisNet.Types.IType ourType = typeExtractor.ExtractType(cciType); AnalysisNetBytecode.SizeofInstruction instruction = new AnalysisNetBytecode.SizeofInstruction((uint)op.Offset, ourType); return(instruction); }
public static string ToTypeScriptType(this Mono.Cecil.TypeReference typeReference) { typeReference = GetNullableType(typeReference); if (genericTypeMap == null) { genericTypeMap = typeMap .ToDictionary(item => "<" + item.Key + ">", item => "<" + item.Value + ">"); typeMap .ToDictionary(item => item.Key + "[]", item => item.Value + "[]") .Each(x => genericTypeMap.Add(x.Key, x.Value)); } var fromName = typeReference.FullName; // translate / in nested classes into underscores fromName = fromName.Replace("/", "_"); if (typeMap.ContainsKey(fromName)) { return(typeMap[fromName]); } var genericType = genericTypeMap.FirstOrDefault(x => fromName.Contains(x.Key)); if (!genericType.Equals(default(System.Collections.Generic.KeyValuePair <string, string>))) { fromName = fromName.Replace(genericType.Key, genericType.Value); } fromName = fromName .StripGenericTick(); // To lazy to figure out the Mono.Cecil way (or if there is a way), but do // some string search/replace on types for example: // // turn // Windows.Foundation.Collections.IMapView<System.String,System.Object>; // into // Windows.Foundation.Collections.IMapView<string,any>; // typeMap.Each(item => { fromName = fromName.Replace(item.Key, item.Value); }); // If it's an array type return it as such. var genericTypeArgName = ""; if (IsTypeArray(typeReference, out genericTypeArgName)) { return(genericTypeArgName + "[]"); } // remove the generic bit return(fromName); }
public void Add(Mono.Cecil.TypeReference type) { // Add all methods of type. Mono.Cecil.TypeDefinition type_defintion = type.Resolve(); foreach (Mono.Cecil.MethodDefinition definition in type_defintion.Methods) { Add(definition); } }
/// <summary> /// Create an argument for an annotation. /// </summary> private static AnnotationArgument CreateAnnotationArgument(string name, TypeReference valueType, object value, DexTargetPackage targetPackage, XModule module) { if (valueType.IsSystemType()) { // Convert .NET type reference to Dex type reference value = ((TypeReference)value).GetReference(targetPackage, module); } return(new AnnotationArgument(name, value)); }
public override void Visit(Model.Bytecode.InitObjInstruction instruction) { Cecil.Cil.OpCode op = Cecil.Cil.OpCodes.Initobj; Cecil.TypeReference type = referenceGenerator.TypeReference(instruction.Type); Result = new List <Mono.Cecil.Cil.Instruction>() { processor.Create(op, type) }; }
private static bool IsNullable(this Mono.Cecil.TypeReference typeReference) { // TODO: is there a better way to determine if it's a Nullable? if (typeReference.Namespace == "System" && typeReference.Name == "Nullable`1") { return(true); } return(false); }
private Cecil.TypeReference ImportTypeReference(Cecil.TypeReference typeReference) { if (typeReference.Module == null || typeReference.Module != Context.CurrentModule) { typeReference = Context.CurrentModule.ImportReference(typeReference); } return(typeReference); }
private void SetDeclaringType(AnalysisNet.Types.TypeDefinition typeDefinition, Cecil.TypeDefinition cecilDef) { Cecil.TypeReference declaringTypeRef = typeDefinition.ContainingType == null ? null : ReferenceGenerator.TypeReference(typeDefinition.ContainingType); if (declaringTypeRef != null) { Cecil.TypeDefinition declaringType = declaringTypeRef.Resolve(); declaringType.NestedTypes.Add(cecilDef); cecilDef.DeclaringType = declaringType; } }
public static TypeDefinition ToDef(this Mono.Cecil.TypeReference tr) { var res = tr.Resolve(); if (res == null) { throw new InvalidOperationException(); } return(res); }
public NetTypeReference Visit(TypeReference type, ResolveData data) { var typeDef = type.Resolve(); if (typeDef == null) { throw new ImportException(string.Format("Cannot resolve type {0}", type.FullName)); } return(Visit(typeDef, data)); }
/// <summary> /// Gets the type definition containing all the methods for the given type. /// </summary> /// <returns></returns> TypeDefinition GetMethodTypeDefinition(TypeReference typeReference) { if (typeReference is ArrayType) { // Return ArrayType return(corlib.MainModule.GetType(typeof(Array).FullName)); } // Default: resolve to get real type return(typeReference.Resolve()); }
private static MethodReference ResolveGenericMethod(TypeReference typeReference, MethodReference method) { var genericInstanceType = typeReference as GenericInstanceType; if (genericInstanceType != null) { return(method.MakeGeneric(genericInstanceType.GenericArguments.ToArray())); } return(method); }
public Type FindType(Cecil.TypeReference typeRef) { var type = resolver.FindType(typeRef); if (type == null) { throw new Exception(String.Format("Cannot resolve type {0}", typeRef)); } return(type); }
public static string PrintShortType(this Mono.Cecil.TypeReference type) { var ginst = type as GenericInstanceType; if (ginst != null) { return(string.Format("{0}<{1}>", type.Name, ginst.GenericArguments.Select(w => w.Name).Aggregate((a, b) => a + ", " + b))); } return(type.Name); }
public static bool IsSimilarType(Type thisType, Mono.Cecil.TypeReference type) { // Ignore any 'ref' types if (thisType.IsByRef) { thisType = thisType.GetElementType(); } if (type.IsByReference) { if (type.IsArray) { var array_type = type as ArrayType; type = array_type.ElementType; } else { type = type.GetElementType(); } } // Handle array types if (thisType.IsArray && type.IsArray) { Mono.Cecil.ArrayType at = type as Mono.Cecil.ArrayType; // Dimensions must be the same. if (thisType.GetArrayRank() != at.Rank) { return(false); } // Base type of array must be the same. var array_type = type as ArrayType; return(IsSimilarType(thisType.GetElementType(), array_type.ElementType)); } if (thisType.IsArray && !type.IsArray) { return(false); } if (type.IsArray && !thisType.IsArray) { return(false); } // If the types are identical, or they're both generic parameters // or the special 'T' type, treat as a match // Match also if thisType is generic and type can be unified with thisType. if (thisType.Name == type.Name || // identical types. ((thisType.IsGenericParameter || thisType == typeof(T)) && (type.IsGenericParameter || type.Name.Equals("T"))) || // using "T" as matching generic type. IsUnifiableMono(thisType, type)) { return(true); } return(false); }
public TYPE(Mono.Cecil.TypeReference mono_type) { _cil_type = mono_type.SwapInBclType(); _cil_type_llvm = _cil_type.ToTypeRef(); _verification_type = METAHELPER.InitVerificationType(_cil_type); _storage_type = _verification_type; _storage_type_llvm = _storage_type.ToTypeRef(); _stack_verification_type = METAHELPER.InitStackVerificationType(_verification_type, _cil_type); _intermediate_type = _stack_verification_type; _intermediate_type_llvm = _stack_verification_type.ToTypeRef(); }
protected static IList GetArgumentsToBaseConstructor(MC.CustomAttribute att, MC.TypeReference baseType) { if (att.AttributeType.FullName == baseType.FullName) { return(att.ConstructorArguments.Select(arg => arg.Value).ToList()); } else { //FIXME: Implement throw new NotImplementedException(); } }
public static int GetArrayInfo(Mono.Cecil.TypeReference type, out Mono.Cecil.TypeReference elementType) { elementType = type; int rank = 0; while (type.IsArray) { rank++; elementType = type = type.GetElementType(); } return(rank); }
protected static IList GetArgumentsToBaseConstructor(MC.CustomAttribute att, MC.TypeReference baseType) { if (att.Constructor.DeclaringType.FullName == baseType.FullName) { return(att.ConstructorParameters); } else { //FIXME: Implement throw new NotImplementedException(); } }
private bool IsDelegate(Cecil.TypeDefinition cecilType) { Cecil.TypeReference baseType = cecilType.BaseType; if (baseType == null) { return(false); } Cecil.IMetadataScope coreLibrary = cecilType.Module.TypeSystem.CoreLibrary; return(coreLibrary.Equals(baseType.Scope) && baseType.Namespace == "System" && baseType.Name == "MulticastDelegate"); }
public AnalysisNet.Types.IType ExtractType(Cecil.TypeReference typeReference) { return(performanceCache.GetOrCreate(typeReference, (cacheEntry) => { AnalysisNet.Types.IType result = null; if (typeReference is Cecil.ArrayType arrayType) { result = ExtractType(arrayType); } else if (typeReference is Cecil.ByReferenceType byReferenceType) { result = ExtractType(byReferenceType); } else if (typeReference is Cecil.PointerType pointerType) { result = ExtractType(pointerType); } else if (typeReference is Cecil.GenericParameter genericParameterType) { result = ExtractType(genericParameterType); } else if (typeReference is Cecil.FunctionPointerType functionPointerType) { result = ExtractType(functionPointerType); } else if (typeReference is Cecil.GenericInstanceType genericInstanceType) { result = ExtractType(genericInstanceType); } else { // named type reference result = ExtractNonGenericInstanceType(typeReference); } if (result is AnalysisNet.Types.BasicType) { AnalysisNet.Types.BasicType basicType = result as AnalysisNet.Types.BasicType; basicType.Resolve(host); if (basicType.GenericType is AnalysisNet.Types.BasicType) { basicType = basicType.GenericType as AnalysisNet.Types.BasicType; basicType.Resolve(host); } } return result; })); }