private void UpdateFields(SimpleTypeLookup <MemberAction <FieldDefinition> > fieldActions)
{
foreach (var fieldAction in fieldActions[typeof(ModifiesMemberAttribute), typeof(NewMemberAttribute)])
{
ModifyField(fieldAction.ActionAttribute, fieldAction.YourMember, fieldAction.TargetMember);
}
}
private void UpdateMethodDeclerations(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions)
{
foreach (var methodAction in methodActions[typeof(NewMemberAttribute)])
{
ModifyMethodDecleration(methodAction.YourMember, methodAction.TargetMember);
}
}
private void UpdateEvents(SimpleTypeLookup <MemberAction <EventDefinition> > eventActions)
{
foreach (var eventAction in eventActions[typeof(ModifiesMemberAttribute), typeof(NewMemberAttribute)])
{
ModifyEvent(eventAction.ActionAttribute, eventAction.YourMember, eventAction.TargetMember);
}
}
private void UpdateTypes(SimpleTypeLookup <TypeAction> typeActions)
{
foreach (var modType in typeActions[typeof(NewTypeAttribute)])
{
ModifyTypeDecleration(modType.YourType);
}
}
public static SimpleTypeLookup <T> ToSimpleTypeLookup <T>(this IEnumerable <IGrouping <Type, T> > groupings)
{
var lookup = new SimpleTypeLookup <T>();
lookup.AddRange(groupings);
return(lookup);
}
private void UpdateProperties(SimpleTypeLookup <MemberAction <PropertyDefinition> > propActions)
{
foreach (var propAction in propActions[typeof(ModifiesMemberAttribute), typeof(NewMemberAttribute)])
{
ModifyProperty(propAction.ActionAttribute, propAction.YourMember, propAction.TargetMember);
}
}
private void ClearReplacedTypes(SimpleTypeLookup <TypeAction> typeActions)
{
foreach (var pairing in typeActions[typeof(ReplaceTypeAttribute)])
{
Log.Information("Clearing fields in {0:l}", pairing.TargetType.UserFriendlyName());
pairing.TargetType.Fields.Clear();
}
}
private void SpecializeTypes(SimpleTypeLookup <TypeAction> lookup, AssemblyDefinition toTargetAssembly)
{
foreach (var item in lookup[typeof(ModifiesTypeAttribute), typeof(ReplaceTypeAttribute)])
{
var name = item.YourType.GetPatchedTypeFullName();
item.TargetType = toTargetAssembly.MainModule.GetType(name);
}
}
private void UpdateMethods(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions)
{
foreach (var methodAction in methodActions[typeof(ModifiesMemberAttribute), typeof(NewMemberAttribute)])
{
ModifyMethod(methodAction.TypeAction.TargetType,
methodAction.YourMember,
methodAction.ActionAttribute, methodAction.TargetMember);
}
}
private void RemoveFields(SimpleTypeLookup <MemberAction <FieldDefinition> > fieldActions)
{
foreach (var fieldAction in fieldActions[typeof(RemoveThisMemberAttribute)])
{
var removed =
fieldAction.TypeAction.TargetType.Fields.RemoveWhere(x => x.Name == fieldAction.YourMember.Name);
if (!removed)
{
LogFailedToRemove("field", fieldAction.YourMember);
}
}
}
private void RemoveProperties(SimpleTypeLookup <MemberAction <PropertyDefinition> > propActions)
{
foreach (var propAction in propActions[typeof(RemoveThisMemberAttribute)])
{
var prop = propAction.TypeAction.TargetType.GetPropertyLike(propAction.YourMember);
var removed = propAction.TypeAction.TargetType.Properties.Remove(prop);
if (!removed)
{
LogFailedToRemove("property", propAction.YourMember);
}
}
}
private void IntroduceMethods(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions)
{
foreach (var methodAction in methodActions[typeof(NewMemberAttribute)])
{
var newMethod = CreateNewMethod(methodAction);
if (newMethod == null)
{
methodActions.Remove(methodAction);
continue;
}
}
}
private void LogTasks <T>(SimpleTypeLookup <T> memberActions, string format)
{
Log.Information(format + " {@Tasks}",
new {
ByTask = new {
CreateAndModify = memberActions[typeof(NewMemberAttribute)].Count(),
Remove = memberActions[typeof(RemoveThisMemberAttribute)].Count(),
Modify = memberActions[typeof(ModifiesMemberAttribute)].Count()
},
Total = memberActions.Count
});
}
private void RemoveMethods(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions)
{
foreach (var actionParams in methodActions[typeof(RemoveThisMemberAttribute)])
{
var method = actionParams.TypeAction.TargetType.GetMethodLike(actionParams.YourMember);
var result = actionParams.TypeAction.TargetType.Methods.Remove(method);
if (!result)
{
LogFailedToRemove("method", actionParams.YourMember);
}
}
}
private void RemoveEvents(SimpleTypeLookup <MemberAction <EventDefinition> > eventActions)
{
foreach (var eventAction in eventActions[typeof(RemoveThisMemberAttribute)])
{
var removed =
eventAction.TypeAction.TargetType.Events.RemoveWhere(x => x.Name == eventAction.YourMember.Name);
if (!removed)
{
LogFailedToRemove("event", eventAction.YourMember);
}
}
}
private void IntroduceProperties(SimpleTypeLookup <MemberAction <PropertyDefinition> > propActions)
{
foreach (var propAction in propActions[typeof(NewMemberAttribute)])
{
var newProperty = CreateNewProperty(propAction.TypeAction.TargetType, propAction.YourMember, (NewMemberAttribute)propAction.ActionAttribute);
if (newProperty == null)
{
propActions.Remove(propAction);
continue;
}
propAction.TargetMember = newProperty;
}
}
private void IntroduceTypes(SimpleTypeLookup <TypeAction> typeActions)
{
foreach (var newTypeAction in typeActions[typeof(NewTypeAttribute)])
{
var newType = CreateNewType(newTypeAction.YourType, (NewTypeAttribute)newTypeAction.ActionAttribute);
if (newType == null)
{
typeActions.Remove(newTypeAction);
continue;
}
newTypeAction.TargetType = newType;
}
}
private void IntroduceEvents(SimpleTypeLookup <MemberAction <EventDefinition> > eventActions)
{
foreach (var eventAction in eventActions[typeof(NewMemberAttribute)])
{
var newEvent = CreateNewEvent(eventAction.TypeAction.TargetType, eventAction.YourMember, (NewMemberAttribute)eventAction.ActionAttribute);
if (newEvent == null)
{
eventActions.Remove(eventAction);
continue;
}
eventAction.TargetMember = newEvent;
}
}
private void UpdateMethods(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions)
{
//The reason to fill bodies of the new methods before modifying existing ones is to ensure that DuplicatesBody attribute
//works on unmodified version (see https://github.com/GregRos/Patchwork/issues/8 for details).
foreach (var methodAction in methodActions[typeof(NewMemberAttribute)])
{
ModifyMethod(methodAction.TypeAction.TargetType, methodAction.YourMember, methodAction.ActionAttribute, methodAction.TargetMember);
}
foreach (var methodAction in methodActions[typeof(ModifiesMemberAttribute)])
{
ModifyMethod(methodAction.TypeAction.TargetType, methodAction.YourMember, methodAction.ActionAttribute, methodAction.TargetMember);
}
}
private void SpecializeMembers <T>(SimpleTypeLookup <MemberAction <T> > lookup, AssemblyDefinition toTargetAssembly)
where T : MemberReference, IMemberDefinition
{
foreach (var item in lookup[typeof(ModifiesMemberAttribute), typeof(MemberAliasAttribute)])
{
item.TargetMember = GetPatchedMember(item.TypeAction.TargetType, item.YourMember, item.ActionAttribute);
if (item.TargetMember == null)
{
var memberName = GetPatchedMemberName(item.YourMember, item.ActionAttribute);
throw Errors.Missing_member_in_attribute(DisplayNameHelper.CommonNameForMemberDef <T>(), item.YourMember, memberName);
}
}
}
private void IntroduceFields(SimpleTypeLookup <MemberAction <FieldDefinition> > fieldActions)
{
Log.Header("Creating new fields");
foreach (var fieldAction in fieldActions[typeof(NewMemberAttribute)])
{
var newField = CreateNewField(fieldAction.TypeAction.TargetType,
fieldAction.YourMember,
(NewMemberAttribute)fieldAction.ActionAttribute);
if (newField == null)
{
fieldActions.Remove(fieldAction);
continue;
}
fieldAction.TargetMember = newField;
}
}
private SimpleTypeLookup <MemberAction <T> > OrganizeMembers <T>(SimpleTypeLookup <TypeAction> organizedTypes,
Func <TypeDefinition, IEnumerable <T> > getMembers, Func <MemberReference, bool> filter) where T : MemberReference, IMemberDefinition
{
var memberSeq =
from pair in organizedTypes.SelectMany(x => x)
from yourMember in getMembers(pair.YourType)
where !yourMember.HasCustomAttribute <DisablePatchingAttribute>()
where filter(yourMember)
let actionAttr = GetMemberActionAttribute(yourMember, pair.ActionAttribute)
where actionAttr != null
group new MemberAction <T>()
{
YourMember = yourMember,
ActionAttribute = actionAttr,
TypeAction = pair,
} by actionAttr.GetType();
return(memberSeq.ToSimpleTypeLookup());
}
private void ImplicitlyAddNewMethods <T>(SimpleTypeLookup <MemberAction <MethodDefinition> > methodActions,
MemberAction <T> rootMemberAction,
Func <T, IEnumerable <MethodDefinition> > getMethods) where T : IMemberDefinition
{
var newMethods = getMethods(rootMemberAction.YourMember);
var allMethods = new HashSet <MethodDefinition>(methodActions.SelectMany(x => x).Select(x => x.YourMember));
foreach (var method in newMethods)
{
if (allMethods.Contains(method))
{
continue;
}
methodActions.GetGroupExplicitly(typeof(NewMemberAttribute)).Values.Add(new MemberAction <MethodDefinition>()
{
YourMember = method,
ActionAttribute = new NewMemberAttribute(true),
TypeAction = rootMemberAction.TypeAction,
TargetMember = null
});
}
}
private static IEnumerable <KeyValuePair <T, MemberAction <T> > > ToMappingDictionary <T>(SimpleTypeLookup <MemberAction <T> > lookup)
where T : IMemberDefinition
{
return(from action in lookup[typeof(NewMemberAttribute), typeof(ModifiesMemberAttribute), typeof(MemberAliasAttribute)]
select new KeyValuePair <T, MemberAction <T> >(action.YourMember, action));
}
