// Returns the previous method, or null if none
        public MethodDef addMethod(MethodDef ifaceMethod, MethodDef classMethod)
        {
            if (!ifaceMethodToClassMethod.ContainsKey(ifaceMethod))
                throw new ApplicationException("Could not find interface method");

            MethodDef oldMethod;
            ifaceMethodToClassMethod.TryGetValue(ifaceMethod, out oldMethod);
            ifaceMethodToClassMethod[ifaceMethod] = classMethod;
            return oldMethod;
        }

		public MMethodDef(MethodDef methodDef, MTypeDef owner, int index)
			: base(methodDef, owner, index) {
			genericParams = MGenericParamDef.CreateGenericParamDefList(MethodDef.GenericParameters);
			visibleBaseIndex = methodDef.MethodSig != null && methodDef.MethodSig.HasThis ? 1 : 0;
			for (int i = 0; i < methodDef.Parameters.Count; i++) {
				var param = methodDef.Parameters[i];
				if (param.IsNormalMethodParameter)
					visibleParamCount++;
				paramDefs.Add(new MParamDef(param, i));
			}
			returnParamDef = new MParamDef(methodDef.Parameters.ReturnParameter, -1);
		}

        EventDef getOverriddenEvent(MethodDef overrideMethod, out MethodDef overriddenMethod)
        {
            var theMethod = overrideMethod.MethodDefinition.Overrides[0];
            overriddenMethod = modules.resolve(theMethod);
            if (overriddenMethod != null)
                return overriddenMethod.Event;

            var extType = theMethod.DeclaringType;
            if (extType == null)
                return null;
            var extTypeDef = modules.resolveOther(extType);
            if (extTypeDef == null)
                return null;
            overriddenMethod = extTypeDef.find(theMethod);
            if (overriddenMethod != null)
                return overriddenMethod.Event;

            return null;
        }

 public void same(MethodDef a, MethodDef b)
 {
     merge(get(a), get(b));
 }

 public void add(MethodDef methodDef)
 {
     get(methodDef);
 }

 public MethodInst(MethodDef origMethodDef, MethodReference methodReference)
 {
     this.origMethodDef = origMethodDef;
     this.methodReference = methodReference;
 }

		static PropertySig CreatePropertySig(MethodDef method, TypeSig propType, bool isGetter) {
			if (method == null)
				return null;
			var sig = method.MethodSig;
			if (sig == null)
				return null;

			var newSig = new PropertySig(sig.HasThis, propType);
			newSig.GenParamCount = sig.GenParamCount;

			int count = sig.Params.Count;
			if (!isGetter)
				count--;
			for (int i = 0; i < count; i++)
				newSig.Params.Add(sig.Params[i]);

			return newSig;
		}

        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;
                }
            }
        }

 bool canRenameMethod(MethodDef methodDef)
 {
     var methodInfo = method(methodDef);
     if (methodDef.isStatic()) {
         if (methodInfo.oldName == ".cctor")
             return false;
     }
     else if (methodDef.isVirtual()) {
         if (DotNetUtils.derivesFromDelegate(type.TypeDefinition)) {
             switch (methodInfo.oldName) {
             case "BeginInvoke":
             case "EndInvoke":
             case "Invoke":
                 return false;
             }
         }
     }
     else {
         if (methodInfo.oldName == ".ctor")
             return false;
     }
     return true;
 }

 static bool isEventHandler(MethodDef methodDef)
 {
     if (methodDef.MethodDefinition.Parameters.Count != 2)
         return false;
     if (methodDef.MethodDefinition.MethodReturnType.ReturnType.FullName != "System.Void")
         return false;
     if (methodDef.MethodDefinition.Parameters[0].ParameterType.FullName != "System.Object")
         return false;
     if (!methodDef.MethodDefinition.Parameters[1].ParameterType.FullName.Contains("EventArgs"))
         return false;
     return true;
 }

 public void renameMethod(MethodDef methodDef, string methodName)
 {
     if (!canRenameMethod(methodDef))
         return;
     var methodInfo = method(methodDef);
     variableNameState.addMethodName(methodName);
     methodInfo.rename(methodName);
 }

 public MethodInfo method(MethodDef method)
 {
     return memberInfos.method(method);
 }

        PropertyDef getOverriddenProperty(MethodDef overrideMethod)
        {
            var theMethod = overrideMethod.MethodDefinition.Overrides[0];
            var overriddenMethod = modules.resolve(theMethod);
            if (overriddenMethod != null)
                return overriddenMethod.Property;

            var extType = theMethod.DeclaringType;
            if (extType == null)
                return null;
            var extTypeDef = modules.resolveOther(extType);
            if (extTypeDef == null)
                return null;
            var theMethodDef = extTypeDef.find(theMethod);
            if (theMethodDef != null)
                return theMethodDef.Property;

            return null;
        }

 MethodDef getOverriddenMethod(MethodDef overrideMethod)
 {
     return modules.resolve(overrideMethod.MethodDefinition.Overrides[0]);
 }

 public MethodNameGroup get(MethodDef method)
 {
     if (!method.isVirtual())
         throw new ApplicationException("Not a virtual method");
     MethodNameGroup group;
     if (!methodGroups.TryGetValue(method, out group)) {
         methodGroups[method] = group = new MethodNameGroup();
         group.add(method);
     }
     return group;
 }

		MPropertyDef CreateProperty(MTypeDef ownerType, string name, TypeSig propType, MethodDef getter, MethodDef setter) {
			if (string.IsNullOrEmpty(name) || propType.ElementType == ElementType.Void)
				return null;
			var newSig = CreatePropertySig(getter, propType, true) ?? CreatePropertySig(setter, propType, false);
			if (newSig == null)
				return null;
			var newProp = ownerType.Module.ModuleDefMD.UpdateRowId(new PropertyDefUser(name, newSig, 0));
			newProp.GetMethod = getter;
			newProp.SetMethod = setter;
			var propDef = ownerType.FindAny(newProp);
			if (propDef != null)
				return propDef;

			propDef = ownerType.Create(newProp);
			memberInfos.Add(propDef);
			if (isVerbose)
				Logger.v("Restoring property: {0}", Utils.RemoveNewlines(newProp));
			return propDef;
		}

 string getPinvokeName(MethodDef methodDef)
 {
     var entryPoint = methodDef.MethodDefinition.PInvokeInfo.EntryPoint;
     if (Regex.IsMatch(entryPoint, @"^#\d+$"))
         entryPoint = DotNetUtils.getDllName(methodDef.MethodDefinition.PInvokeInfo.Module.Name) + "_" + entryPoint.Substring(1);
     return entryPoint;
 }

		public void RemoveMethodDef(MethodDef md) {
			if (!MethodDefs.Remove(md))
				throw new ApplicationException(string.Format("Could not remove MethodDef: {0}", md));
		}

        void prepareRenameMethodArgs(MethodDef methodDef)
        {
            if (methodDef.ParamDefs.Count > 0) {
                if (isEventHandler(methodDef)) {
                    ParamInfo info;

                    info = param(methodDef.ParamDefs[0]);
                    if (!info.gotNewName())
                        info.newName = "sender";

                    info = param(methodDef.ParamDefs[1]);
                    if (!info.gotNewName())
                        info.newName = "e";
                }
                else {
                    var newVariableNameState = variableNameState.cloneParamsOnly();
                    var checker = NameChecker;
                    foreach (var paramDef in methodDef.ParamDefs) {
                        var info = param(paramDef);
                        if (info.gotNewName())
                            continue;
                        if (!checker.isValidMethodArgName(info.oldName))
                            info.newName = newVariableNameState.getNewParamName(info.oldName, paramDef.ParameterDefinition);
                    }
                }
            }

            if ((methodDef.Property != null && methodDef == methodDef.Property.SetMethod) ||
                (methodDef.Event != null && (methodDef == methodDef.Event.AddMethod || methodDef == methodDef.Event.RemoveMethod))) {
                if (methodDef.ParamDefs.Count > 0) {
                    var paramDef = methodDef.ParamDefs[methodDef.ParamDefs.Count - 1];
                    param(paramDef).newName = "value";
                }
            }
        }

 public void addMethodIfEmpty(TypeInfo iface, MethodDef ifaceMethod, MethodDef classMethod)
 {
     InterfaceMethodInfo info;
     var key = new TypeReferenceKey(iface.typeReference);
     if (!interfaceMethods.TryGetValue(key, out info))
         throw new ApplicationException("Could not find interface");
     info.addMethodIfEmpty(ifaceMethod, classMethod);
 }