public TypeInfo(TypeDef typeDef, MemberInfos memberInfos) : base(typeDef) { this.type = typeDef; this.memberInfos = memberInfos; oldNamespace = typeDef.TypeDefinition.Namespace; }
public MethodDef(MethodDefinition methodDefinition, TypeDef owner, int index) : base(methodDefinition, owner, index) { genericParams = GenericParamDef.createGenericParamDefList(MethodDefinition.GenericParameters); for (int i = 0; i < methodDefinition.Parameters.Count; i++) { var param = methodDefinition.Parameters[i]; paramDefs.Add(new ParamDef(param, i)); } }
void findInitializeComponentMethod(TypeDef type, MethodDef possibleInitMethod) { foreach (var methodDef in type.AllMethods) { if (methodDef.MethodDefinition.Name != ".ctor") continue; if (methodDef.MethodDefinition.Body == null) continue; foreach (var instr in methodDef.MethodDefinition.Body.Instructions) { if (instr.OpCode.Code != Code.Call && instr.OpCode.Code != Code.Callvirt) continue; if (!MemberReferenceHelper.compareMethodReferenceAndDeclaringType(possibleInitMethod.MethodDefinition, instr.Operand as MethodReference)) continue; memberInfos.method(possibleInitMethod).suggestedName = "InitializeComponent"; return; } } }
public PropertyDef(PropertyDefinition propertyDefinition, TypeDef owner, int index) : base(propertyDefinition, owner, index) { }
public TypeInfo(TypeReference typeReference, TypeDef typeDef) { this.typeReference = typeReference; this.typeDef = typeDef; }
public void addBaseType(TypeDef baseDef, TypeReference baseRef) { if (baseDef == null || baseRef == null) return; baseType = new TypeInfo(baseRef, baseDef); }
public void RemoveTypeDef(TypeDef td) { if (!TypeDefs.Remove(td)) throw new ApplicationException(string.Format("Could not remove TypeDef: {0}", td)); }
void mergeState(TypeDef other) { if (other == null) return; TypeInfo otherInfo; if (!memberInfos.tryGetType(other, out otherInfo)) return; variableNameState.merge(otherInfo.variableNameState); }
void merge(TypeDef type) { if (visited.ContainsKey(type)) return; visited[type] = true; TypeInfo info; if (!memberInfos.tryGetType(type, out info)) return; if (type.baseType != null) merge(type.baseType.typeDef); foreach (var ifaceInfo in type.interfaces) merge(ifaceInfo.typeDef); if (type.baseType != null) merge(info, type.baseType.typeDef); foreach (var ifaceInfo in type.interfaces) merge(info, ifaceInfo.typeDef); }
void visit(TypeDef type) { if (visited.ContainsKey(type)) return; visited[type] = true; if (type.baseType != null) visit(type.baseType.typeDef); foreach (var ifaceInfo in type.interfaces) visit(ifaceInfo.typeDef); TypeInfo info; if (!memberInfos.tryGetType(type, out info)) return; foreach (var method in type.AllMethodsSorted) { MethodNameGroup group; if (!methodToGroup.TryGetValue(method, out group)) continue; foreach (var m in group.Methods) methodToGroup.Remove(m); func(group); } }
void renameMembers(TypeDef type) { var info = memberInfos.type(type); Log.v("Type: {0}", Utils.removeNewlines(info.type.TypeDefinition.FullName)); Log.indent(); renameFields(info); renameProperties(info); renameEvents(info); renameMethods(info); Log.deIndent(); }
void rename(TypeDef type) { var typeDefinition = type.TypeDefinition; var info = memberInfos.type(type); Log.v("Type: {0} ({1:X8})", Utils.removeNewlines(typeDefinition.FullName), typeDefinition.MetadataToken.ToUInt32()); Log.indent(); renameGenericParams(type.GenericParams); if (RenameTypes && info.gotNewName()) { var old = typeDefinition.Name; typeDefinition.Name = info.newName; Log.v("Name: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Name)); } if (RenameNamespaces && info.newNamespace != null) { var old = typeDefinition.Namespace; typeDefinition.Namespace = info.newNamespace; Log.v("Namespace: {0} => {1}", Utils.removeNewlines(old), Utils.removeNewlines(typeDefinition.Namespace)); } Log.deIndent(); }
public MTypeDef(TypeDef typeDef, Module module, int index) : base(typeDef, null, index) { this.module = module; genericParams = MGenericParamDef.CreateGenericParamDefList(TypeDef.GenericParameters); }
protected Ref(MemberReference memberReference, TypeDef owner, int index) { this.memberReference = memberReference; Owner = owner; Index = index; }
string findWindowsFormsClassName(TypeDef type) { foreach (var methodDef in type.AllMethods) { if (methodDef.MethodDefinition.Body == null) continue; if (methodDef.MethodDefinition.IsStatic || methodDef.MethodDefinition.IsVirtual) continue; var instructions = methodDef.MethodDefinition.Body.Instructions; for (int i = 2; i < instructions.Count; i++) { var call = instructions[i]; if (call.OpCode.Code != Code.Call && call.OpCode.Code != Code.Callvirt) continue; if (!isWindowsFormsSetNameMethod(call.Operand as MethodReference)) continue; var ldstr = instructions[i - 1]; if (ldstr.OpCode.Code != Code.Ldstr) continue; var className = ldstr.Operand as string; if (className == null) continue; if (DotNetUtils.getArgIndex(instructions[i - 2]) != 0) continue; findInitializeComponentMethod(type, methodDef); return className; } } return null; }
void merge(TypeInfo info, TypeDef other) { TypeInfo otherInfo; if (!memberInfos.tryGetType(other, out otherInfo)) return; if ((flags & MergeStateFlags.Methods) != MergeStateFlags.None) info.variableNameState.mergeMethods(otherInfo.variableNameState); if ((flags & MergeStateFlags.Properties) != MergeStateFlags.None) info.variableNameState.mergeProperties(otherInfo.variableNameState); if ((flags & MergeStateFlags.Events) != MergeStateFlags.None) info.variableNameState.mergeEvents(otherInfo.variableNameState); }
void prepare(TypeDef type) { if (prepareMethodCalled.ContainsKey(type)) return; prepareMethodCalled[type] = true; foreach (var ifaceInfo in type.interfaces) prepare(ifaceInfo.typeDef); if (type.baseType != null) prepare(type.baseType.typeDef); TypeInfo info; if (memberInfos.tryGetType(type, out info)) func(info); }
void Add(TypeDef td) { if (td == null || typeDefs.ContainsKey(td)) return; if (td.Module != validModule) return; typeDefs[td] = true; Push(td.BaseType); Add(td.Fields); Add(td.Methods); Add(td.GenericParameters); Add(td.Interfaces); Add(td.DeclSecurities); Add(td.DeclaringType); Add(td.Events); Add(td.Properties); Add(td.NestedTypes); Add(td.CustomAttributes); }
EventDef createEvent(TypeDef ownerType, string name, TypeReference eventType) { if (string.IsNullOrEmpty(name) || eventType == null || eventType.FullName == "System.Void") return null; var newEvent = DotNetUtils.createEventDefinition(name, eventType); var eventDef = ownerType.findAny(newEvent); if (eventDef != null) return eventDef; eventDef = ownerType.create(newEvent); memberInfos.add(eventDef); Log.v("Restoring event: {0}", Utils.removeNewlines(newEvent)); return eventDef; }
public void add(TypeDef t) { types.add(t); }
PropertyDef createProperty(TypeDef ownerType, string name, TypeReference propType, MethodDefinition getter, MethodDefinition setter) { if (string.IsNullOrEmpty(name) || propType.FullName == "System.Void") return null; var newProp = DotNetUtils.createPropertyDefinition(name, propType, getter, setter); var propDef = ownerType.findAny(newProp); if (propDef != null) return propDef; propDef = ownerType.create(newProp); memberInfos.add(propDef); Log.v("Restoring property: {0}", Utils.removeNewlines(newProp)); return propDef; }
public void addInterface(TypeDef ifaceDef, TypeReference iface) { if (ifaceDef == null || iface == null) return; interfaces.Add(new TypeInfo(iface, ifaceDef)); }
void fixClsTypeNames(TypeDef nesting, TypeDef nested) { int nestingCount = nesting == null ? 0 : nesting.GenericParams.Count; int arity = nested.GenericParams.Count - nestingCount; var nestedInfo = memberInfos.type(nested); if (nestedInfo.renamed && arity > 0) nestedInfo.newName += "`" + arity; foreach (var nestedType in nested.NestedTypes) fixClsTypeNames(nested, nestedType); }
public TypeInfo(TypeInfo other, GenericInstanceType git) { this.typeReference = TypeReferenceInstance.make(other.typeReference, git); this.typeDef = other.typeDef; }
public EventDef(EventDefinition eventDefinition, TypeDef owner, int index) : base(eventDefinition, owner, index) { }