2321 lines
90 KiB
C#
2321 lines
90 KiB
C#
/*
|
|
Copyright (C) 2014-2019 de4dot@gmail.com
|
|
|
|
This file is part of dnSpy
|
|
|
|
dnSpy is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
dnSpy is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with dnSpy. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Linq;
|
|
using dnlib.DotNet;
|
|
using dnlib.DotNet.Emit;
|
|
using dnlib.PE;
|
|
using dnSpy.AsmEditor.Event;
|
|
using dnSpy.AsmEditor.Field;
|
|
using dnSpy.AsmEditor.Method;
|
|
using dnSpy.AsmEditor.Properties;
|
|
using dnSpy.AsmEditor.Property;
|
|
using dnSpy.AsmEditor.Types;
|
|
using dnSpy.Contracts.AsmEditor.Compiler;
|
|
using dnSpy.Decompiler.Utils;
|
|
|
|
namespace dnSpy.AsmEditor.Compiler {
|
|
[Serializable]
|
|
sealed class ModuleImporterAbortedException : Exception {
|
|
}
|
|
|
|
[Flags]
|
|
enum ModuleImporterOptions {
|
|
None = 0,
|
|
|
|
/// <summary>
|
|
/// Module and assembly attributes replace target module and assembly attributes
|
|
/// </summary>
|
|
ReplaceModuleAssemblyAttributes = 0x00000001,
|
|
|
|
/// <summary>
|
|
/// Assembly declared security attributes replace target assembly's declared security attributes
|
|
/// </summary>
|
|
ReplaceAssemblyDeclSecurities = 0x00000002,
|
|
|
|
/// <summary>
|
|
/// All exported types replace the target assembly's exported types
|
|
/// </summary>
|
|
ReplaceExportedTypes = 0x00000004,
|
|
}
|
|
|
|
sealed partial class ModuleImporter {
|
|
const string IM0001 = nameof(IM0001);
|
|
const string IM0002 = nameof(IM0002);
|
|
const string IM0003 = nameof(IM0003);
|
|
const string IM0004 = nameof(IM0004);
|
|
const string IM0005 = nameof(IM0005);
|
|
const string IM0006 = nameof(IM0006);
|
|
const string IM0007 = nameof(IM0007);
|
|
const string IM0008 = nameof(IM0008);
|
|
const string IM0009 = nameof(IM0009);
|
|
const string IM0010 = nameof(IM0010);
|
|
|
|
public CompilerDiagnostic[] Diagnostics => diagnostics.ToArray();
|
|
public NewImportedType[] NewNonNestedTypes => newNonNestedImportedTypes.ToArray();
|
|
public MergedImportedType[] MergedNonNestedTypes => nonNestedMergedImportedTypes.Where(a => !a.IsEmpty).ToArray();
|
|
public CustomAttribute[]? NewAssemblyCustomAttributes { get; private set; }
|
|
public DeclSecurity[]? NewAssemblyDeclSecurities { get; private set; }
|
|
public CustomAttribute[]? NewModuleCustomAttributes { get; private set; }
|
|
public ExportedType[]? NewExportedTypes { get; private set; }
|
|
public Version? NewAssemblyVersion { get; private set; }
|
|
public Resource[]? NewResources { get; private set; }
|
|
|
|
readonly ModuleDef targetModule;
|
|
readonly IAssemblyResolver assemblyResolver;
|
|
readonly List<CompilerDiagnostic> diagnostics;
|
|
readonly List<NewImportedType> newNonNestedImportedTypes;
|
|
readonly List<MergedImportedType> nonNestedMergedImportedTypes;
|
|
readonly HashSet<TypeDef> newStateMachineTypes;
|
|
|
|
ModuleDef sourceModule;
|
|
readonly Dictionary<TypeDef, ImportedType> oldTypeToNewType;
|
|
readonly Dictionary<ITypeDefOrRef, ImportedType> oldTypeRefToNewType;
|
|
readonly Dictionary<MethodDef, MemberInfo<MethodDef>> oldMethodToNewMethod;
|
|
readonly Dictionary<FieldDef, MemberInfo<FieldDef>> oldFieldToNewField;
|
|
readonly Dictionary<PropertyDef, MemberInfo<PropertyDef>> oldPropertyToNewProperty;
|
|
readonly Dictionary<EventDef, MemberInfo<EventDef>> oldEventToNewEvent;
|
|
readonly Dictionary<object, object> bodyDict;
|
|
readonly Dictionary<ImportedType, ExtraImportedTypeData> toExtraData;
|
|
readonly Dictionary<MethodDef, MethodDef> editedMethodsToFix;
|
|
readonly Dictionary<FieldDef, FieldDef> editedFieldsToFix;
|
|
readonly Dictionary<PropertyDef, PropertyDef> editedPropertiesToFix;
|
|
readonly Dictionary<EventDef, EventDef> editedEventsToFix;
|
|
Dictionary<TypeDef, TypeDef>? originalTypes;
|
|
readonly HashSet<MethodDef> usedMethods;
|
|
readonly HashSet<object> isStub;
|
|
ImportSigComparerOptions? importSigComparerOptions;
|
|
|
|
Dictionary<TypeDef, TypeDef> OriginalTypes {
|
|
get {
|
|
if (originalTypes is null) {
|
|
originalTypes = new Dictionary<TypeDef, TypeDef>(new TypeEqualityComparer(SigComparerOptions.DontCompareTypeScope));
|
|
foreach (var t in targetModule.GetTypes())
|
|
originalTypes[t] = t;
|
|
}
|
|
return originalTypes;
|
|
}
|
|
}
|
|
|
|
readonly struct MemberInfo<T> where T : IMemberDef {
|
|
public T TargetMember { get; }
|
|
public T EditedMember { get; }
|
|
public MemberInfo(T targetMember, T editedMember) {
|
|
TargetMember = targetMember;
|
|
EditedMember = editedMember;
|
|
}
|
|
}
|
|
|
|
readonly struct ExtraImportedTypeData {
|
|
/// <summary>
|
|
/// New type in temporary module created by the compiler
|
|
/// </summary>
|
|
public TypeDef CompiledType { get; }
|
|
public ExtraImportedTypeData(TypeDef compiledType) => CompiledType = compiledType;
|
|
}
|
|
|
|
const SigComparerOptions SIG_COMPARER_BASE_OPTIONS = SigComparerOptions.IgnoreModifiers;
|
|
const SigComparerOptions SIG_COMPARER_OPTIONS = SIG_COMPARER_BASE_OPTIONS | SigComparerOptions.TypeRefCanReferenceGlobalType | SigComparerOptions.PrivateScopeIsComparable;
|
|
|
|
public ModuleImporter(ModuleDef targetModule, IAssemblyResolver assemblyResolver) {
|
|
sourceModule = null!;
|
|
this.targetModule = targetModule ?? throw new ArgumentNullException(nameof(targetModule));
|
|
this.assemblyResolver = assemblyResolver ?? throw new ArgumentNullException(nameof(assemblyResolver));
|
|
diagnostics = new List<CompilerDiagnostic>();
|
|
newNonNestedImportedTypes = new List<NewImportedType>();
|
|
nonNestedMergedImportedTypes = new List<MergedImportedType>();
|
|
newStateMachineTypes = new HashSet<TypeDef>();
|
|
oldTypeToNewType = new Dictionary<TypeDef, ImportedType>();
|
|
oldTypeRefToNewType = new Dictionary<ITypeDefOrRef, ImportedType>(TypeEqualityComparer.Instance);
|
|
oldMethodToNewMethod = new Dictionary<MethodDef, MemberInfo<MethodDef>>();
|
|
oldFieldToNewField = new Dictionary<FieldDef, MemberInfo<FieldDef>>();
|
|
oldPropertyToNewProperty = new Dictionary<PropertyDef, MemberInfo<PropertyDef>>();
|
|
oldEventToNewEvent = new Dictionary<EventDef, MemberInfo<EventDef>>();
|
|
bodyDict = new Dictionary<object, object>();
|
|
toExtraData = new Dictionary<ImportedType, ExtraImportedTypeData>();
|
|
editedMethodsToFix = new Dictionary<MethodDef, MethodDef>();
|
|
editedFieldsToFix = new Dictionary<FieldDef, FieldDef>();
|
|
editedPropertiesToFix = new Dictionary<PropertyDef, PropertyDef>();
|
|
editedEventsToFix = new Dictionary<EventDef, EventDef>();
|
|
usedMethods = new HashSet<MethodDef>();
|
|
isStub = new HashSet<object>();
|
|
}
|
|
|
|
void AddError(string id, string msg) => diagnostics.Add(new CompilerDiagnostic(CompilerDiagnosticSeverity.Error, msg, id, null, null, null));
|
|
|
|
void AddErrorThrow(string id, string msg) {
|
|
AddError(id, msg);
|
|
throw new ModuleImporterAbortedException();
|
|
}
|
|
|
|
ModuleDefMD LoadModule(byte[] rawGeneratedModule, DebugFileResult debugFile) {
|
|
var opts = new ModuleCreationOptions();
|
|
opts.TryToLoadPdbFromDisk = false;
|
|
opts.Context = new ModuleContext(assemblyResolver, new Resolver(assemblyResolver));
|
|
|
|
switch (debugFile.Format) {
|
|
case DebugFileFormat.None:
|
|
break;
|
|
|
|
case DebugFileFormat.Pdb:
|
|
case DebugFileFormat.PortablePdb:
|
|
opts.PdbFileOrData = debugFile.RawFile;
|
|
break;
|
|
|
|
case DebugFileFormat.Embedded:
|
|
opts.TryToLoadPdbFromDisk = true;
|
|
break;
|
|
|
|
default:
|
|
Debug.Fail($"Unknown debug file format: {debugFile.Format}");
|
|
break;
|
|
}
|
|
|
|
var module = ModuleDefMD.Load(rawGeneratedModule, opts);
|
|
if (module.Assembly is null && targetModule.Assembly is AssemblyDef targetAsm) {
|
|
var asm = new AssemblyDefUser(targetAsm.Name, targetAsm.Version, targetAsm.PublicKey, targetAsm.Culture);
|
|
asm.Attributes = targetAsm.Attributes;
|
|
asm.HashAlgorithm = targetAsm.HashAlgorithm;
|
|
asm.Modules.Add(module);
|
|
}
|
|
return module;
|
|
}
|
|
|
|
static void RemoveDuplicates(List<CustomAttribute> attributes, string fullName) {
|
|
bool found = false;
|
|
for (int i = 0; i < attributes.Count; i++) {
|
|
var ca = attributes[i];
|
|
if (ca.TypeFullName != fullName)
|
|
continue;
|
|
if (!found) {
|
|
found = true;
|
|
continue;
|
|
}
|
|
attributes.RemoveAt(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
static void RemoveDuplicateSecurityPermissionAttributes(List<DeclSecurity> secAttrs) {
|
|
foreach (var declSec in secAttrs) {
|
|
if (declSec.Action != SecurityAction.RequestMinimum)
|
|
continue;
|
|
bool found = false;
|
|
var list = declSec.SecurityAttributes;
|
|
for (int i = 0; i < list.Count; i++) {
|
|
var ca = list[i];
|
|
if (ca.TypeFullName != "System.Security.Permissions.SecurityPermissionAttribute")
|
|
continue;
|
|
if (!found) {
|
|
found = true;
|
|
continue;
|
|
}
|
|
list.RemoveAt(i);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitializeTypesAndMethods() {
|
|
// Step 1: Initialize all definitions
|
|
InitializeTypesStep1(oldTypeToNewType.Values.OfType<NewImportedType>());
|
|
InitializeTypesStep1(oldTypeToNewType.Values.OfType<MergedImportedType>());
|
|
|
|
// Step 2: import the rest, which depend on defs having been initialized,
|
|
// eg. ca.Constructor could be a MethodDef
|
|
InitializeTypesStep2(oldTypeToNewType.Values.OfType<NewImportedType>());
|
|
InitializeTypesStep2(oldTypeToNewType.Values.OfType<MergedImportedType>());
|
|
|
|
InitializeTypesMethods(oldTypeToNewType.Values.OfType<NewImportedType>());
|
|
InitializeTypesMethods(oldTypeToNewType.Values.OfType<MergedImportedType>());
|
|
|
|
UpdateEditedMethods();
|
|
foreach (var kv in editedFieldsToFix) {
|
|
var importedType = (MergedImportedType)oldTypeToNewType[kv.Key.DeclaringType];
|
|
var info = oldFieldToNewField[kv.Key];
|
|
Debug.Assert(info.TargetMember.Module == targetModule);
|
|
importedType.EditedFields.Add(new EditedField(info.TargetMember, CreateFieldDefOptions(info.EditedMember, info.TargetMember)));
|
|
}
|
|
foreach (var kv in editedPropertiesToFix) {
|
|
var importedType = (MergedImportedType)oldTypeToNewType[kv.Key.DeclaringType];
|
|
var info = oldPropertyToNewProperty[kv.Key];
|
|
Debug.Assert(info.TargetMember.Module == targetModule);
|
|
importedType.EditedProperties.Add(new EditedProperty(info.TargetMember, CreatePropertyDefOptions(info.EditedMember)));
|
|
}
|
|
foreach (var kv in editedEventsToFix) {
|
|
var importedType = (MergedImportedType)oldTypeToNewType[kv.Key.DeclaringType];
|
|
var info = oldEventToNewEvent[kv.Key];
|
|
Debug.Assert(info.TargetMember.Module == targetModule);
|
|
importedType.EditedEvents.Add(new EditedEvent(info.TargetMember, CreateEventDefOptions(info.EditedMember)));
|
|
}
|
|
}
|
|
|
|
void ImportResources() {
|
|
var newResources = new List<Resource>(sourceModule.Resources.Count);
|
|
foreach (var resource in sourceModule.Resources) {
|
|
var newResource = Import(resource);
|
|
if (newResource is null)
|
|
continue;
|
|
newResources.Add(newResource);
|
|
}
|
|
|
|
//TODO: Need to rename some resources if the owner type has been renamed, this also
|
|
// requires fixing strings in method bodies.
|
|
|
|
NewResources = newResources.ToArray();
|
|
}
|
|
|
|
Resource? Import(Resource resource) {
|
|
if (resource is EmbeddedResource er)
|
|
return Import(er);
|
|
|
|
if (resource is AssemblyLinkedResource alr)
|
|
return Import(alr);
|
|
|
|
if (resource is LinkedResource lr)
|
|
return Import(lr);
|
|
|
|
Debug.Fail($"Unknown resource type: {resource?.GetType()}");
|
|
return null;
|
|
}
|
|
|
|
EmbeddedResource Import(EmbeddedResource resource) =>
|
|
new EmbeddedResource(resource.Name, resource.CreateReader().ToArray(), resource.Attributes);
|
|
|
|
AssemblyLinkedResource Import(AssemblyLinkedResource resource) =>
|
|
new AssemblyLinkedResource(resource.Name, resource.Assembly?.ToAssemblyRef(), resource.Attributes);
|
|
|
|
LinkedResource Import(LinkedResource resource) =>
|
|
new LinkedResource(resource.Name, Import(resource.File), resource.Attributes) { Hash = resource.Hash };
|
|
|
|
FileDef Import(FileDef file) {
|
|
var createdFile = targetModule.UpdateRowId(new FileDefUser(file.Name, file.Flags, file.HashValue));
|
|
ImportCustomAttributes(createdFile, file);
|
|
return createdFile;
|
|
}
|
|
|
|
void AddNewOrMergedNonNestedType(TypeDef sourceType) {
|
|
Debug.Assert(!sourceType.IsGlobalModuleType);
|
|
Debug2.Assert(sourceType.DeclaringType is null);
|
|
|
|
TypeDef? targetType;
|
|
bool merge = false;
|
|
bool hasTargetType = OriginalTypes.TryGetValue(sourceType, out targetType);
|
|
|
|
// VB embeds the used core types. Merge all of them
|
|
if (HasVBEmbeddedAttribute(sourceType))
|
|
merge |= hasTargetType && HasVBEmbeddedAttribute(targetType!);
|
|
|
|
// C# embeds some attributes if the target framework doesn't have them (Eg. IsByRefLikeAttribute, IsReadOnlyAttribute)
|
|
if (HasCodeAnalysisEmbeddedAttribute(sourceType))
|
|
merge |= hasTargetType && HasCodeAnalysisEmbeddedAttribute(targetType!);
|
|
|
|
// Merge all embedded COM types
|
|
if (TIAHelper.IsTypeDefEquivalent(sourceType) && hasTargetType)
|
|
merge |= new SigComparer().Equals(sourceType, targetType);
|
|
|
|
if (merge)
|
|
nonNestedMergedImportedTypes.Add(MergeEditedTypes(sourceType, targetType!));
|
|
else
|
|
newNonNestedImportedTypes.Add(CreateNewImportedType(sourceType, targetModule.Types));
|
|
}
|
|
|
|
static bool HasVBEmbeddedAttribute(TypeDef type) {
|
|
var ca = type.CustomAttributes.Find("Microsoft.VisualBasic.Embedded");
|
|
// The attribute should also be embedded, so make sure the ctor is a MethodDef
|
|
return ca?.Constructor is MethodDef;
|
|
}
|
|
|
|
static bool HasCodeAnalysisEmbeddedAttribute(TypeDef type) {
|
|
var ca = type.CustomAttributes.Find("Microsoft.CodeAnalysis.EmbeddedAttribute");
|
|
// The attribute should also be embedded, so make sure the ctor is a MethodDef
|
|
return ca?.Constructor is MethodDef;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imports everything into the target module. All global members are merged and possibly renamed.
|
|
/// All non-nested types are renamed if a type with the same name exists in the target module.
|
|
/// </summary>
|
|
/// <param name="rawGeneratedModule">Raw bytes of compiled assembly</param>
|
|
/// <param name="debugFile">Debug file</param>
|
|
/// <param name="options">Options</param>
|
|
public void Import(byte[] rawGeneratedModule, DebugFileResult debugFile, ModuleImporterOptions options) {
|
|
SetSourceModule(LoadModule(rawGeneratedModule, debugFile));
|
|
|
|
AddGlobalTypeMembers(sourceModule.GlobalType);
|
|
foreach (var type in sourceModule.Types) {
|
|
if (type.IsGlobalModuleType)
|
|
continue;
|
|
AddNewOrMergedNonNestedType(type);
|
|
}
|
|
InitializeTypesAndMethods();
|
|
|
|
if ((options & ModuleImporterOptions.ReplaceModuleAssemblyAttributes) != 0) {
|
|
var attributes = new List<CustomAttribute>();
|
|
ImportCustomAttributes(attributes, sourceModule);
|
|
// The compiler adds [UnverifiableCode] causing a duplicate attribute
|
|
RemoveDuplicates(attributes, "System.Security.UnverifiableCodeAttribute");
|
|
NewModuleCustomAttributes = attributes.ToArray();
|
|
var asm = sourceModule.Assembly;
|
|
if (asm is not null) {
|
|
NewAssemblyVersion = asm.Version;
|
|
attributes.Clear();
|
|
ImportCustomAttributes(attributes, asm);
|
|
NewAssemblyCustomAttributes = attributes.ToArray();
|
|
}
|
|
}
|
|
|
|
if ((options & ModuleImporterOptions.ReplaceAssemblyDeclSecurities) != 0) {
|
|
var asm = sourceModule.Assembly;
|
|
if (asm is not null) {
|
|
var declSecs = new List<DeclSecurity>();
|
|
ImportDeclSecurities(declSecs, asm);
|
|
// The C# compiler always adds this security attribute:
|
|
// SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)
|
|
RemoveDuplicateSecurityPermissionAttributes(declSecs);
|
|
NewAssemblyDeclSecurities = declSecs.ToArray();
|
|
}
|
|
}
|
|
|
|
if ((options & ModuleImporterOptions.ReplaceExportedTypes) != 0) {
|
|
var exportedTypes = new List<ExportedType>();
|
|
ImportExportedTypes(exportedTypes);
|
|
NewExportedTypes = exportedTypes.ToArray();
|
|
}
|
|
|
|
ImportResources();
|
|
SetSourceModule(null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imports all new types and methods. Members that only exist in <paramref name="targetType"/>
|
|
/// are considered deleted. Members that exist in both types are merged.
|
|
/// </summary>
|
|
/// <param name="rawGeneratedModule">Raw bytes of compiled assembly</param>
|
|
/// <param name="debugFile">Debug file</param>
|
|
/// <param name="targetType">Original type that was edited</param>
|
|
public void Import(byte[] rawGeneratedModule, DebugFileResult debugFile, TypeDef targetType) {
|
|
if (targetType.Module != targetModule)
|
|
throw new InvalidOperationException();
|
|
if (targetType.DeclaringType is not null)
|
|
throw new ArgumentException("Type must not be nested");
|
|
SetSourceModule(LoadModule(rawGeneratedModule, debugFile));
|
|
|
|
var newType = FindSourceType(targetType);
|
|
if (newType.DeclaringType is not null)
|
|
throw new ArgumentException("Type must not be nested");
|
|
RenamePropEventAccessors(newType, targetType);
|
|
|
|
if (!newType.IsGlobalModuleType)
|
|
AddGlobalTypeMembers(sourceModule.GlobalType);
|
|
foreach (var type in sourceModule.Types) {
|
|
if (type.IsGlobalModuleType)
|
|
continue;
|
|
if (type == newType)
|
|
continue;
|
|
AddNewOrMergedNonNestedType(type);
|
|
}
|
|
nonNestedMergedImportedTypes.Add(MergeEditedTypes(newType, targetType));
|
|
InitializeTypesAndMethods();
|
|
|
|
ImportResources();
|
|
SetSourceModule(null);
|
|
}
|
|
|
|
TypeDef FindSourceType(TypeDef targetType) {
|
|
var newType = sourceModule.Find(targetType.Module.Import(targetType));
|
|
if (newType is not null)
|
|
return newType;
|
|
|
|
AddErrorThrow(IM0010, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindEditedType, targetType));
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imports all new types and members. Nothing is removed.
|
|
/// </summary>
|
|
/// <param name="rawGeneratedModule">Raw bytes of compiled assembly</param>
|
|
/// <param name="debugFile">Debug file</param>
|
|
/// <param name="targetType">Original type that was edited</param>
|
|
public void ImportNewMembers(byte[] rawGeneratedModule, DebugFileResult debugFile, TypeDef targetType) {
|
|
if (targetType.Module != targetModule)
|
|
throw new InvalidOperationException();
|
|
if (targetType.DeclaringType is not null)
|
|
throw new ArgumentException("Type must not be nested");
|
|
SetSourceModule(LoadModule(rawGeneratedModule, debugFile));
|
|
|
|
var newType = FindSourceType(targetType);
|
|
if (newType.DeclaringType is not null)
|
|
throw new ArgumentException("Type must not be nested");
|
|
RenamePropEventAccessors(newType, targetType);
|
|
|
|
if (!newType.IsGlobalModuleType)
|
|
AddGlobalTypeMembers(sourceModule.GlobalType);
|
|
foreach (var type in sourceModule.Types) {
|
|
if (type.IsGlobalModuleType)
|
|
continue;
|
|
if (type == newType)
|
|
continue;
|
|
AddNewOrMergedNonNestedType(type);
|
|
}
|
|
nonNestedMergedImportedTypes.Add(AddMergedType(newType, targetType));
|
|
InitializeTypesAndMethods();
|
|
|
|
ImportResources();
|
|
SetSourceModule(null);
|
|
}
|
|
|
|
readonly struct ExistingMember<T> where T : IMemberDef {
|
|
/// <summary>Compiled member</summary>
|
|
public T CompiledMember { get; }
|
|
/// <summary>Original member that exists in the target module</summary>
|
|
public T TargetMember { get; }
|
|
public ExistingMember(T compiledMember, T targetMember) {
|
|
CompiledMember = compiledMember;
|
|
TargetMember = targetMember;
|
|
}
|
|
}
|
|
|
|
abstract class MemberDiff<T> : IEqualityComparer<T> where T : IMemberDef {
|
|
public List<T> Deleted { get; } = new List<T>();
|
|
public List<T> New { get; } = new List<T>();
|
|
public List<ExistingMember<T>> Existing { get; } = new List<ExistingMember<T>>();
|
|
|
|
public void Initialize(TypeDef newType, TypeDef targetType, MergedImportedType mergedImportedType) {
|
|
var newMembersDict = new Dictionary<T, T>(this);
|
|
var targetMembersDict = new Dictionary<T, T>(this);
|
|
foreach (var m in GetMembers(newType))
|
|
newMembersDict[m] = m;
|
|
foreach (var m in GetMembers(targetType))
|
|
targetMembersDict[m] = m;
|
|
if (newMembersDict.Count != GetMembers(newType).Count)
|
|
throw new InvalidOperationException();
|
|
if (targetMembersDict.Count != GetMembers(targetType).Count)
|
|
throw new InvalidOperationException();
|
|
|
|
foreach (var newMember in GetMembers(newType)) {
|
|
if (targetMembersDict.TryGetValue(newMember, out var targetMember))
|
|
Existing.Add(new ExistingMember<T>(newMember, targetMember));
|
|
else
|
|
New.Add(newMember);
|
|
}
|
|
|
|
Deleted.AddRange(targetMembersDict.Keys.Where(a => !newMembersDict.ContainsKey(a)));
|
|
}
|
|
protected abstract IList<T> GetMembers(TypeDef type);
|
|
public abstract bool Equals([AllowNull] T x, [AllowNull] T y);
|
|
public abstract int GetHashCode([DisallowNull] T obj);
|
|
}
|
|
|
|
sealed class FieldMemberDiff : MemberDiff<FieldDef> {
|
|
readonly ImportFieldEqualityComparer comparer;
|
|
public FieldMemberDiff(ImportSigComparerOptions importSigComparerOptions, ModuleDef targetModule) => comparer = new ImportFieldEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule));
|
|
protected override IList<FieldDef> GetMembers(TypeDef type) => type.Fields;
|
|
public override bool Equals([AllowNull] FieldDef x, [AllowNull] FieldDef y) => comparer.Equals(x, y);
|
|
public override int GetHashCode([DisallowNull] FieldDef obj) => comparer.GetHashCode(obj);
|
|
}
|
|
|
|
sealed class MethodMemberDiff : MemberDiff<MethodDef> {
|
|
readonly ImportMethodEqualityComparer comparer;
|
|
public MethodMemberDiff(ImportSigComparerOptions importSigComparerOptions, ModuleDef targetModule) => comparer = new ImportMethodEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule));
|
|
protected override IList<MethodDef> GetMembers(TypeDef type) => type.Methods;
|
|
public override bool Equals([AllowNull] MethodDef x, [AllowNull] MethodDef y) => comparer.Equals(x, y);
|
|
public override int GetHashCode([DisallowNull] MethodDef obj) => comparer.GetHashCode(obj);
|
|
}
|
|
|
|
sealed class PropertyMemberDiff : MemberDiff<PropertyDef> {
|
|
readonly ImportPropertyEqualityComparer comparer;
|
|
public PropertyMemberDiff(ImportSigComparerOptions importSigComparerOptions, ModuleDef targetModule) => comparer = new ImportPropertyEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule));
|
|
protected override IList<PropertyDef> GetMembers(TypeDef type) => type.Properties;
|
|
public override bool Equals([AllowNull] PropertyDef x, [AllowNull] PropertyDef y) => comparer.Equals(x, y);
|
|
public override int GetHashCode([DisallowNull] PropertyDef obj) => comparer.GetHashCode(obj);
|
|
}
|
|
|
|
sealed class EventMemberDiff : MemberDiff<EventDef> {
|
|
readonly ImportEventEqualityComparer comparer;
|
|
public EventMemberDiff(ImportSigComparerOptions importSigComparerOptions, ModuleDef targetModule) => comparer = new ImportEventEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule));
|
|
protected override IList<EventDef> GetMembers(TypeDef type) => type.Events;
|
|
public override bool Equals([AllowNull] EventDef x, [AllowNull] EventDef y) => comparer.Equals(x, y);
|
|
public override int GetHashCode([DisallowNull] EventDef obj) => comparer.GetHashCode(obj);
|
|
}
|
|
|
|
MergedImportedType MergeEditedTypes(TypeDef newType, TypeDef targetType) {
|
|
var mergedImportedType = AddMergedImportedType(newType, targetType, MergeKind.Edit);
|
|
|
|
InitializeNewStateMachineTypes(newType);
|
|
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var fieldDiff = new FieldMemberDiff(importSigComparerOptions, targetModule);
|
|
fieldDiff.Initialize(newType, targetType, mergedImportedType);
|
|
var methodDiff = new MethodMemberDiff(importSigComparerOptions, targetModule);
|
|
methodDiff.Initialize(newType, targetType, mergedImportedType);
|
|
var propertyDiff = new PropertyMemberDiff(importSigComparerOptions, targetModule);
|
|
propertyDiff.Initialize(newType, targetType, mergedImportedType);
|
|
var eventDiff = new EventMemberDiff(importSigComparerOptions, targetModule);
|
|
eventDiff.Initialize(newType, targetType, mergedImportedType);
|
|
|
|
mergedImportedType.DeletedFields.AddRange(fieldDiff.Deleted);
|
|
mergedImportedType.DeletedMethods.AddRange(methodDiff.Deleted);
|
|
mergedImportedType.DeletedProperties.AddRange(propertyDiff.Deleted);
|
|
mergedImportedType.DeletedEvents.AddRange(eventDiff.Deleted);
|
|
|
|
foreach (var info in fieldDiff.Existing)
|
|
editedFieldsToFix.Add(info.CompiledMember, info.TargetMember);
|
|
foreach (var info in methodDiff.Existing)
|
|
editedMethodsToFix.Add(info.CompiledMember, info.TargetMember);
|
|
foreach (var info in propertyDiff.Existing)
|
|
editedPropertiesToFix.Add(info.CompiledMember, info.TargetMember);
|
|
foreach (var info in eventDiff.Existing)
|
|
editedEventsToFix.Add(info.CompiledMember, info.TargetMember);
|
|
|
|
var typeComparer = new TypeEqualityComparer(SigComparerOptions.DontCompareTypeScope);
|
|
var newNestedTypesDict = new Dictionary<TypeDef, TypeDef>(typeComparer);
|
|
var targetTypesDict = new Dictionary<TypeDef, TypeDef>(typeComparer);
|
|
foreach (var t in newType.NestedTypes)
|
|
newNestedTypesDict[t] = t;
|
|
foreach (var t in targetType.NestedTypes)
|
|
targetTypesDict[t] = t;
|
|
if (newNestedTypesDict.Count != newType.NestedTypes.Count)
|
|
throw new InvalidOperationException();
|
|
if (targetTypesDict.Count != targetType.NestedTypes.Count)
|
|
throw new InvalidOperationException();
|
|
|
|
var existingTypes = new List<ExistingMember<TypeDef>>();
|
|
var newNestedTypes = new List<TypeDef>();
|
|
var stateMachineTypes = new List<TypeDef>();
|
|
|
|
foreach (var nestedType in newType.NestedTypes) {
|
|
bool canAdd = true;
|
|
|
|
// If it's a state machine type, always create a new one.
|
|
if (newStateMachineTypes.Contains(nestedType)) {
|
|
stateMachineTypes.Add(nestedType);
|
|
canAdd = false;
|
|
}
|
|
|
|
if (targetTypesDict.TryGetValue(nestedType, out var targetNestedType)) {
|
|
existingTypes.Add(new ExistingMember<TypeDef>(nestedType, targetNestedType));
|
|
canAdd = false;
|
|
}
|
|
|
|
if (canAdd)
|
|
newNestedTypes.Add(nestedType);
|
|
}
|
|
|
|
mergedImportedType.DeletedNestedTypes.AddRange(targetTypesDict.Keys.Where(a => !newNestedTypesDict.ContainsKey(a)));
|
|
|
|
var usedTypeNames = new UsedTypeNames();
|
|
foreach (var existing in existingTypes) {
|
|
usedTypeNames.Add(existing.CompiledMember);
|
|
if (!newStateMachineTypes.Contains(existing.CompiledMember))
|
|
mergedImportedType.NewOrExistingNestedTypes.Add(MergeEditedTypes(existing.CompiledMember, existing.TargetMember));
|
|
}
|
|
|
|
foreach (var newNestedType in newNestedTypes)
|
|
mergedImportedType.NewOrExistingNestedTypes.Add(CreateNewImportedType(newNestedType, usedTypeNames));
|
|
foreach (var smType in stateMachineTypes)
|
|
mergedImportedType.NewOrExistingNestedTypes.Add(CreateNewImportedType(smType, usedTypeNames));
|
|
|
|
return mergedImportedType;
|
|
}
|
|
|
|
void InitializeNewStateMachineTypes(TypeDef compiledType) {
|
|
foreach (var method in compiledType.Methods) {
|
|
var smType = StateMachineHelpers.GetStateMachineType(method);
|
|
if (smType is not null) {
|
|
Debug.Assert(!newStateMachineTypes.Contains(smType), "Two or more methods share the same state machine type");
|
|
newStateMachineTypes.Add(smType);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imports all new types and methods (compiler generated or created by the user). All new types and members
|
|
/// in the global type are added to the target's global type. All duplicates are renamed.
|
|
/// All removed classes and members in the edited method's type or it's declaring type etc are kept. All
|
|
/// new types and members are added to the target module. Nothing needs to be renamed because a member that
|
|
/// exists in both modules is assumed to be the original member stub.
|
|
/// All the instructions in the edited method are imported, and its impl attributes. Nothing else is imported.
|
|
/// </summary>
|
|
/// <param name="rawGeneratedModule">Raw bytes of compiled assembly</param>
|
|
/// <param name="debugFile">Debug file</param>
|
|
/// <param name="targetMethod">Original method that was edited</param>
|
|
public void Import(byte[] rawGeneratedModule, DebugFileResult debugFile, MethodDef targetMethod) {
|
|
if (targetMethod.Module != targetModule)
|
|
throw new InvalidOperationException();
|
|
SetSourceModule(LoadModule(rawGeneratedModule, debugFile));
|
|
|
|
var newMethod = FindSourceMethod(targetMethod);
|
|
var newMethodNonNestedDeclType = newMethod.DeclaringType;
|
|
while (newMethodNonNestedDeclType.DeclaringType is not null)
|
|
newMethodNonNestedDeclType = newMethodNonNestedDeclType.DeclaringType;
|
|
RenamePropEventAccessors(newMethod.DeclaringType, targetMethod.DeclaringType);
|
|
|
|
AddEditedMethod(newMethod, targetMethod);
|
|
if (!newMethodNonNestedDeclType.IsGlobalModuleType)
|
|
AddGlobalTypeMembers(sourceModule.GlobalType);
|
|
foreach (var type in sourceModule.Types) {
|
|
if (type.IsGlobalModuleType)
|
|
continue;
|
|
if (type == newMethodNonNestedDeclType)
|
|
continue;
|
|
AddNewOrMergedNonNestedType(type);
|
|
}
|
|
InitializeTypesAndMethods();
|
|
|
|
ImportResources();
|
|
SetSourceModule(null);
|
|
}
|
|
|
|
// A getter in the original module could have a different name than usual, eg. prop='Prop' but getter = 'random_name'.
|
|
// The C# compiler will call get_Prop, so rename get_Prop to the original name ('random_name')
|
|
void RenamePropEventAccessors(TypeDef newType, TypeDef targetType) {
|
|
for (;;) {
|
|
if (newType.DeclaringType is null && targetType.DeclaringType is null)
|
|
break;
|
|
newType = newType.DeclaringType ?? throw new InvalidOperationException();
|
|
targetType = targetType.DeclaringType ?? throw new InvalidOperationException();
|
|
}
|
|
|
|
var sigComparer = new ImportSigComparer(importSigComparerOptions!, SIG_COMPARER_OPTIONS | SigComparerOptions.CompareDeclaringTypes, targetModule);
|
|
var propComparer = new ImportPropertyEqualityComparer(sigComparer);
|
|
var eventComparer = new ImportEventEqualityComparer(sigComparer);
|
|
var targetProps = new Dictionary<PropertyDef, PropertyDef>(propComparer);
|
|
var targetEvents = new Dictionary<EventDef, EventDef>(eventComparer);
|
|
foreach (var t in GetTypes(targetType)) {
|
|
foreach (var p in t.Properties)
|
|
targetProps[p] = p;
|
|
foreach (var e in t.Events)
|
|
targetEvents[e] = e;
|
|
}
|
|
foreach (var t in GetTypes(newType)) {
|
|
foreach (var p in t.Properties) {
|
|
if (targetProps.TryGetValue(p, out var origProp)) {
|
|
Rename(p.GetMethod, origProp.GetMethod);
|
|
Rename(p.SetMethod, origProp.SetMethod);
|
|
}
|
|
}
|
|
foreach (var e in t.Events) {
|
|
if (targetEvents.TryGetValue(e, out var origEvent)) {
|
|
Rename(e.AddMethod, origEvent.AddMethod);
|
|
Rename(e.InvokeMethod, origEvent.InvokeMethod);
|
|
Rename(e.RemoveMethod, origEvent.RemoveMethod);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Rename(MethodDef newMethod, MethodDef targetMethod) {
|
|
if (newMethod is null || targetMethod is null)
|
|
return;
|
|
newMethod.Name = targetMethod.Name;
|
|
}
|
|
|
|
static IEnumerable<TypeDef> GetTypes(TypeDef type) {
|
|
yield return type;
|
|
foreach (var t in type.GetTypes())
|
|
yield return t;
|
|
}
|
|
|
|
static UTF8String GetMethodName(MethodDef method) {
|
|
foreach (var p in method.DeclaringType.Properties) {
|
|
if (p.GetMethod == method)
|
|
return "get_" + p.Name;
|
|
if (p.SetMethod == method)
|
|
return "set_" + p.Name;
|
|
}
|
|
foreach (var e in method.DeclaringType.Events) {
|
|
if (e.AddMethod == method)
|
|
return "add_" + e.Name;
|
|
if (e.RemoveMethod == method)
|
|
return "remove_" + e.Name;
|
|
if (e.InvokeMethod == method)
|
|
return "raise_" + e.Name;
|
|
}
|
|
return method.Name;
|
|
}
|
|
|
|
MethodDef FindSourceMethod(MethodDef targetMethod) {
|
|
var newType = sourceModule.Find(targetMethod.Module.Import(targetMethod.DeclaringType));
|
|
if (newType is null)
|
|
AddErrorThrow(IM0001, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindMethodType, targetMethod.DeclaringType));
|
|
|
|
// Don't check type scopes or we won't be able to find methods with edited nested types.
|
|
const SigComparerOptions comparerFlags = SIG_COMPARER_OPTIONS | SigComparerOptions.DontCompareTypeScope;
|
|
|
|
var newMethod = newType!.FindMethod(GetMethodName(targetMethod), targetMethod.MethodSig, comparerFlags, targetMethod.Module);
|
|
if (newMethod is not null)
|
|
return newMethod;
|
|
|
|
if (targetMethod.Overrides.Count != 0) {
|
|
var targetOverriddenMethod = targetMethod.Overrides[0].MethodDeclaration;
|
|
var comparer = new SigComparer(comparerFlags, targetModule);
|
|
foreach (var method in newType.Methods) {
|
|
foreach (var o in method.Overrides) {
|
|
if (!comparer.Equals(o.MethodDeclaration, targetOverriddenMethod))
|
|
continue;
|
|
if (!comparer.Equals(o.MethodDeclaration.DeclaringType, targetOverriddenMethod.DeclaringType))
|
|
continue;
|
|
return method;
|
|
}
|
|
}
|
|
}
|
|
|
|
AddErrorThrow(IM0002, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindEditedMethod, targetMethod));
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
void SetSourceModule(ModuleDef? newSourceModule) {
|
|
sourceModule = newSourceModule!;
|
|
importSigComparerOptions = newSourceModule is null ? null : new ImportSigComparerOptions(newSourceModule, targetModule);
|
|
}
|
|
|
|
FieldDefOptions CreateFieldDefOptions(FieldDef newField, FieldDef targetField) =>
|
|
new FieldDefOptions(newField);
|
|
|
|
PropertyDefOptions CreatePropertyDefOptions(PropertyDef newProperty) =>
|
|
new PropertyDefOptions(newProperty);
|
|
|
|
EventDefOptions CreateEventDefOptions(EventDef newEvent) =>
|
|
new EventDefOptions(newEvent);
|
|
|
|
MethodDefOptions CreateMethodDefOptions(MethodDef newMethod, MethodDef targetMethod) {
|
|
var options = new MethodDefOptions(newMethod);
|
|
options.ParamDefs.Clear();
|
|
options.ParamDefs.AddRange(newMethod.ParamDefs.Select(a => Clone(a)!));
|
|
options.GenericParameters.Clear();
|
|
options.GenericParameters.AddRange(newMethod.GenericParameters.Select(a => Clone(a)!));
|
|
return options;
|
|
}
|
|
|
|
ParamDef? Clone(ParamDef paramDef) {
|
|
if (paramDef is null)
|
|
return null;
|
|
var importedParamDef = new ParamDefUser(paramDef.Name, paramDef.Sequence, paramDef.Attributes);
|
|
importedParamDef.Rid = paramDef.Rid;
|
|
importedParamDef.CustomAttributes.AddRange(paramDef.CustomAttributes);
|
|
importedParamDef.MarshalType = paramDef.MarshalType;
|
|
importedParamDef.Constant = paramDef.Constant;
|
|
return importedParamDef;
|
|
}
|
|
|
|
GenericParam? Clone(GenericParam gp) {
|
|
if (gp is null)
|
|
return null;
|
|
var importedGenericParam = new GenericParamUser(gp.Number, gp.Flags, gp.Name);
|
|
importedGenericParam.Rid = gp.Rid;
|
|
importedGenericParam.CustomAttributes.AddRange(gp.CustomAttributes);
|
|
importedGenericParam.Kind = gp.Kind;
|
|
foreach (var gpc in gp.GenericParamConstraints)
|
|
importedGenericParam.GenericParamConstraints.Add(Clone(gpc));
|
|
return importedGenericParam;
|
|
}
|
|
|
|
GenericParamConstraint? Clone(GenericParamConstraint gpc) {
|
|
if (gpc is null)
|
|
return null;
|
|
var importedGenericParamConstraint = new GenericParamConstraintUser(gpc.Constraint);
|
|
importedGenericParamConstraint.Rid = gpc.Rid;
|
|
importedGenericParamConstraint.CustomAttributes.AddRange(gpc.CustomAttributes);
|
|
return importedGenericParamConstraint;
|
|
}
|
|
|
|
void UpdateEditedMethods() {
|
|
foreach (var kv in editedMethodsToFix) {
|
|
var newMethod = kv.Key;
|
|
var info = oldMethodToNewMethod[newMethod];
|
|
Debug.Assert(info.TargetMember.Module == targetModule);
|
|
Debug.Assert(info.TargetMember == kv.Value);
|
|
|
|
var importedType = (MergedImportedType)oldTypeToNewType[newMethod.DeclaringType];
|
|
var methodDefOptions = CreateMethodDefOptions(info.EditedMember, info.TargetMember);
|
|
importedType.EditedMethods.Add(new EditedMethod(info.TargetMember, info.EditedMember.Body, methodDefOptions));
|
|
}
|
|
}
|
|
|
|
void AddEditedMethod(MethodDef newMethod, MethodDef targetMethod) {
|
|
var newBaseType = newMethod.DeclaringType;
|
|
var targetBaseType = targetMethod.DeclaringType;
|
|
while (newBaseType.DeclaringType is not null) {
|
|
if (targetBaseType is null)
|
|
throw new InvalidOperationException();
|
|
newBaseType = newBaseType.DeclaringType;
|
|
targetBaseType = targetBaseType.DeclaringType;
|
|
}
|
|
if (targetBaseType is null || targetBaseType.DeclaringType is not null)
|
|
throw new InvalidOperationException();
|
|
|
|
var newStateMachineType = StateMachineHelpers.GetStateMachineType(newMethod);
|
|
if (newStateMachineType is not null)
|
|
newStateMachineTypes.Add(newStateMachineType);
|
|
nonNestedMergedImportedTypes.Add(AddMergedType(newBaseType, targetBaseType));
|
|
editedMethodsToFix.Add(newMethod, targetMethod);
|
|
}
|
|
|
|
MergedImportedType AddMergedType(TypeDef newType, TypeDef targetType) {
|
|
var importedType = AddMergedImportedType(newType, targetType, MergeKind.Merge);
|
|
|
|
if (newType.NestedTypes.Count != 0 || targetType.NestedTypes.Count != 0) {
|
|
var typeComparer = new TypeEqualityComparer(SigComparerOptions.DontCompareTypeScope);
|
|
var newTypes = new Dictionary<TypeDef, TypeDef>(typeComparer);
|
|
var targetTypes = new Dictionary<TypeDef, TypeDef>(typeComparer);
|
|
foreach (var t in newType.NestedTypes)
|
|
newTypes[t] = t;
|
|
foreach (var t in targetType.NestedTypes)
|
|
targetTypes[t] = t;
|
|
if (newTypes.Count != newType.NestedTypes.Count)
|
|
throw new InvalidOperationException();
|
|
if (targetTypes.Count != targetType.NestedTypes.Count)
|
|
throw new InvalidOperationException();
|
|
|
|
foreach (var nestedTargetType in targetType.NestedTypes) {
|
|
if (newTypes.TryGetValue(nestedTargetType, out var nestedNewType)) {
|
|
// If it's a state machine type, it's a new type
|
|
if (!newStateMachineTypes.Contains(nestedNewType)) {
|
|
targetTypes.Remove(nestedTargetType);
|
|
newTypes.Remove(nestedTargetType);
|
|
if (IsCompilerGenerated(nestedNewType)) {
|
|
var nestedImportedType = CreateNewImportedType(nestedNewType, targetType.NestedTypes);
|
|
importedType.NewOrExistingNestedTypes.Add(nestedImportedType);
|
|
}
|
|
else {
|
|
var nestedImportedType = AddMergedType(nestedNewType, nestedTargetType);
|
|
importedType.NewOrExistingNestedTypes.Add(nestedImportedType);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// The user removed the type, or it was a compiler generated type that
|
|
// was never shown in the decompiled code.
|
|
}
|
|
}
|
|
// Whatever's left are types created by the user or the compiler
|
|
var usedTypeNames = new UsedTypeNames(targetTypes.Keys);
|
|
foreach (var newNestedType in newTypes.Values)
|
|
importedType.NewOrExistingNestedTypes.Add(CreateNewImportedType(newNestedType, usedTypeNames));
|
|
}
|
|
|
|
return importedType;
|
|
}
|
|
|
|
static bool IsCompilerGenerated(TypeDef type) {
|
|
if (!type.CustomAttributes.IsDefined("System.Runtime.CompilerServices.CompilerGeneratedAttribute"))
|
|
return false;
|
|
var name = type.Name.String;
|
|
if (name.Length == 0 || name[0] == '<')
|
|
return true;
|
|
if (name.StartsWith("_Closure$__"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void AddGlobalTypeMembers(TypeDef newGlobalType) =>
|
|
nonNestedMergedImportedTypes.Add(MergeTypesRename(newGlobalType, targetModule.GlobalType));
|
|
|
|
// Adds every member as a new member. If a member exists in the target type, it's renamed.
|
|
// Nested types aren't merged with existing nested types, they're just renamed.
|
|
MergedImportedType MergeTypesRename(TypeDef newType, TypeDef targetType) {
|
|
var mergedImportedType = AddMergedImportedType(newType, targetType, MergeKind.Rename);
|
|
foreach (var nestedType in newType.NestedTypes) {
|
|
var nestedImportedType = CreateNewImportedType(nestedType, targetType.NestedTypes);
|
|
mergedImportedType.NewOrExistingNestedTypes.Add(nestedImportedType);
|
|
}
|
|
return mergedImportedType;
|
|
}
|
|
|
|
static bool IsVirtual(PropertyDef property) => property.GetMethod?.IsVirtual == true || property.SetMethod?.IsVirtual == true;
|
|
static bool IsVirtual(EventDef @event) => @event.AddMethod?.IsVirtual == true || @event.RemoveMethod?.IsVirtual == true || @event.InvokeMethod?.IsVirtual == true;
|
|
|
|
void RenameMergedMembers(MergedImportedType mergedType) {
|
|
if (mergedType.MergeKind != MergeKind.Rename)
|
|
throw new InvalidOperationException();
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var existingProps = new HashSet<PropertyDef>(new ImportPropertyEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS | SigComparerOptions.DontCompareReturnType, targetModule)));
|
|
var existingMethods = new HashSet<MethodDef>(new ImportMethodEqualityComparer(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS | SigComparerOptions.DontCompareReturnType, targetModule)));
|
|
var existingEventsFields = new HashSet<string>(StringComparer.Ordinal);
|
|
var suggestedNames = new Dictionary<MethodDef, string>();
|
|
|
|
foreach (var p in mergedType.TargetType!.Properties)
|
|
existingProps.Add(p);
|
|
foreach (var e in mergedType.TargetType.Events)
|
|
existingEventsFields.Add(e.Name);
|
|
foreach (var m in mergedType.TargetType.Methods)
|
|
existingMethods.Add(m);
|
|
foreach (var f in mergedType.TargetType.Fields)
|
|
existingEventsFields.Add(f.Name);
|
|
|
|
var compiledType = toExtraData[mergedType].CompiledType;
|
|
foreach (var compiledProp in compiledType.Properties) {
|
|
var newProp = oldPropertyToNewProperty[compiledProp].EditedMember;
|
|
if (!existingProps.Contains(newProp))
|
|
continue;
|
|
|
|
if (IsVirtual(compiledProp))
|
|
AddError(IM0006, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_RenamingVirtualPropsIsNotSupported, compiledProp));
|
|
|
|
var origName = newProp.Name;
|
|
int counter = 0;
|
|
while (existingProps.Contains(newProp))
|
|
newProp.Name = origName + "_" + (counter++).ToString();
|
|
existingProps.Add(newProp);
|
|
if (newProp.GetMethod is not null)
|
|
suggestedNames[newProp.GetMethod] = "get_" + newProp.Name;
|
|
if (newProp.SetMethod is not null)
|
|
suggestedNames[newProp.SetMethod] = "set_" + newProp.Name;
|
|
}
|
|
|
|
foreach (var compiledEvent in compiledType.Events) {
|
|
var newEvent = oldEventToNewEvent[compiledEvent].EditedMember;
|
|
if (!existingEventsFields.Contains(newEvent.Name))
|
|
continue;
|
|
|
|
if (IsVirtual(compiledEvent))
|
|
AddError(IM0007, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_RenamingVirtualEventsIsNotSupported, compiledEvent));
|
|
|
|
var origName = newEvent.Name;
|
|
int counter = 0;
|
|
while (existingEventsFields.Contains(newEvent.Name))
|
|
newEvent.Name = origName + "_" + (counter++).ToString();
|
|
existingEventsFields.Add(newEvent.Name);
|
|
if (newEvent.AddMethod is not null)
|
|
suggestedNames[newEvent.AddMethod] = "add_" + newEvent.Name;
|
|
if (newEvent.RemoveMethod is not null)
|
|
suggestedNames[newEvent.RemoveMethod] = "remove_" + newEvent.Name;
|
|
if (newEvent.InvokeMethod is not null)
|
|
suggestedNames[newEvent.InvokeMethod] = "raise_" + newEvent.Name;
|
|
}
|
|
|
|
foreach (var compiledMethod in compiledType.Methods) {
|
|
var newMethod = oldMethodToNewMethod[compiledMethod].EditedMember;
|
|
|
|
string? suggestedName;
|
|
suggestedNames.TryGetValue(newMethod, out suggestedName);
|
|
|
|
if (suggestedName is null && !existingMethods.Contains(newMethod))
|
|
continue;
|
|
|
|
if (compiledMethod.IsVirtual)
|
|
AddError(IM0008, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_RenamingVirtualMethodsIsNotSupported, compiledMethod));
|
|
|
|
string baseName = suggestedName ?? newMethod.Name;
|
|
int counter = 0;
|
|
newMethod.Name = baseName;
|
|
while (existingMethods.Contains(newMethod))
|
|
newMethod.Name = baseName + "_" + (counter++).ToString();
|
|
existingMethods.Add(newMethod);
|
|
}
|
|
|
|
foreach (var compiledField in compiledType.Fields) {
|
|
var newField = oldFieldToNewField[compiledField].EditedMember;
|
|
if (!existingEventsFields.Contains(newField.Name))
|
|
continue;
|
|
|
|
var origName = newField.Name;
|
|
int counter = 0;
|
|
while (existingEventsFields.Contains(newField.Name))
|
|
newField.Name = origName + "_" + (counter++).ToString();
|
|
existingEventsFields.Add(newField.Name);
|
|
}
|
|
}
|
|
|
|
readonly struct TypeName : IEquatable<TypeName> {
|
|
readonly UTF8String ns;
|
|
readonly UTF8String name;
|
|
|
|
public TypeName(TypeDef type)
|
|
: this(type.Namespace, type.Name) {
|
|
}
|
|
|
|
public TypeName(UTF8String ns, UTF8String name) {
|
|
this.ns = ns ?? UTF8String.Empty;
|
|
this.name = name ?? UTF8String.Empty;
|
|
}
|
|
|
|
public bool Equals(TypeName other) =>
|
|
UTF8String.Equals(ns, other.ns) &&
|
|
UTF8String.Equals(name, other.name);
|
|
|
|
public override bool Equals(object? obj) => obj is TypeName && Equals((TypeName)obj);
|
|
|
|
public override int GetHashCode() =>
|
|
UTF8String.GetHashCode(ns) ^
|
|
UTF8String.GetHashCode(name);
|
|
|
|
public override string ToString() {
|
|
if (UTF8String.IsNullOrEmpty(ns))
|
|
return name;
|
|
return ns + "." + name;
|
|
}
|
|
}
|
|
|
|
sealed class TypeNames {
|
|
readonly HashSet<TypeName> names;
|
|
|
|
public TypeNames() => names = new HashSet<TypeName>();
|
|
|
|
public TypeNames(IEnumerable<TypeDef> existingTypes) {
|
|
names = new HashSet<TypeName>();
|
|
foreach (var t in existingTypes)
|
|
names.Add(new TypeName(t.Namespace, t.Name));
|
|
}
|
|
|
|
public bool Contains(UTF8String ns, UTF8String name) =>
|
|
names.Contains(new TypeName(ns, name));
|
|
|
|
public bool Contains(TypeDef type) =>
|
|
names.Contains(new TypeName(type.Namespace, type.Name));
|
|
|
|
public void Add(UTF8String ns, UTF8String name) =>
|
|
names.Add(new TypeName(ns, name));
|
|
|
|
public void Add(TypeDef type) =>
|
|
names.Add(new TypeName(type.Namespace, type.Name));
|
|
}
|
|
|
|
sealed class UsedTypeNames {
|
|
readonly TypeNames typeNames;
|
|
|
|
public UsedTypeNames() => typeNames = new TypeNames();
|
|
|
|
public UsedTypeNames(IEnumerable<TypeDef> existingTypes) => typeNames = new TypeNames(existingTypes);
|
|
|
|
public UTF8String GetNewName(TypeDef type) {
|
|
var ns = type.Namespace;
|
|
var name = type.Name;
|
|
for (int counter = 0; ; counter++) {
|
|
if (!typeNames.Contains(ns, name))
|
|
break;
|
|
var typeName = type.Name.String;
|
|
int index = typeName.LastIndexOf('`');
|
|
if (index < 0)
|
|
index = typeName.Length;
|
|
name = typeName.Substring(0, index) + "__" + counter.ToString() + typeName.Substring(index);
|
|
}
|
|
typeNames.Add(ns, name);
|
|
return name;
|
|
}
|
|
|
|
public void Add(TypeDef type) =>
|
|
typeNames.Add(type);
|
|
}
|
|
|
|
NewImportedType CreateNewImportedType(TypeDef newType, IList<TypeDef> existingTypes) =>
|
|
CreateNewImportedType(newType, new UsedTypeNames(existingTypes));
|
|
|
|
NewImportedType CreateNewImportedType(TypeDef newType, UsedTypeNames usedTypeNames) {
|
|
var name = usedTypeNames.GetNewName(newType);
|
|
var importedType = AddNewImportedType(newType, name);
|
|
AddNewNestedTypes(newType);
|
|
return importedType;
|
|
}
|
|
|
|
void AddNewNestedTypes(TypeDef newType) {
|
|
if (newType.NestedTypes.Count == 0)
|
|
return;
|
|
var stack = new Stack<TypeDef>();
|
|
foreach (var t in newType.NestedTypes)
|
|
stack.Push(t);
|
|
while (stack.Count > 0) {
|
|
var newNestedType = stack.Pop();
|
|
var importedNewNestedType = AddNewImportedType(newNestedType, newNestedType.Name);
|
|
foreach (var t in newNestedType.NestedTypes)
|
|
stack.Push(t);
|
|
}
|
|
}
|
|
|
|
MergedImportedType AddMergedImportedType(TypeDef compiledType, TypeDef targetType, MergeKind mergeKind) {
|
|
var importedType = new MergedImportedType(targetType, mergeKind);
|
|
toExtraData.Add(importedType, new ExtraImportedTypeData(compiledType));
|
|
oldTypeToNewType.Add(compiledType, importedType);
|
|
if (!compiledType.IsGlobalModuleType)
|
|
oldTypeRefToNewType.Add(compiledType, importedType);
|
|
return importedType;
|
|
}
|
|
|
|
NewImportedType AddNewImportedType(TypeDef type, UTF8String name) {
|
|
var createdType = targetModule.UpdateRowId(new TypeDefUser(type.Namespace, name) { Attributes = type.Attributes });
|
|
var importedType = new NewImportedType(createdType);
|
|
toExtraData.Add(importedType, new ExtraImportedTypeData(type));
|
|
oldTypeToNewType.Add(type, importedType);
|
|
oldTypeRefToNewType.Add(type, importedType);
|
|
return importedType;
|
|
}
|
|
|
|
void InitializeTypesStep1(IEnumerable<NewImportedType> importedTypes) {
|
|
foreach (var importedType in importedTypes) {
|
|
var compiledType = toExtraData[importedType].CompiledType;
|
|
foreach (var field in compiledType.Fields)
|
|
Create(field);
|
|
foreach (var method in compiledType.Methods)
|
|
Create(method);
|
|
foreach (var prop in compiledType.Properties)
|
|
Create(prop);
|
|
foreach (var evt in compiledType.Events)
|
|
Create(evt);
|
|
}
|
|
}
|
|
|
|
void InitializeTypesStep2(IEnumerable<NewImportedType> importedTypes) {
|
|
foreach (var importedType in importedTypes) {
|
|
var compiledType = toExtraData[importedType].CompiledType;
|
|
importedType.TargetType!.BaseType = Import(compiledType.BaseType);
|
|
ImportCustomAttributes(importedType.TargetType, compiledType);
|
|
ImportDeclSecurities(importedType.TargetType, compiledType);
|
|
importedType.TargetType.ClassLayout = Import(compiledType.ClassLayout);
|
|
foreach (var genericParam in compiledType.GenericParameters)
|
|
importedType.TargetType.GenericParameters.Add(Import(genericParam));
|
|
foreach (var iface in compiledType.Interfaces)
|
|
importedType.TargetType.Interfaces.Add(Import(iface));
|
|
foreach (var nestedType in compiledType.NestedTypes)
|
|
importedType.TargetType.NestedTypes.Add(oldTypeToNewType[nestedType].TargetType);
|
|
|
|
foreach (var field in compiledType.Fields)
|
|
importedType.TargetType.Fields.Add(Initialize(field));
|
|
foreach (var method in compiledType.Methods)
|
|
importedType.TargetType.Methods.Add(Initialize(method));
|
|
foreach (var prop in compiledType.Properties)
|
|
importedType.TargetType.Properties.Add(Initialize(prop));
|
|
foreach (var evt in compiledType.Events)
|
|
importedType.TargetType.Events.Add(Initialize(evt));
|
|
}
|
|
}
|
|
|
|
// Adds all methods of existing properties and events of a merged type to make sure
|
|
// the methods aren't accidentally used twice. Could happen if the compiler (eg. mcs)
|
|
// doesn't set the PropertyDef.Type's HasThis flag even if it's an instance property.
|
|
// Roslyn will set this flag, so our comparison would fail to match the two (now different)
|
|
// properties. This comparison has since been fixed.
|
|
void AddUsedMethods(ImportedType importedType) {
|
|
foreach (var p in importedType.TargetType!.Properties) {
|
|
foreach (var m in p.GetMethods)
|
|
usedMethods.Add(m);
|
|
foreach (var m in p.SetMethods)
|
|
usedMethods.Add(m);
|
|
foreach (var m in p.OtherMethods)
|
|
usedMethods.Add(m);
|
|
}
|
|
foreach (var p in importedType.TargetType.Events) {
|
|
if (p.AddMethod is not null)
|
|
usedMethods.Add(p.AddMethod);
|
|
if (p.InvokeMethod is not null)
|
|
usedMethods.Add(p.InvokeMethod);
|
|
if (p.RemoveMethod is not null)
|
|
usedMethods.Add(p.RemoveMethod);
|
|
foreach (var m in p.OtherMethods)
|
|
usedMethods.Add(m);
|
|
}
|
|
}
|
|
|
|
void InitializeTypesStep1(IEnumerable<MergedImportedType> importedTypes) {
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var memberDict = new MemberLookup(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_BASE_OPTIONS, targetModule));
|
|
foreach (var importedType in importedTypes) {
|
|
var compiledType = toExtraData[importedType].CompiledType;
|
|
|
|
if (importedType.MergeKind == MergeKind.Rename) {
|
|
// All dupes are assumed to be new members and they're all renamed
|
|
|
|
foreach (var field in compiledType.Fields)
|
|
Create(field);
|
|
foreach (var method in compiledType.Methods)
|
|
Create(method);
|
|
foreach (var prop in compiledType.Properties)
|
|
Create(prop);
|
|
foreach (var evt in compiledType.Events)
|
|
Create(evt);
|
|
AddUsedMethods(importedType);
|
|
}
|
|
else if (importedType.MergeKind == MergeKind.Merge) {
|
|
// Duplicate members are assumed to be original members (stubs) and
|
|
// we should just redirect refs to them to the original members.
|
|
|
|
memberDict.Initialize(importedType.TargetType!);
|
|
|
|
foreach (var compiledField in compiledType.Fields) {
|
|
FieldDef? targetField;
|
|
if ((targetField = memberDict.FindField(compiledField)) is not null) {
|
|
memberDict.Remove(targetField);
|
|
isStub.Add(compiledField);
|
|
isStub.Add(targetField);
|
|
var editedField = targetModule.UpdateRowId(new FieldDefUser(targetField.Name));
|
|
oldFieldToNewField.Add(compiledField, new MemberInfo<FieldDef>(targetField, editedField));
|
|
}
|
|
else
|
|
Create(compiledField);
|
|
}
|
|
foreach (var compiledMethod in compiledType.Methods) {
|
|
MethodDef? targetMethod;
|
|
if ((targetMethod = memberDict.FindMethod(compiledMethod)) is not null || editedMethodsToFix.TryGetValue(compiledMethod, out targetMethod)) {
|
|
memberDict.Remove(targetMethod);
|
|
isStub.Add(compiledMethod);
|
|
isStub.Add(targetMethod);
|
|
var editedMethod = targetModule.UpdateRowId(new MethodDefUser(targetMethod.Name));
|
|
oldMethodToNewMethod.Add(compiledMethod, new MemberInfo<MethodDef>(targetMethod, editedMethod));
|
|
}
|
|
else
|
|
Create(compiledMethod);
|
|
}
|
|
foreach (var compiledProperty in compiledType.Properties) {
|
|
PropertyDef? targetProperty;
|
|
if ((targetProperty = memberDict.FindProperty(compiledProperty)) is not null) {
|
|
memberDict.Remove(targetProperty);
|
|
isStub.Add(compiledProperty);
|
|
isStub.Add(targetProperty);
|
|
var editedProperty = targetModule.UpdateRowId(new PropertyDefUser(targetProperty.Name));
|
|
oldPropertyToNewProperty.Add(compiledProperty, new MemberInfo<PropertyDef>(targetProperty, editedProperty));
|
|
}
|
|
else
|
|
Create(compiledProperty);
|
|
}
|
|
foreach (var compiledEvent in compiledType.Events) {
|
|
EventDef? targetEvent;
|
|
if ((targetEvent = memberDict.FindEvent(compiledEvent)) is not null) {
|
|
memberDict.Remove(targetEvent);
|
|
isStub.Add(compiledEvent);
|
|
isStub.Add(targetEvent);
|
|
var editedEvent = targetModule.UpdateRowId(new EventDefUser(targetEvent.Name));
|
|
oldEventToNewEvent.Add(compiledEvent, new MemberInfo<EventDef>(targetEvent, editedEvent));
|
|
}
|
|
else
|
|
Create(compiledEvent);
|
|
}
|
|
}
|
|
else if (importedType.MergeKind == MergeKind.Edit) {
|
|
foreach (var compiledField in compiledType.Fields) {
|
|
if (editedFieldsToFix.TryGetValue(compiledField, out var targetField)) {
|
|
var editedField = targetModule.UpdateRowId(new FieldDefUser(targetField.Name));
|
|
oldFieldToNewField.Add(compiledField, new MemberInfo<FieldDef>(targetField, editedField));
|
|
}
|
|
else
|
|
Create(compiledField);
|
|
}
|
|
foreach (var compiledMethod in compiledType.Methods) {
|
|
if (editedMethodsToFix.TryGetValue(compiledMethod, out var targetMethod)) {
|
|
var editedMethod = targetModule.UpdateRowId(new MethodDefUser(targetMethod.Name));
|
|
oldMethodToNewMethod.Add(compiledMethod, new MemberInfo<MethodDef>(targetMethod, editedMethod));
|
|
}
|
|
else
|
|
Create(compiledMethod);
|
|
}
|
|
foreach (var compiledProperty in compiledType.Properties) {
|
|
if (editedPropertiesToFix.TryGetValue(compiledProperty, out var targetProperty)) {
|
|
var editedProperty = targetModule.UpdateRowId(new PropertyDefUser(targetProperty.Name));
|
|
oldPropertyToNewProperty.Add(compiledProperty, new MemberInfo<PropertyDef>(targetProperty, editedProperty));
|
|
}
|
|
else
|
|
Create(compiledProperty);
|
|
}
|
|
foreach (var compiledEvent in compiledType.Events) {
|
|
if (editedEventsToFix.TryGetValue(compiledEvent, out var targetEvent)) {
|
|
var editedEvent = targetModule.UpdateRowId(new EventDefUser(targetEvent.Name));
|
|
oldEventToNewEvent.Add(compiledEvent, new MemberInfo<EventDef>(targetEvent, editedEvent));
|
|
}
|
|
else
|
|
Create(compiledEvent);
|
|
}
|
|
}
|
|
else
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
void Initialize(TypeDef compiledType, TypeDef targetType, TypeDefOptions options) {
|
|
options.Attributes = compiledType.Attributes;
|
|
options.Namespace = compiledType.Namespace;
|
|
options.Name = compiledType.Name;
|
|
options.PackingSize = compiledType.ClassLayout?.PackingSize;
|
|
options.ClassSize = compiledType.ClassLayout?.ClassSize;
|
|
options.BaseType = Import(compiledType.BaseType);
|
|
options.CustomAttributes.Clear();
|
|
ImportCustomAttributes(options.CustomAttributes, compiledType);
|
|
options.DeclSecurities.Clear();
|
|
ImportDeclSecurities(options.DeclSecurities, compiledType);
|
|
options.GenericParameters.Clear();
|
|
foreach (var genericParam in compiledType.GenericParameters)
|
|
options.GenericParameters.Add(Import(genericParam)!);
|
|
options.Interfaces.Clear();
|
|
foreach (var ifaceImpl in compiledType.Interfaces)
|
|
options.Interfaces.Add(Import(ifaceImpl)!);
|
|
}
|
|
|
|
void InitializeTypesStep2(IEnumerable<MergedImportedType> importedTypes) {
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var memberDict = new MemberLookup(new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_BASE_OPTIONS, targetModule));
|
|
foreach (var importedType in importedTypes) {
|
|
var compiledType = toExtraData[importedType].CompiledType;
|
|
|
|
Initialize(compiledType, importedType.TargetType!, importedType.NewTypeDefOptions);
|
|
|
|
if (importedType.MergeKind == MergeKind.Rename) {
|
|
// All dupes are assumed to be new members and they're all renamed
|
|
|
|
foreach (var field in compiledType.Fields)
|
|
importedType.NewFields.Add(Initialize(field)!);
|
|
foreach (var method in compiledType.Methods)
|
|
importedType.NewMethods.Add(Initialize(method)!);
|
|
foreach (var prop in compiledType.Properties)
|
|
importedType.NewProperties.Add(Initialize(prop)!);
|
|
foreach (var evt in compiledType.Events)
|
|
importedType.NewEvents.Add(Initialize(evt)!);
|
|
|
|
RenameMergedMembers(importedType);
|
|
}
|
|
else if (importedType.MergeKind == MergeKind.Merge) {
|
|
// Duplicate members are assumed to be original members (stubs) and
|
|
// we should just redirect refs to them to the original members.
|
|
|
|
memberDict.Initialize(importedType.TargetType!);
|
|
|
|
foreach (var compiledField in compiledType.Fields) {
|
|
FieldDef? targetField;
|
|
if ((targetField = memberDict.FindField(compiledField)) is not null) {
|
|
Initialize(compiledField);
|
|
memberDict.Remove(targetField);
|
|
}
|
|
else
|
|
importedType.NewFields.Add(Initialize(compiledField)!);
|
|
}
|
|
foreach (var compiledMethod in compiledType.Methods) {
|
|
MethodDef? targetMethod;
|
|
if ((targetMethod = memberDict.FindMethod(compiledMethod)!) is not null || editedMethodsToFix.TryGetValue(compiledMethod, out targetMethod)) {
|
|
Initialize(compiledMethod);
|
|
memberDict.Remove(targetMethod);
|
|
}
|
|
else
|
|
importedType.NewMethods.Add(Initialize(compiledMethod)!);
|
|
}
|
|
foreach (var compiledProperty in compiledType.Properties) {
|
|
PropertyDef? targetProperty;
|
|
if ((targetProperty = memberDict.FindProperty(compiledProperty)) is not null) {
|
|
Initialize(compiledProperty);
|
|
memberDict.Remove(targetProperty);
|
|
}
|
|
else
|
|
importedType.NewProperties.Add(Initialize(compiledProperty)!);
|
|
}
|
|
foreach (var compiledEvent in compiledType.Events) {
|
|
EventDef? targetEvent;
|
|
if ((targetEvent = memberDict.FindEvent(compiledEvent)) is not null) {
|
|
Initialize(compiledEvent);
|
|
memberDict.Remove(targetEvent);
|
|
}
|
|
else
|
|
importedType.NewEvents.Add(Initialize(compiledEvent)!);
|
|
}
|
|
}
|
|
else if (importedType.MergeKind == MergeKind.Edit) {
|
|
foreach (var compiledField in compiledType.Fields) {
|
|
if (editedFieldsToFix.TryGetValue(compiledField, out var targetField))
|
|
Initialize(compiledField);
|
|
else
|
|
importedType.NewFields.Add(Initialize(compiledField)!);
|
|
}
|
|
foreach (var compiledMethod in compiledType.Methods) {
|
|
if (editedMethodsToFix.TryGetValue(compiledMethod, out var targetMethod))
|
|
Initialize(compiledMethod);
|
|
else
|
|
importedType.NewMethods.Add(Initialize(compiledMethod)!);
|
|
}
|
|
foreach (var compiledProperty in compiledType.Properties) {
|
|
if (editedPropertiesToFix.TryGetValue(compiledProperty, out var targetProperty))
|
|
Initialize(compiledProperty);
|
|
else
|
|
importedType.NewProperties.Add(Initialize(compiledProperty)!);
|
|
}
|
|
foreach (var compiledEvent in compiledType.Events) {
|
|
if (editedEventsToFix.TryGetValue(compiledEvent, out var targetEvent))
|
|
Initialize(compiledEvent);
|
|
else
|
|
importedType.NewEvents.Add(Initialize(compiledEvent)!);
|
|
}
|
|
}
|
|
else
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
void InitializeTypesMethods(IEnumerable<NewImportedType> importedTypes) {
|
|
foreach (var importedType in importedTypes) {
|
|
foreach (var compiledMethod in toExtraData[importedType].CompiledType.Methods) {
|
|
var targetMethod = oldMethodToNewMethod[compiledMethod].EditedMember;
|
|
targetMethod.Body = CreateBody(targetMethod, compiledMethod);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitializeTypesMethods(IEnumerable<MergedImportedType> importedTypes) {
|
|
foreach (var importedType in importedTypes) {
|
|
foreach (var compiledMethod in toExtraData[importedType].CompiledType.Methods) {
|
|
var targetInfo = oldMethodToNewMethod[compiledMethod];
|
|
if (editedMethodsToFix.TryGetValue(compiledMethod, out var targetMethod2)) {
|
|
if (targetInfo.TargetMember != targetMethod2)
|
|
throw new InvalidOperationException();
|
|
if (compiledMethod.IsStatic != targetInfo.TargetMember.IsStatic)
|
|
AddError(IM0009, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_AddingRemovingStaticFromEditedMethodNotSupported, targetInfo.TargetMember));
|
|
targetInfo.EditedMember.Body = CreateBody(targetInfo.EditedMember, compiledMethod);
|
|
}
|
|
else if (!isStub.Contains(targetInfo.TargetMember))
|
|
targetInfo.EditedMember.Body = CreateBody(targetInfo.EditedMember, compiledMethod);
|
|
}
|
|
}
|
|
}
|
|
|
|
IMethodDefOrRef? Import(IMethodDefOrRef method) => (IMethodDefOrRef?)Import((IMethod)method);
|
|
|
|
ITypeDefOrRef? Import(ITypeDefOrRef type) {
|
|
if (type is null)
|
|
return null;
|
|
|
|
var res = TryGetTypeInTargetModule(type, out var importedType);
|
|
if (res is not null)
|
|
return res;
|
|
|
|
if (type is TypeRef tr)
|
|
return ImportTypeRefNoModuleChecks(tr, 0);
|
|
|
|
if (type is TypeSpec ts)
|
|
return ImportTypeSpec(ts);
|
|
|
|
// TypeDefs are already handled elsewhere
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
TypeRef? ImportTypeRefNoModuleChecks(TypeRef tr, int recurseCount) {
|
|
const int MAX_RECURSE_COUNT = 500;
|
|
if (recurseCount >= MAX_RECURSE_COUNT)
|
|
return null;
|
|
|
|
var scope = tr.ResolutionScope;
|
|
IResolutionScope? importedScope;
|
|
|
|
if (scope is TypeRef scopeTypeRef)
|
|
importedScope = ImportTypeRefNoModuleChecks(scopeTypeRef, recurseCount + 1);
|
|
else if (scope is AssemblyRef)
|
|
importedScope = Import((AssemblyRef)scope);
|
|
else if (scope is ModuleRef)
|
|
importedScope = Import((ModuleRef)scope, true);
|
|
else if (scope is ModuleDef) {
|
|
if (scope == targetModule || scope == sourceModule)
|
|
importedScope = targetModule;
|
|
else
|
|
throw new InvalidOperationException();
|
|
}
|
|
else
|
|
throw new InvalidOperationException();
|
|
|
|
var importedTypeRef = targetModule.UpdateRowId(new TypeRefUser(targetModule, tr.Namespace, tr.Name, importedScope));
|
|
ImportCustomAttributes(importedTypeRef, tr);
|
|
return importedTypeRef;
|
|
}
|
|
|
|
AssemblyRef? Import(AssemblyRef asmRef) {
|
|
if (asmRef is null)
|
|
return null;
|
|
var importedAssemblyRef = targetModule.UpdateRowId(new AssemblyRefUser(asmRef.Name, asmRef.Version, asmRef.PublicKeyOrToken, asmRef.Culture));
|
|
ImportCustomAttributes(importedAssemblyRef, asmRef);
|
|
importedAssemblyRef.Attributes = asmRef.Attributes;
|
|
importedAssemblyRef.Hash = asmRef.Hash;
|
|
return importedAssemblyRef;
|
|
}
|
|
|
|
TypeSpec? ImportTypeSpec(TypeSpec ts) {
|
|
if (ts is null)
|
|
return null;
|
|
var importedTypeSpec = targetModule.UpdateRowId(new TypeSpecUser(Import(ts.TypeSig)));
|
|
ImportCustomAttributes(importedTypeSpec, ts);
|
|
importedTypeSpec.ExtraData = ts.ExtraData;
|
|
return importedTypeSpec;
|
|
}
|
|
|
|
TypeDef? TryGetTypeInTargetModule(ITypeDefOrRef? tdr, out ImportedType? importedType) {
|
|
if (tdr is null) {
|
|
importedType = null;
|
|
return null;
|
|
}
|
|
|
|
if (tdr is TypeDef td)
|
|
return (importedType = oldTypeToNewType[td]).TargetType;
|
|
|
|
if (tdr is TypeRef tr) {
|
|
if (oldTypeRefToNewType.TryGetValue(tr, out var importedTypeTmp))
|
|
return (importedType = importedTypeTmp).TargetType;
|
|
|
|
var tr2 = (TypeRef)tr.GetNonNestedTypeRefScope();
|
|
if (IsTarget(tr2.ResolutionScope)) {
|
|
td = targetModule.Find(tr);
|
|
if (td is not null) {
|
|
importedType = null;
|
|
return td;
|
|
}
|
|
|
|
AddError(IM0003, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindType, tr));
|
|
importedType = null;
|
|
return null;
|
|
}
|
|
if (IsSource(tr2.ResolutionScope))
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
importedType = null;
|
|
return null;
|
|
}
|
|
|
|
bool IsSource(IResolutionScope scope) {
|
|
if (scope is AssemblyRef asmRef)
|
|
return IsSource(asmRef);
|
|
|
|
if (scope is ModuleRef modRef)
|
|
return IsSource(modRef);
|
|
|
|
return scope == sourceModule;
|
|
}
|
|
|
|
bool IsTarget(IResolutionScope scope) {
|
|
if (scope is AssemblyRef asmRef)
|
|
return IsTarget(asmRef);
|
|
|
|
if (scope is ModuleRef modRef)
|
|
return IsTarget(modRef);
|
|
|
|
return scope == targetModule;
|
|
}
|
|
|
|
bool IsSource(AssemblyRef asmRef) => AssemblyNameComparer.CompareAll.Equals(asmRef, sourceModule.Assembly);
|
|
bool IsTarget(AssemblyRef asmRef) => AssemblyNameComparer.CompareAll.Equals(asmRef, targetModule.Assembly);
|
|
|
|
bool IsSourceOrTarget(ModuleRef modRef) => IsSource(modRef) || IsTarget(modRef);
|
|
bool IsSource(ModuleRef modRef) => StringComparer.OrdinalIgnoreCase.Equals(modRef?.Name, sourceModule.Name);
|
|
bool IsTarget(ModuleRef modRef) => StringComparer.OrdinalIgnoreCase.Equals(modRef?.Name, targetModule.Name);
|
|
|
|
// The type/method could be in some external assembly, eg. System.Private.CoreLib, don't return those defs.
|
|
TypeDef? TryImportTypeDef(TypeDef? type) => type is not null && oldTypeToNewType.TryGetValue(type, out var importedType) ? importedType.TargetType : null;
|
|
MethodDef? TryImportMethodDef(MethodDef? method) => method is not null && oldMethodToNewMethod.TryGetValue(method, out var importedMethod) ? importedMethod.TargetMember : null;
|
|
|
|
TypeSig? Import(TypeSig type) {
|
|
if (type is null)
|
|
return null;
|
|
|
|
TypeSig? result;
|
|
switch (type.ElementType) {
|
|
case ElementType.Void: result = targetModule.CorLibTypes.Void; break;
|
|
case ElementType.Boolean: result = targetModule.CorLibTypes.Boolean; break;
|
|
case ElementType.Char: result = targetModule.CorLibTypes.Char; break;
|
|
case ElementType.I1: result = targetModule.CorLibTypes.SByte; break;
|
|
case ElementType.U1: result = targetModule.CorLibTypes.Byte; break;
|
|
case ElementType.I2: result = targetModule.CorLibTypes.Int16; break;
|
|
case ElementType.U2: result = targetModule.CorLibTypes.UInt16; break;
|
|
case ElementType.I4: result = targetModule.CorLibTypes.Int32; break;
|
|
case ElementType.U4: result = targetModule.CorLibTypes.UInt32; break;
|
|
case ElementType.I8: result = targetModule.CorLibTypes.Int64; break;
|
|
case ElementType.U8: result = targetModule.CorLibTypes.UInt64; break;
|
|
case ElementType.R4: result = targetModule.CorLibTypes.Single; break;
|
|
case ElementType.R8: result = targetModule.CorLibTypes.Double; break;
|
|
case ElementType.String: result = targetModule.CorLibTypes.String; break;
|
|
case ElementType.TypedByRef:result = targetModule.CorLibTypes.TypedReference; break;
|
|
case ElementType.I: result = targetModule.CorLibTypes.IntPtr; break;
|
|
case ElementType.U: result = targetModule.CorLibTypes.UIntPtr; break;
|
|
case ElementType.Object: result = targetModule.CorLibTypes.Object; break;
|
|
case ElementType.Ptr: result = new PtrSig(Import(type.Next)); break;
|
|
case ElementType.ByRef: result = new ByRefSig(Import(type.Next)); break;
|
|
case ElementType.ValueType: result = CreateClassOrValueType(((ClassOrValueTypeSig)type).TypeDefOrRef, true); break;
|
|
case ElementType.Class: result = CreateClassOrValueType(((ClassOrValueTypeSig)type).TypeDefOrRef, false); break;
|
|
case ElementType.Var: result = new GenericVar(((GenericVar)type).Number, TryImportTypeDef(((GenericVar)type).OwnerType)); break;
|
|
case ElementType.ValueArray:result = new ValueArraySig(Import(type.Next), ((ValueArraySig)type).Size); break;
|
|
case ElementType.FnPtr: result = new FnPtrSig(Import(((FnPtrSig)type).Signature)); break;
|
|
case ElementType.SZArray: result = new SZArraySig(Import(type.Next)); break;
|
|
case ElementType.MVar: result = new GenericMVar(((GenericMVar)type).Number, TryImportMethodDef(((GenericMVar)type).OwnerMethod)); break;
|
|
case ElementType.CModReqd: result = new CModReqdSig(Import(((ModifierSig)type).Modifier), Import(type.Next)); break;
|
|
case ElementType.CModOpt: result = new CModOptSig(Import(((ModifierSig)type).Modifier), Import(type.Next)); break;
|
|
case ElementType.Module: result = new ModuleSig(((ModuleSig)type).Index, Import(type.Next)); break;
|
|
case ElementType.Sentinel: result = new SentinelSig(); break;
|
|
case ElementType.Pinned: result = new PinnedSig(Import(type.Next)); break;
|
|
|
|
case ElementType.Array:
|
|
var arraySig = (ArraySig)type;
|
|
var sizes = new List<uint>(arraySig.Sizes);
|
|
var lbounds = new List<int>(arraySig.LowerBounds);
|
|
result = new ArraySig(Import(type.Next), arraySig.Rank, sizes, lbounds);
|
|
break;
|
|
|
|
case ElementType.GenericInst:
|
|
var gis = (GenericInstSig)type;
|
|
var genArgs = new List<TypeSig>(gis.GenericArguments.Count);
|
|
foreach (var ga in gis.GenericArguments)
|
|
genArgs.Add(Import(ga)!);
|
|
result = new GenericInstSig(Import(gis.GenericType) as ClassOrValueTypeSig, genArgs);
|
|
break;
|
|
|
|
case ElementType.End:
|
|
case ElementType.R:
|
|
case ElementType.Internal:
|
|
default:
|
|
result = null;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
TypeSig CreateClassOrValueType(ITypeDefOrRef type, bool isValueType) {
|
|
var corLibType = targetModule.CorLibTypes.GetCorLibTypeSig(type);
|
|
if (corLibType is not null)
|
|
return corLibType;
|
|
|
|
if (isValueType)
|
|
return new ValueTypeSig(Import(type));
|
|
return new ClassSig(Import(type));
|
|
}
|
|
|
|
void ImportCustomAttributes(IHasCustomAttribute target, IHasCustomAttribute source) =>
|
|
ImportCustomAttributes(target.CustomAttributes, source);
|
|
|
|
void ImportCustomAttributes(IList<CustomAttribute> targetList, IHasCustomAttribute source) {
|
|
foreach (var ca in source.CustomAttributes)
|
|
targetList.Add(Import(ca)!);
|
|
}
|
|
|
|
ICustomAttributeType? Import(ICustomAttributeType caType) {
|
|
if (caType is MemberRef mr) {
|
|
Debug.Assert(mr.IsMethodRef);
|
|
if (mr.IsMethodRef)
|
|
return (ICustomAttributeType?)Import((IMethod)mr);
|
|
return (ICustomAttributeType?)Import((IField)mr);
|
|
}
|
|
if (caType is MethodDef md)
|
|
return oldMethodToNewMethod[md].TargetMember;
|
|
return null;
|
|
}
|
|
|
|
CustomAttribute? Import(CustomAttribute ca) {
|
|
if (ca is null)
|
|
return null;
|
|
if (ca.IsRawBlob)
|
|
return new CustomAttribute(Import(ca.Constructor), ca.RawData);
|
|
|
|
var importedCustomAttribute = new CustomAttribute(Import(ca.Constructor));
|
|
foreach (var arg in ca.ConstructorArguments)
|
|
importedCustomAttribute.ConstructorArguments.Add(Import(arg));
|
|
foreach (var namedArg in ca.NamedArguments)
|
|
importedCustomAttribute.NamedArguments.Add(Import(namedArg));
|
|
|
|
return importedCustomAttribute;
|
|
}
|
|
|
|
CAArgument Import(CAArgument arg) => new CAArgument(Import(arg.Type), ImportCAValue(arg.Value));
|
|
|
|
object? ImportCAValue(object? value) {
|
|
if (value is CAArgument)
|
|
return Import((CAArgument)value);
|
|
if (value is IList<CAArgument> args) {
|
|
var newArgs = new List<CAArgument>(args.Count);
|
|
foreach (var arg in args)
|
|
newArgs.Add(Import(arg));
|
|
return newArgs;
|
|
}
|
|
if (value is TypeSig)
|
|
return Import((TypeSig)value);
|
|
return value;
|
|
}
|
|
|
|
CANamedArgument Import(CANamedArgument namedArg) =>
|
|
new CANamedArgument(namedArg.IsField, Import(namedArg.Type), namedArg.Name, Import(namedArg.Argument));
|
|
|
|
void ImportDeclSecurities(IHasDeclSecurity target, IHasDeclSecurity source) =>
|
|
ImportDeclSecurities(target.DeclSecurities, source);
|
|
|
|
void ImportDeclSecurities(IList<DeclSecurity> targetList, IHasDeclSecurity source) {
|
|
foreach (var ds in source.DeclSecurities)
|
|
targetList.Add(Import(ds)!);
|
|
}
|
|
|
|
DeclSecurity? Import(DeclSecurity ds) {
|
|
if (ds is null)
|
|
return null;
|
|
|
|
var importedDeclSecurity = targetModule.UpdateRowId(new DeclSecurityUser());
|
|
ImportCustomAttributes(importedDeclSecurity, ds);
|
|
importedDeclSecurity.Action = ds.Action;
|
|
foreach (var sa in ds.SecurityAttributes)
|
|
importedDeclSecurity.SecurityAttributes.Add(Import(sa));
|
|
|
|
return importedDeclSecurity;
|
|
}
|
|
|
|
SecurityAttribute? Import(SecurityAttribute sa) {
|
|
if (sa is null)
|
|
return null;
|
|
|
|
var importedSecurityAttribute = new SecurityAttribute(Import(sa.AttributeType));
|
|
foreach (var namedArg in sa.NamedArguments)
|
|
importedSecurityAttribute.NamedArguments.Add(Import(namedArg));
|
|
|
|
return importedSecurityAttribute;
|
|
}
|
|
|
|
Constant? Import(Constant constant) {
|
|
if (constant is null)
|
|
return null;
|
|
return targetModule.UpdateRowId(new ConstantUser(constant.Value, constant.Type));
|
|
}
|
|
|
|
MarshalType? Import(MarshalType marshalType) {
|
|
if (marshalType is null)
|
|
return null;
|
|
|
|
if (marshalType is RawMarshalType) {
|
|
var mt = (RawMarshalType)marshalType;
|
|
return new RawMarshalType(mt.Data);
|
|
}
|
|
|
|
if (marshalType is FixedSysStringMarshalType) {
|
|
var mt = (FixedSysStringMarshalType)marshalType;
|
|
return new FixedSysStringMarshalType(mt.Size);
|
|
}
|
|
|
|
if (marshalType is SafeArrayMarshalType) {
|
|
var mt = (SafeArrayMarshalType)marshalType;
|
|
return new SafeArrayMarshalType(mt.VariantType, Import(mt.UserDefinedSubType));
|
|
}
|
|
|
|
if (marshalType is FixedArrayMarshalType) {
|
|
var mt = (FixedArrayMarshalType)marshalType;
|
|
return new FixedArrayMarshalType(mt.Size, mt.ElementType);
|
|
}
|
|
|
|
if (marshalType is ArrayMarshalType) {
|
|
var mt = (ArrayMarshalType)marshalType;
|
|
return new ArrayMarshalType(mt.ElementType, mt.ParamNumber, mt.Size, mt.Flags);
|
|
}
|
|
|
|
if (marshalType is CustomMarshalType) {
|
|
var mt = (CustomMarshalType)marshalType;
|
|
return new CustomMarshalType(mt.Guid, mt.NativeTypeName, Import(mt.CustomMarshaler), mt.Cookie);
|
|
}
|
|
|
|
if (marshalType is InterfaceMarshalType) {
|
|
var mt = (InterfaceMarshalType)marshalType;
|
|
return new InterfaceMarshalType(mt.NativeType, mt.IidParamIndex);
|
|
}
|
|
|
|
Debug.Assert(marshalType.GetType() == typeof(MarshalType));
|
|
return new MarshalType(marshalType.NativeType);
|
|
}
|
|
|
|
ImplMap? Import(ImplMap implMap) {
|
|
if (implMap is null)
|
|
return null;
|
|
return targetModule.UpdateRowId(new ImplMapUser(Import(implMap.Module, false), implMap.Name, implMap.Attributes));
|
|
}
|
|
|
|
ModuleRef Import(ModuleRef module, bool canConvertToTargetModule) {
|
|
var name = canConvertToTargetModule && IsSourceOrTarget(module) ? targetModule.Name : module.Name;
|
|
var importedModuleRef = targetModule.UpdateRowId(new ModuleRefUser(targetModule, name));
|
|
ImportCustomAttributes(importedModuleRef, module);
|
|
return importedModuleRef;
|
|
}
|
|
|
|
ClassLayout? Import(ClassLayout classLayout) {
|
|
if (classLayout is null)
|
|
return null;
|
|
return targetModule.UpdateRowId(new ClassLayoutUser(classLayout.PackingSize, classLayout.ClassSize));
|
|
}
|
|
|
|
CallingConventionSig? Import(CallingConventionSig signature) {
|
|
if (signature is null)
|
|
return null;
|
|
|
|
if (signature is MethodSig)
|
|
return Import((MethodSig)signature);
|
|
if (signature is FieldSig)
|
|
return Import((FieldSig)signature);
|
|
if (signature is GenericInstMethodSig)
|
|
return Import((GenericInstMethodSig)signature);
|
|
if (signature is PropertySig)
|
|
return Import((PropertySig)signature);
|
|
if (signature is LocalSig)
|
|
return Import((LocalSig)signature);
|
|
return null;
|
|
}
|
|
|
|
MethodSig? Import(MethodSig sig) {
|
|
if (sig is null)
|
|
return null;
|
|
return Import(new MethodSig(sig.GetCallingConvention()), sig);
|
|
}
|
|
|
|
PropertySig? Import(PropertySig sig) {
|
|
if (sig is null)
|
|
return null;
|
|
return Import(new PropertySig(sig.HasThis), sig);
|
|
}
|
|
|
|
T Import<T>(T sig, T old) where T : MethodBaseSig {
|
|
sig.RetType = Import(old.RetType);
|
|
foreach (var p in old.Params)
|
|
sig.Params.Add(Import(p));
|
|
sig.GenParamCount = old.GenParamCount;
|
|
var paramsAfterSentinel = sig.ParamsAfterSentinel;
|
|
if (paramsAfterSentinel is not null) {
|
|
foreach (var p in old.ParamsAfterSentinel)
|
|
paramsAfterSentinel.Add(Import(p));
|
|
}
|
|
return sig;
|
|
}
|
|
|
|
FieldSig? Import(FieldSig sig) {
|
|
if (sig is null)
|
|
return null;
|
|
return new FieldSig(Import(sig.Type));
|
|
}
|
|
|
|
GenericInstMethodSig? Import(GenericInstMethodSig sig) {
|
|
if (sig is null)
|
|
return null;
|
|
|
|
var result = new GenericInstMethodSig();
|
|
foreach (var l in sig.GenericArguments)
|
|
result.GenericArguments.Add(Import(l));
|
|
|
|
return result;
|
|
}
|
|
|
|
LocalSig? Import(LocalSig sig) {
|
|
if (sig is null)
|
|
return null;
|
|
|
|
var result = new LocalSig();
|
|
foreach (var l in sig.Locals)
|
|
result.Locals.Add(Import(l));
|
|
|
|
return result;
|
|
}
|
|
|
|
static readonly bool keepImportedRva = false;
|
|
RVA GetRVA(RVA rva) => keepImportedRva ? rva : 0;
|
|
|
|
void Create(FieldDef field) {
|
|
var importedField = targetModule.UpdateRowId(new FieldDefUser(field.Name));
|
|
oldFieldToNewField.Add(field, new MemberInfo<FieldDef>(importedField, importedField));
|
|
}
|
|
|
|
void Create(MethodDef method) {
|
|
var importedMethodDef = targetModule.UpdateRowId(new MethodDefUser(method.Name));
|
|
oldMethodToNewMethod.Add(method, new MemberInfo<MethodDef>(importedMethodDef, importedMethodDef));
|
|
}
|
|
|
|
void Create(PropertyDef propDef) {
|
|
var importedPropertyDef = targetModule.UpdateRowId(new PropertyDefUser(propDef.Name));
|
|
oldPropertyToNewProperty.Add(propDef, new MemberInfo<PropertyDef>(importedPropertyDef, importedPropertyDef));
|
|
}
|
|
|
|
void Create(EventDef eventDef) {
|
|
var importedEventDef = targetModule.UpdateRowId(new EventDefUser(eventDef.Name));
|
|
oldEventToNewEvent.Add(eventDef, new MemberInfo<EventDef>(importedEventDef, importedEventDef));
|
|
}
|
|
|
|
FieldDef? Initialize(FieldDef field) {
|
|
if (field is null)
|
|
return null;
|
|
var importedField = oldFieldToNewField[field].EditedMember;
|
|
ImportCustomAttributes(importedField, field);
|
|
importedField.Signature = Import(field.Signature);
|
|
importedField.Attributes = field.Attributes;
|
|
importedField.RVA = GetRVA(field.RVA);
|
|
importedField.InitialValue = field.InitialValue;
|
|
importedField.Constant = Import(field.Constant);
|
|
importedField.FieldOffset = field.FieldOffset;
|
|
importedField.MarshalType = Import(field.MarshalType);
|
|
importedField.ImplMap = Import(field.ImplMap);
|
|
return importedField;
|
|
}
|
|
|
|
MethodDef? Initialize(MethodDef method) {
|
|
if (method is null)
|
|
return null;
|
|
var importedMethodDef = oldMethodToNewMethod[method].EditedMember;
|
|
ImportCustomAttributes(importedMethodDef, method);
|
|
ImportDeclSecurities(importedMethodDef, method);
|
|
importedMethodDef.RVA = GetRVA(method.RVA);
|
|
importedMethodDef.ImplAttributes = method.ImplAttributes;
|
|
importedMethodDef.Attributes = method.Attributes;
|
|
importedMethodDef.Signature = Import(method.Signature);
|
|
importedMethodDef.SemanticsAttributes = method.SemanticsAttributes;
|
|
importedMethodDef.ImplMap = Import(method.ImplMap);
|
|
foreach (var paramDef in method.ParamDefs)
|
|
importedMethodDef.ParamDefs.Add(Import(paramDef));
|
|
foreach (var genericParam in method.GenericParameters)
|
|
importedMethodDef.GenericParameters.Add(Import(genericParam));
|
|
foreach (var ovr in method.Overrides)
|
|
importedMethodDef.Overrides.Add(new MethodOverride(Import(ovr.MethodBody), Import(ovr.MethodDeclaration)));
|
|
importedMethodDef.Parameters.UpdateParameterTypes();
|
|
return importedMethodDef;
|
|
}
|
|
|
|
GenericParam? Import(GenericParam gp) {
|
|
if (gp is null)
|
|
return null;
|
|
var importedGenericParam = targetModule.UpdateRowId(new GenericParamUser(gp.Number, gp.Flags, gp.Name));
|
|
ImportCustomAttributes(importedGenericParam, gp);
|
|
importedGenericParam.Kind = Import(gp.Kind);
|
|
foreach (var gpc in gp.GenericParamConstraints)
|
|
importedGenericParam.GenericParamConstraints.Add(Import(gpc));
|
|
return importedGenericParam;
|
|
}
|
|
|
|
GenericParamConstraint? Import(GenericParamConstraint gpc) {
|
|
if (gpc is null)
|
|
return null;
|
|
var importedGenericParamConstraint = targetModule.UpdateRowId(new GenericParamConstraintUser(Import(gpc.Constraint)));
|
|
ImportCustomAttributes(importedGenericParamConstraint, gpc);
|
|
return importedGenericParamConstraint;
|
|
}
|
|
|
|
InterfaceImpl? Import(InterfaceImpl ifaceImpl) {
|
|
if (ifaceImpl is null)
|
|
return null;
|
|
var importedInterfaceImpl = targetModule.UpdateRowId(new InterfaceImplUser(Import(ifaceImpl.Interface)));
|
|
ImportCustomAttributes(importedInterfaceImpl, ifaceImpl);
|
|
return importedInterfaceImpl;
|
|
}
|
|
|
|
ParamDef? Import(ParamDef paramDef) {
|
|
if (paramDef is null)
|
|
return null;
|
|
var importedParamDef = targetModule.UpdateRowId(new ParamDefUser(paramDef.Name, paramDef.Sequence, paramDef.Attributes));
|
|
ImportCustomAttributes(importedParamDef, paramDef);
|
|
importedParamDef.MarshalType = Import(paramDef.MarshalType);
|
|
importedParamDef.Constant = Import(paramDef.Constant);
|
|
return importedParamDef;
|
|
}
|
|
|
|
PropertyDef? Initialize(PropertyDef propDef) {
|
|
if (propDef is null)
|
|
return null;
|
|
var importedPropertyDef = oldPropertyToNewProperty[propDef].EditedMember;
|
|
ImportCustomAttributes(importedPropertyDef, propDef);
|
|
importedPropertyDef.Attributes = propDef.Attributes;
|
|
importedPropertyDef.Type = Import(propDef.Type);
|
|
importedPropertyDef.Constant = Import(propDef.Constant);
|
|
foreach (var m in propDef.GetMethods) {
|
|
var newMethod = TryGetMethod(m);
|
|
if (newMethod is not null)
|
|
importedPropertyDef.GetMethods.Add(newMethod);
|
|
}
|
|
foreach (var m in propDef.SetMethods) {
|
|
var newMethod = TryGetMethod(m);
|
|
if (newMethod is not null)
|
|
importedPropertyDef.SetMethods.Add(newMethod);
|
|
}
|
|
foreach (var m in propDef.OtherMethods) {
|
|
var newMethod = TryGetMethod(m);
|
|
if (newMethod is not null)
|
|
importedPropertyDef.OtherMethods.Add(newMethod);
|
|
}
|
|
return importedPropertyDef;
|
|
}
|
|
|
|
MethodDef? TryGetMethod(MethodDef method) {
|
|
if (method is null)
|
|
return null;
|
|
var m = oldMethodToNewMethod[method].TargetMember;
|
|
if (usedMethods.Contains(m))
|
|
return null;
|
|
usedMethods.Add(m);
|
|
return m;
|
|
}
|
|
|
|
EventDef? Initialize(EventDef eventDef) {
|
|
if (eventDef is null)
|
|
return null;
|
|
var importedEventDef = oldEventToNewEvent[eventDef].EditedMember;
|
|
importedEventDef.EventType = Import(eventDef.EventType);
|
|
importedEventDef.Attributes = eventDef.Attributes;
|
|
ImportCustomAttributes(importedEventDef, eventDef);
|
|
if (eventDef.AddMethod is not null) {
|
|
var newMethod = TryGetMethod(eventDef.AddMethod);
|
|
if (newMethod is not null)
|
|
importedEventDef.AddMethod = newMethod;
|
|
}
|
|
if (eventDef.InvokeMethod is not null) {
|
|
var newMethod = TryGetMethod(eventDef.InvokeMethod);
|
|
if (newMethod is not null)
|
|
importedEventDef.InvokeMethod = newMethod;
|
|
}
|
|
if (eventDef.RemoveMethod is not null) {
|
|
var newMethod = TryGetMethod(eventDef.RemoveMethod);
|
|
if (newMethod is not null)
|
|
importedEventDef.RemoveMethod = newMethod;
|
|
}
|
|
foreach (var m in eventDef.OtherMethods) {
|
|
var newMethod = TryGetMethod(m);
|
|
if (newMethod is not null)
|
|
importedEventDef.OtherMethods.Add(newMethod);
|
|
}
|
|
return importedEventDef;
|
|
}
|
|
|
|
CilBody? CreateBody(MethodDef paramsSourceMethod, MethodDef sourceMethod) {
|
|
// NOTE: Both methods can be identical: targetMethod == sourceMethod
|
|
|
|
var sourceBody = sourceMethod.Body;
|
|
if (sourceBody is null)
|
|
return null;
|
|
|
|
var targetBody = new CilBody();
|
|
targetBody.KeepOldMaxStack = sourceBody.KeepOldMaxStack;
|
|
targetBody.InitLocals = sourceBody.InitLocals;
|
|
targetBody.HeaderSize = sourceBody.HeaderSize;
|
|
targetBody.MaxStack = sourceBody.MaxStack;
|
|
targetBody.LocalVarSigTok = sourceBody.LocalVarSigTok;
|
|
|
|
bodyDict.Clear();
|
|
foreach (var local in sourceBody.Variables) {
|
|
var newLocal = new Local(Import(local.Type), local.Name);
|
|
bodyDict[local] = newLocal;
|
|
newLocal.Attributes = local.Attributes;
|
|
targetBody.Variables.Add(newLocal);
|
|
}
|
|
|
|
int si = sourceMethod.IsStatic ? 0 : 1;
|
|
int ti = paramsSourceMethod.IsStatic ? 0 : 1;
|
|
if (sourceMethod.Parameters.Count - si != paramsSourceMethod.Parameters.Count - ti)
|
|
throw new InvalidOperationException();
|
|
for (; si < sourceMethod.Parameters.Count && ti < paramsSourceMethod.Parameters.Count; si++, ti++)
|
|
bodyDict[sourceMethod.Parameters[si]] = paramsSourceMethod.Parameters[ti];
|
|
|
|
foreach (var instr in sourceBody.Instructions) {
|
|
var newInstr = new Instruction(instr.OpCode, instr.Operand);
|
|
newInstr.Offset = instr.Offset;
|
|
newInstr.SequencePoint = instr.SequencePoint?.Clone();
|
|
bodyDict[instr] = newInstr;
|
|
targetBody.Instructions.Add(newInstr);
|
|
}
|
|
|
|
foreach (var eh in sourceBody.ExceptionHandlers) {
|
|
var newEh = new ExceptionHandler(eh.HandlerType);
|
|
newEh.TryStart = GetInstruction(bodyDict, eh.TryStart);
|
|
newEh.TryEnd = GetInstruction(bodyDict, eh.TryEnd);
|
|
newEh.FilterStart = GetInstruction(bodyDict, eh.FilterStart);
|
|
newEh.HandlerStart = GetInstruction(bodyDict, eh.HandlerStart);
|
|
newEh.HandlerEnd = GetInstruction(bodyDict, eh.HandlerEnd);
|
|
newEh.CatchType = Import(eh.CatchType);
|
|
targetBody.ExceptionHandlers.Add(newEh);
|
|
}
|
|
|
|
foreach (var newInstr in targetBody.Instructions) {
|
|
var op = newInstr.Operand;
|
|
if (op is null)
|
|
continue;
|
|
|
|
if (bodyDict.TryGetValue(op, out var obj)) {
|
|
newInstr.Operand = obj;
|
|
continue;
|
|
}
|
|
|
|
if (op is IList<Instruction> oldList) {
|
|
var targets = new Instruction?[oldList.Count];
|
|
for (int i = 0; i < oldList.Count; i++)
|
|
targets[i] = GetInstruction(bodyDict, oldList[i]);
|
|
newInstr.Operand = targets;
|
|
continue;
|
|
}
|
|
|
|
if (op is ITypeDefOrRef tdr) {
|
|
newInstr.Operand = Import(tdr);
|
|
continue;
|
|
}
|
|
|
|
if (op is IMethod method && method.IsMethod) {
|
|
newInstr.Operand = Import(method);
|
|
continue;
|
|
}
|
|
|
|
if (op is IField field) {
|
|
newInstr.Operand = Import(field);
|
|
continue;
|
|
}
|
|
|
|
if (op is MethodSig msig) {
|
|
newInstr.Operand = Import(msig);
|
|
continue;
|
|
}
|
|
|
|
Debug.Assert(op is sbyte || op is byte || op is int || op is long || op is float || op is double || op is string);
|
|
}
|
|
|
|
return targetBody;
|
|
}
|
|
|
|
static Instruction? GetInstruction(Dictionary<object, object> dict, Instruction instr) {
|
|
if (instr is null || !dict.TryGetValue(instr, out var obj))
|
|
return null;
|
|
return (Instruction)obj;
|
|
}
|
|
|
|
IMethod? Import(IMethod method) {
|
|
if (method is null)
|
|
return null;
|
|
|
|
if (method is MethodDef md)
|
|
return oldMethodToNewMethod[md].TargetMember;
|
|
|
|
if (method is MethodSpec ms) {
|
|
var importedMethodSpec = new MethodSpecUser(Import(ms.Method), Import(ms.GenericInstMethodSig));
|
|
ImportCustomAttributes(importedMethodSpec, ms);
|
|
return importedMethodSpec;
|
|
}
|
|
|
|
var mr = (MemberRef)method;
|
|
var td = TryGetTypeInTargetModule(mr.Class as ITypeDefOrRef, out var importedType);
|
|
if (td is not null) {
|
|
var targetMethod = FindMethod(td, mr);
|
|
if (targetMethod is not null)
|
|
return targetMethod;
|
|
if (importedType is not null) {
|
|
var compiledMethod = FindMethod(toExtraData[importedType].CompiledType, mr);
|
|
if (compiledMethod is not null)
|
|
return oldMethodToNewMethod[compiledMethod].TargetMember;
|
|
}
|
|
|
|
AddError(IM0004, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindMethod, mr));
|
|
return null;
|
|
}
|
|
|
|
return ImportNoCheckForDefs(mr);
|
|
}
|
|
|
|
MethodDef? FindMethod(TypeDef targetType, MemberRef mr) {
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var comparer = new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule);
|
|
foreach (var method in targetType.Methods) {
|
|
if (!UTF8String.Equals(method.Name, mr.Name))
|
|
continue;
|
|
if (comparer.Equals(method.MethodSig, mr.MethodSig))
|
|
return method;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
IField? Import(IField field) {
|
|
if (field is null)
|
|
return null;
|
|
|
|
if (field is FieldDef fd)
|
|
return oldFieldToNewField[fd].TargetMember;
|
|
|
|
var mr = (MemberRef)field;
|
|
var td = TryGetTypeInTargetModule(mr.Class as ITypeDefOrRef, out var importedType);
|
|
if (td is not null) {
|
|
var targetField = FindField(td, mr);
|
|
if (targetField is not null)
|
|
return targetField;
|
|
if (importedType is not null) {
|
|
var compiledField = FindField(toExtraData[importedType].CompiledType, mr);
|
|
if (compiledField is not null)
|
|
return oldFieldToNewField[compiledField].TargetMember;
|
|
}
|
|
|
|
AddError(IM0005, string.Format(dnSpy_AsmEditor_Resources.ERR_IM_CouldNotFindField, mr));
|
|
return null;
|
|
}
|
|
|
|
return ImportNoCheckForDefs(mr);
|
|
}
|
|
|
|
FieldDef? FindField(TypeDef targetType, MemberRef mr) {
|
|
Debug2.Assert(importSigComparerOptions is not null);
|
|
var comparer = new ImportSigComparer(importSigComparerOptions, SIG_COMPARER_OPTIONS, targetModule);
|
|
foreach (var field in targetType.Fields) {
|
|
if (!UTF8String.Equals(field.Name, mr.Name))
|
|
continue;
|
|
if (comparer.Equals(field.FieldSig, mr.FieldSig))
|
|
return field;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
MemberRef ImportNoCheckForDefs(MemberRef mr) {
|
|
var importedMemberRef = targetModule.UpdateRowId(new MemberRefUser(targetModule, mr.Name));
|
|
ImportCustomAttributes(importedMemberRef, mr);
|
|
importedMemberRef.Signature = Import(mr.Signature);
|
|
importedMemberRef.Class = Import(mr.Class);
|
|
return importedMemberRef;
|
|
}
|
|
|
|
IMemberRefParent? Import(IMemberRefParent cls) {
|
|
if (cls is null)
|
|
return null;
|
|
|
|
if (cls is ITypeDefOrRef tdr)
|
|
return Import(tdr);
|
|
|
|
if (cls is MethodDef md)
|
|
return oldMethodToNewMethod[md].TargetMember;
|
|
|
|
if (cls is ModuleRef modRef)
|
|
return Import(modRef, true);
|
|
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
void ImportExportedTypes(List<ExportedType> exportedTypes) {
|
|
var toNewExportedType = new Dictionary<ExportedType, ExportedType>(sourceModule.ExportedTypes.Count);
|
|
var toNewImpl = new Dictionary<IImplementation, IImplementation>();
|
|
foreach (var et in sourceModule.ExportedTypes) {
|
|
var newEt = targetModule.UpdateRowId(new ExportedTypeUser(targetModule, et.TypeDefId, et.TypeNamespace, et.Name, et.Attributes, null));
|
|
exportedTypes.Add(newEt);
|
|
toNewExportedType.Add(et, newEt);
|
|
toNewImpl.Add(et, newEt);
|
|
}
|
|
foreach (var kv in toNewExportedType) {
|
|
var et = kv.Key;
|
|
var newEt = kv.Value;
|
|
var origImpl = et.Implementation;
|
|
if (origImpl is null)
|
|
continue;
|
|
if (!toNewImpl.TryGetValue(origImpl, out var newImpl)) {
|
|
switch (origImpl) {
|
|
case FileDef file:
|
|
newImpl = targetModule.UpdateRowId(new FileDefUser(file.Name, file.Flags, file.HashValue));
|
|
break;
|
|
|
|
case AssemblyRef asmRef:
|
|
newImpl = targetModule.UpdateRowId(new AssemblyRefUser(asmRef.Name, asmRef.Version, asmRef.PublicKeyOrToken, asmRef.Culture));
|
|
break;
|
|
|
|
case ExportedType declType:
|
|
// Should never happen since it should only reference an ExportedType that exists in ExportedTypes property
|
|
throw new InvalidOperationException();
|
|
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
toNewImpl.Add(origImpl, newImpl);
|
|
}
|
|
newEt.Implementation = newImpl;
|
|
}
|
|
}
|
|
}
|
|
}
|