public ModuleState(CorModuleDefFile corModuleDefFile, IModuleDocumentNode moduleNode, HashSet <uint> modifiedTypes, HashSet <uint> loadClassHash) { this.CorModuleDefFile = corModuleDefFile; this.ModuleNode = moduleNode; this.ModifiedTypes = modifiedTypes; this.LoadClassHash = loadClassHash; }
SolveAllMethods(IMethodAnnotations methodAnnotations, IModuleDocumentNode moduleNode, List <DeadInstr> deadInstructions, CancellationToken token) { this.methodAnnotations = methodAnnotations; this.moduleNode = moduleNode; this.methods = new List <MethodDef>(); var module = moduleNode.GetModule(); if (module.HasTypes) { foreach (TypeDef type in (IEnumerable <TypeDef>)module.Types) { AddMethods(methods, type); } } this.origMethodBodys = new List <MethodBody>(); foreach (var method in this.methods) { this.origMethodBodys.Add(method.MethodBody); } this.deadInstructions = new DeadInstr[deadInstructions.Count]; deadInstructions.CopyTo(this.deadInstructions); this.isBodyModified = new List <bool>(); this.token = token; }
public NamespaceNodeCreator(string ns, IModuleDocumentNode modNode) { this.modNode = modNode; this.nsNode = modNode.FindNode(ns); if (this.nsNode == null) { this.nsNode = modNode.Create(ns); this.nsNodeCreated = true; } }
public AddUpdatedNodesHelper(Lazy <IMethodAnnotations> methodAnnotations, IModuleDocumentNode modNode, ModuleImporter importer) { this.modNode = modNode; this.newTypeNodeCreators = importer.NewNonNestedTypes.Select(a => new TypeNodeCreator(modNode, a.TargetType)).ToArray(); this.existingTypeNodeUpdaters = importer.MergedNonNestedTypes.Select(a => new ExistingTypeNodeUpdater(methodAnnotations, modNode, a)).ToArray(); if (!importer.MergedNonNestedTypes.All(a => a.TargetType.Module == modNode.Document.ModuleDef)) { throw new InvalidOperationException(); } }
public TreeViewUpdater(IDocumentTabService documentTabService, CorModuleDefFile cmdf, IModuleDocumentNode node, HashSet <uint> modifiedTypes, HashSet <uint> loadedClassTokens) { Debug.Assert(node.Document == cmdf); this.documentTabService = documentTabService; this.CorModuleDefFile = cmdf; this.ModuleNode = node; this.modifiedTypes = new HashSet <uint>(modifiedTypes); this.loadedClassTokens = loadedClassTokens; this.checkedTypes = new HashSet <TypeDef>(); this.modNode = node; }
protected AddNetModuleToAssemblyCommand(IUndoCommandService undoCommandService, IDsDocumentNode asmNode, IModuleDocumentNode modNode, bool modNodeWasCreated) { this.undoCommandService = undoCommandService; if (!(asmNode is IAssemblyDocumentNode)) { asmNode = (IAssemblyDocumentNode)asmNode.TreeNode.Parent.Data; } this.asmNode = (IAssemblyDocumentNode)asmNode; this.modNode = modNode; this.modNodeWasCreated = modNodeWasCreated; }
public EditedMethodBodyUpdater(Lazy <IMethodAnnotations> methodAnnotations, IModuleDocumentNode modNode, MethodDef originalMethod, Emit.MethodBody newBody, MethodImplAttributes newImplAttributes) { this.methodAnnotations = methodAnnotations; this.ownerNode = modNode.Context.DocumentTreeView.FindNode(originalMethod); if (ownerNode == null) { throw new InvalidOperationException(); } this.method = originalMethod; this.originalBodyState = new BodyState(originalMethod, methodAnnotations.Value.IsBodyModified(method)); this.newBodyState = new BodyState(newBody, newImplAttributes, true); }
static INamespaceNode GetOrCreateNamespaceNode(IModuleDocumentNode modNode, string ns) { modNode.TreeNode.EnsureChildrenLoaded(); var nsNode = modNode.TreeNode.DataChildren.OfType <INamespaceNode>().FirstOrDefault(a => a.Name == ns); if (nsNode != null) { return(nsNode); } nsNode = modNode.Create(ns); modNode.TreeNode.AddChild(nsNode.TreeNode); return(nsNode); }
RemoveNetModuleFromAssemblyCommand(Lazy <IUndoCommandService> undoCommandService, IModuleDocumentNode modNode) { this.undoCommandService = undoCommandService; this.asmNode = (IAssemblyDocumentNode)modNode.TreeNode.Parent.Data; Debug.Assert(this.asmNode != null); this.modNode = modNode; this.removeIndex = asmNode.TreeNode.DataChildren.ToList().IndexOf(modNode); Debug.Assert(this.removeIndex > 0); Debug.Assert(asmNode.Document.AssemblyDef != null && asmNode.Document.AssemblyDef.Modules.IndexOf(modNode.Document.ModuleDef) == this.removeIndex); this.removeIndexDocument = asmNode.Document.Children.IndexOf(modNode.Document); Debug.Assert(this.removeIndexDocument >= 0); }
static ITypeNode GetOrCreateNonNestedTypeTreeNode(IModuleDocumentNode modNode, TypeDef type) { Debug.Assert(type != null && type.DeclaringType == null); modNode.TreeNode.EnsureChildrenLoaded(); ITypeNode typeNode; var nsNode = GetOrCreateNamespaceNode(modNode, type.Namespace); typeNode = nsNode.TreeNode.DataChildren.OfType <ITypeNode>().FirstOrDefault(a => a.TypeDef == type); if (typeNode != null) { return(typeNode); } typeNode = nsNode.Create(type); nsNode.TreeNode.AddChild(typeNode.TreeNode); return(typeNode); }
public NestedTypeNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerTypeNode, TypeDef nestedType) { if (modNode == null) { throw new ArgumentNullException(nameof(modNode)); } if (nestedType == null) { throw new ArgumentNullException(nameof(nestedType)); } if (nestedType.Module != null) { throw new ArgumentException(); } this.ownerTypeNode = ownerTypeNode; this.nestedTypeNode = modNode.Context.DocumentTreeView.CreateNested(nestedType); }
public TypeNodeCreator(IModuleDocumentNode modNode, TypeDef type) { if (modNode == null) { throw new ArgumentNullException(nameof(modNode)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } // Can't be a nested type, and can't be part of a module yet if (type.DeclaringType != null || type.Module != null) { throw new ArgumentException(); } this.ownerList = modNode.Document.ModuleDef.Types; this.nsNodeCreator = new NamespaceNodeCreator(type.Namespace, modNode); this.typeNode = modNode.Context.DocumentTreeView.Create(type); }
public ExistingTypeNodeUpdater(Lazy <IMethodAnnotations> methodAnnotations, IModuleDocumentNode modNode, MergedImportedType type) { this.typeNode = modNode.Context.DocumentTreeView.FindNode(type.TargetType); if (this.typeNode == null) { throw new InvalidOperationException(); } this.nestedTypes1 = type.NewNestedTypes.OfType <MergedImportedType>().Select(a => new ExistingTypeNodeUpdater(methodAnnotations, modNode, a)).ToArray(); this.nestedTypes2 = type.NewNestedTypes.OfType <NewImportedType>().Select(a => new NestedTypeNodeCreator(modNode, typeNode, a.TargetType)).ToArray(); if (nestedTypes1.Length + nestedTypes2.Length != type.NewNestedTypes.Count) { throw new InvalidOperationException(); } this.fields = type.NewFields.Select(a => new FieldNodeCreator(modNode, typeNode, a)).ToArray(); var specialMethods = GetSpecialMethods(type); this.methods = type.NewMethods.Where(a => !specialMethods.Contains(a)).Select(a => new MethodNodeCreator(modNode, typeNode, a)).ToArray(); this.events = type.NewEvents.Select(a => new EventNodeCreator(modNode, typeNode, a)).ToArray(); this.properties = type.NewProperties.Select(a => new PropertyNodeCreator(modNode, typeNode, a)).ToArray(); this.editedMethods = type.EditedMethodBodies.Select(a => new EditedMethodBodyUpdater(methodAnnotations, modNode, a.OriginalMethod, a.NewBody, a.ImplAttributes)).ToArray(); }
public MethodNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerNode, MethodDef method) { this.ownerNode = ownerNode; this.methodNode = modNode.Context.DocumentTreeView.Create(method); }
static IAssemblyDocumentNode GetParentAssembly(IModuleDocumentNode modNode) => modNode?.TreeNode?.Parent?.Data as IAssemblyDocumentNode;
ModuleSettingsCommand(IModuleDocumentNode modNode, ModuleOptions newOptions) { this.modNode = modNode; this.newOptions = newOptions; this.origOptions = new ModuleOptions(modNode.Document.ModuleDef); }
public PropertyNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerNode, PropertyDef property) { this.ownerNode = ownerNode; this.propNode = modNode.Context.DocumentTreeView.Create(property); }
public FieldNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerNode, FieldDef field) { this.ownerNode = ownerNode; this.fieldNode = modNode.Context.DocumentTreeView.Create(field); }
EditMethodBodyCodeCommand(Lazy <IMethodAnnotations> methodAnnotations, IModuleDocumentNode modNode, ModuleImporter importer) { this.addUpdatedNodesHelper = new AddUpdatedNodesHelper(methodAnnotations, modNode, importer); }
public EventNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerNode, EventDef @event) { this.ownerNode = ownerNode; this.eventNode = modNode.Context.DocumentTreeView.Create(@event); }
AddNewNetModuleToAssemblyCommand(IUndoCommandService undoCommandService, IDsDocumentNode asmNode, IModuleDocumentNode modNode) : base(undoCommandService, asmNode, modNode, true) { }
public ReferencesFolderNode(ITreeNodeGroup treeNodeGroup, IModuleDocumentNode moduleNode) { Debug.Assert(moduleNode.Document.ModuleDef != null); this.TreeNodeGroup = treeNodeGroup; this.moduleNode = moduleNode; }
AddExistingNetModuleToAssemblyCommand(IUndoCommandService undoCommandService, IDsDocumentNode asmNode, IModuleDocumentNode modNode) : base(undoCommandService, asmNode, modNode, false) { }