string getSuggestedPropertyName(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
if (method.Property == null)
continue;
var info = memberInfos.prop(method.Property);
if (info.suggestedName != null)
return info.suggestedName;
}
return null;
}
// Returns property type, or null if not all methods have the same type
TypeReference getPropertyType(MethodNameScope scope)
{
var methodType = getPropertyMethodType(scope.Methods[0]);
if (methodType == PropertyMethodType.Other)
return null;
TypeReference type = null;
foreach (var propMethod in scope.Methods) {
TypeReference propType;
if (methodType == PropertyMethodType.Setter)
propType = propMethod.ParamDefs[propMethod.ParamDefs.Count - 1].ParameterDefinition.ParameterType;
else
propType = propMethod.MethodDefinition.MethodReturnType.ReturnType;
if (type == null)
type = propType;
else if (!MemberReferenceHelper.compareTypes(type, propType))
return null;
}
return type;
}
string getSuggestedMethodName(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
var info = memberInfos.method(method);
if (info.suggestedName != null)
return info.suggestedName;
}
return null;
}
string prepareRenameProperty(MethodNameScope scope, bool renameOverrides, out string overridePrefix)
{
var propMethod = getPropertyMethod(scope);
if (propMethod == null)
throw new ApplicationException("No properties found");
overridePrefix = getOverridePrefix(scope, propMethod);
if (renameOverrides && overridePrefix == "")
return null;
if (!renameOverrides && overridePrefix != "")
return null;
string newPropName, oldPropName;
var propDef = propMethod.Property;
var propInfo = memberInfos.prop(propDef);
if (overridePrefix == "")
oldPropName = propInfo.oldName;
else {
var overriddenPropDef = getOverriddenProperty(propMethod);
if (overriddenPropDef == null)
oldPropName = getRealName(propInfo.oldName);
else
oldPropName = getRealName(memberInfos.prop(overriddenPropDef).newName);
}
if (propInfo.renamed)
newPropName = getRealName(propInfo.newName);
else if (propDef.Owner.Module.ObfuscatedFile.NameChecker.isValidPropertyName(oldPropName))
newPropName = oldPropName;
else {
var propPrefix = getSuggestedPropertyName(scope) ?? getNewPropertyNamePrefix(scope);
mergeStateHelper.merge(MergeStateFlags.Properties, scope);
newPropName = getAvailableName(propPrefix, scope, (scope2, newName) => isPropertyAvailable(scope2, newName));
}
var newPropNameWithPrefix = overridePrefix + newPropName;
foreach (var method in scope.Methods) {
if (method.Property != null) {
memberInfos.prop(method.Property).rename(newPropNameWithPrefix);
var ownerInfo = memberInfos.type(method.Owner);
ownerInfo.variableNameState.addPropertyName(newPropName);
ownerInfo.variableNameState.addPropertyName(newPropNameWithPrefix);
}
}
return newPropName;
}
public MethodNameScope get(MethodDef method)
{
if (!method.isVirtual())
throw new ApplicationException("Not a virtual method");
MethodNameScope scope;
if (!methodScopes.TryGetValue(method, out scope)) {
methodScopes[method] = scope = new MethodNameScope();
scope.add(method);
}
return scope;
}
bool isPropertyAvailable(MethodNameScope scope, string methodName)
{
foreach (var method in scope.Methods) {
if (memberInfos.type(method.Owner).variableNameState.isPropertyNameUsed(methodName))
return false;
}
return true;
}
string prepareRenameEvent(MethodNameScope scope, bool renameOverrides, out string overridePrefix, out string methodPrefix)
{
var eventMethod = getEventMethod(scope);
if (eventMethod == null)
throw new ApplicationException("No events found");
var eventDef = eventMethod.Event;
if (eventMethod == eventDef.AddMethod)
methodPrefix = "add_";
else if (eventMethod == eventDef.RemoveMethod)
methodPrefix = "remove_";
else if (eventMethod == eventDef.RaiseMethod)
methodPrefix = "raise_";
else
methodPrefix = null;
overridePrefix = getOverridePrefix(scope, eventMethod);
if (renameOverrides && overridePrefix == "")
return null;
if (!renameOverrides && overridePrefix != "")
return null;
string newEventName, oldEventName;
var eventInfo = memberInfos.evt(eventDef);
if (overridePrefix == "")
oldEventName = eventInfo.oldName;
else {
var overriddenEventDef = getOverriddenEvent(eventMethod);
if (overriddenEventDef == null)
oldEventName = getRealName(eventInfo.oldName);
else
oldEventName = getRealName(memberInfos.evt(overriddenEventDef).newName);
}
if (eventInfo.renamed)
newEventName = getRealName(eventInfo.newName);
else if (eventDef.Owner.Module.ObfuscatedFile.NameChecker.isValidEventName(oldEventName))
newEventName = oldEventName;
else {
mergeStateHelper.merge(MergeStateFlags.Events, scope);
newEventName = getAvailableName("Event_", scope, (scope2, newName) => isEventAvailable(scope2, newName));
}
var newEventNameWithPrefix = overridePrefix + newEventName;
foreach (var method in scope.Methods) {
if (method.Event != null) {
memberInfos.evt(method.Event).rename(newEventNameWithPrefix);
var ownerInfo = memberInfos.type(method.Owner);
ownerInfo.variableNameState.addEventName(newEventName);
ownerInfo.variableNameState.addEventName(newEventNameWithPrefix);
}
}
return newEventName;
}
static string getAvailableName(string prefix, MethodNameScope scope, Func<MethodNameScope, string, bool> checkAvailable)
{
for (int i = 0; ; i++) {
string newName = prefix + i;
if (checkAvailable(scope, newName))
return newName;
}
}
static string getOverridePrefix(MethodNameScope scope, MethodDef method)
{
if (method == null || method.MethodDefinition.Overrides.Count == 0)
return "";
if (scope.Methods.Count > 1) {
// Don't use an override prefix if the scope has an iface method.
foreach (var m in scope.Methods) {
if (m.Owner.TypeDefinition.IsInterface)
return "";
}
}
var overrideMethod = method.MethodDefinition.Overrides[0];
var name = overrideMethod.DeclaringType.FullName.Replace('/', '.');
name = removeGenericsArityRegex.Replace(name, "");
return name + ".";
}
public void merge(MergeStateFlags flags, MethodNameScope scope)
{
this.flags = flags;
visited.Clear();
foreach (var method in scope.Methods)
merge(method.Owner);
}
public void add(MethodNameScope scope)
{
scopes.Add(scope);
}
void restoreVirtualProperties(MethodNameScope scope)
{
if (scope.Methods.Count <= 1 || !scope.hasProperty())
return;
PropertyDef prop = null;
List<MethodDef> missingProps = null;
foreach (var method in scope.Methods) {
if (method.Property == null) {
if (missingProps == null)
missingProps = new List<MethodDef>();
missingProps.Add(method);
}
else if (prop == null)
prop = method.Property;
}
if (prop == null)
return; // Should never happen
if (missingProps == null)
return;
foreach (var method in missingProps) {
if (!method.Owner.HasModule)
continue;
if (method.MethodDefinition.MethodReturnType.ReturnType.FullName == "System.Void")
createPropertySetter(prop.PropertyDefinition.Name, method);
else
createPropertyGetter(prop.PropertyDefinition.Name, method);
}
}
void restoreVirtualEvents(MethodNameScope scope)
{
if (scope.Methods.Count <= 1 || !scope.hasEvent())
return;
EventMethodType methodType = EventMethodType.None;
EventDef evt = null;
List<MethodDef> missingEvents = null;
foreach (var method in scope.Methods) {
if (method.Event == null) {
if (missingEvents == null)
missingEvents = new List<MethodDef>();
missingEvents.Add(method);
}
else if (evt == null) {
evt = method.Event;
if (evt.AddMethod == method)
methodType = EventMethodType.Adder;
else if (evt.RemoveMethod == method)
methodType = EventMethodType.Remover;
else if (evt.RaiseMethod == method)
methodType = EventMethodType.Raiser;
else
methodType = EventMethodType.Other;
}
}
if (evt == null)
return; // Should never happen
if (missingEvents == null)
return;
foreach (var method in missingEvents) {
if (!method.Owner.HasModule)
continue;
switch (methodType) {
case EventMethodType.Adder:
createEventAdder(evt.EventDefinition.Name, method);
break;
case EventMethodType.Remover:
createEventRemover(evt.EventDefinition.Name, method);
break;
}
}
}
void merge(MethodNameScope a, MethodNameScope b)
{
if (a == b)
return;
if (a.Count < b.Count) {
MethodNameScope tmp = a;
a = b;
b = tmp;
}
a.merge(b);
foreach (var methodDef in b.Methods)
methodScopes[methodDef] = a;
}
bool hasDelegateOwner(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
if (isDelegateClass.check(method.Owner))
return true;
}
return false;
}
MethodDef getEventMethod(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
if (method.Event != null)
return method;
}
return null;
}
bool hasInvalidMethodName(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
var typeInfo = memberInfos.type(method.Owner);
var methodInfo = memberInfos.method(method);
if (!typeInfo.NameChecker.isValidMethodName(methodInfo.oldName))
return true;
}
return false;
}
string getNewPropertyNamePrefix(MethodNameScope scope)
{
const string defaultVal = "Prop_";
var propType = getPropertyType(scope);
if (propType == null || propType is GenericInstanceType)
return defaultVal;
string name = propType.Name;
int i;
if ((i = name.IndexOf('`')) >= 0)
name = name.Substring(0, i);
if ((i = name.LastIndexOf('.')) >= 0)
name = name.Substring(i + 1);
if (name == "")
return defaultVal;
return name + "_";
}
void prepareRenameEvent(MethodNameScope scope, bool renameOverrides)
{
string methodPrefix, overridePrefix;
var eventName = prepareRenameEvent(scope, renameOverrides, out overridePrefix, out methodPrefix);
if (eventName == null)
return;
var methodName = overridePrefix + methodPrefix + eventName;
foreach (var method in scope.Methods)
memberInfos.method(method).rename(methodName);
}
MethodDef getOverrideMethod(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
if (method.MethodDefinition.Overrides.Count > 0)
return method;
}
return null;
}
void prepareRenameProperty(MethodNameScope scope, bool renameOverrides)
{
string overridePrefix;
var propName = prepareRenameProperty(scope, renameOverrides, out overridePrefix);
if (propName == null)
return;
string methodPrefix;
switch (getPropertyMethodType(scope.Methods[0])) {
case PropertyMethodType.Getter:
methodPrefix = "get_";
break;
case PropertyMethodType.Setter:
methodPrefix = "set_";
break;
default:
throw new ApplicationException("Invalid property type");
}
var methodName = overridePrefix + methodPrefix + propName;
foreach (var method in scope.Methods)
memberInfos.method(method).rename(methodName);
}
MethodDef getPropertyMethod(MethodNameScope scope)
{
foreach (var method in scope.Methods) {
if (method.Property != null)
return method;
}
return null;
}
void prepareRenameVirtualMethods(MethodNameScope scope, string namePrefix, bool renameOverrides)
{
if (!hasInvalidMethodName(scope))
return;
if (hasDelegateOwner(scope)) {
switch (scope.Methods[0].MethodDefinition.Name) {
case "Invoke":
case "BeginInvoke":
case "EndInvoke":
return;
}
}
var overrideMethod = getOverrideMethod(scope);
var overridePrefix = getOverridePrefix(scope, overrideMethod);
if (renameOverrides && overridePrefix == "")
return;
if (!renameOverrides && overridePrefix != "")
return;
string newMethodName;
if (overridePrefix != "") {
var overrideInfo = memberInfos.method(overrideMethod);
var overriddenMethod = getOverriddenMethod(overrideMethod);
if (overriddenMethod == null)
newMethodName = getRealName(overrideMethod.MethodDefinition.Overrides[0].Name);
else
newMethodName = getRealName(memberInfos.method(overriddenMethod).newName);
}
else {
newMethodName = getSuggestedMethodName(scope);
if (newMethodName == null) {
mergeStateHelper.merge(MergeStateFlags.Methods, scope);
newMethodName = getAvailableName(namePrefix, scope, (scope2, newName) => isMethodAvailable(scope2, newName));
}
}
var newMethodNameWithPrefix = overridePrefix + newMethodName;
foreach (var method in scope.Methods)
memberInfos.type(method.Owner).renameMethod(method, newMethodNameWithPrefix);
}
public void merge(MethodNameScope other)
{
if (this == other)
return;
methods.AddRange(other.methods);
}
