private IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct)
{
string asmName = asm.AssemblyDefinition.Name.Name;
string name = analyzedEvent.Name;
string declTypeName = analyzedEvent.DeclaringType.FullName;
foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes))
{
ct.ThrowIfCancellationRequested();
if (!TypesHierarchyHelpers.IsBaseType(analyzedEvent.DeclaringType, type, resolveTypeArguments: false))
{
continue;
}
foreach (EventDefinition eventDef in type.Events)
{
ct.ThrowIfCancellationRequested();
if (TypesHierarchyHelpers.IsBaseEvent(analyzedEvent, eventDef))
{
MethodDefinition anyAccessor = eventDef.AddMethod ?? eventDef.RemoveMethod;
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
yield return(new AnalyzedEventTreeNode(eventDef, hidesParent ? "(hides) " : ""));
}
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
AnalyzerTreeNode newNode = null;
try {
if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false))
{
yield break;
}
foreach (MethodDef method in type.Methods)
{
if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method))
{
bool hidesParent = !method.IsVirtual ^ method.IsNewSlot;
newNode = new AnalyzedMethodTreeNode(method, hidesParent);
}
}
}
catch (ResolveException) {
// ignore this type definition. maybe add a notification about such cases.
}
if (newNode != null)
{
newNode.Language = this.Language;
yield return(newNode);
}
}
bool IsAssignableTo(TypeDefinition from, TypeDefinition to)
{
if (to.IsInterface)
{
return(from.Interfaces.Any(x => x.InterfaceType == to));
}
else
{
return(TypesHierarchyHelpers.IsBaseType(to, from, false));
}
}
private IEnumerable<AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!TypesHierarchyHelpers.IsBaseType(analyzedEvent.DeclaringType, type, resolveTypeArguments: false))
yield break;
foreach (EventDefinition eventDef in type.Events) {
if (TypesHierarchyHelpers.IsBaseEvent(analyzedEvent, eventDef)) {
MethodDefinition anyAccessor = eventDef.AddMethod ?? eventDef.RemoveMethod;
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
var node = new AnalyzedEventTreeNode(eventDef, hidesParent ? "(hides) " : "");
node.Language = this.Language;
yield return node;
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false))
{
yield break;
}
foreach (PropertyDef property in type.Properties)
{
if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property))
{
MethodDef anyAccessor = property.GetMethod ?? property.SetMethod;
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
var node = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : "");
node.Language = this.Language;
yield return(node);
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
foreach (MethodDef method in type.Methods)
{
bool found = false;
if (!method.HasBody)
{
continue;
}
// ignore chained constructors
// (since object is the root of everything, we can short circuit the test in this case)
if (method.Name == ".ctor" &&
(isSystemObject || analyzedType == type || TypesHierarchyHelpers.IsBaseType(analyzedType, type, false)))
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
IMethod mr = instr.Operand as IMethod;
if (mr != null && !mr.IsField && mr.Name == ".ctor")
{
if (Helpers.IsReferencedBy(analyzedType, mr.DeclaringType))
{
found = true;
break;
}
}
}
Helpers.FreeMethodBody(method);
if (found)
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
IEnumerable <IAnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
foreach (MethodDef method in type.Methods)
{
if (!method.HasBody)
{
continue;
}
// ignore chained constructors
// (since object is the root of everything, we can short circuit the test in this case)
if (method.Name == ".ctor" &&
(isSystemObject || analyzedType == type || TypesHierarchyHelpers.IsBaseType(analyzedType, type, false)))
{
continue;
}
Instruction foundInstr = null;
foreach (Instruction instr in method.Body.Instructions)
{
IMethod mr = instr.Operand as IMethod;
if (mr != null && !mr.IsField && mr.Name == ".ctor")
{
if (Helpers.IsReferencedBy(analyzedType, mr.DeclaringType))
{
foundInstr = instr;
break;
}
}
}
if (foundInstr != null)
{
yield return new MethodNode(method)
{
Context = Context, SourceRef = new SourceRef(method, foundInstr.Offset, foundInstr.Operand as IMDTokenProvider)
}
}
;
}
}
private IEnumerable <SharpTreeNode> FindReferencesInType(TypeDefinition type)
{
foreach (MethodDefinition method in type.Methods)
{
bool found = false;
if (!method.HasBody)
{
continue;
}
// ignore chained constructors
// (since object is the root of everything, we can short circuit the test in this case)
if (method.Name == ".ctor" &&
(isSystemObject || analyzedType == type || TypesHierarchyHelpers.IsBaseType(analyzedType, type, false)))
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
MethodReference mr = instr.Operand as MethodReference;
if (mr != null && mr.Name == ".ctor")
{
if (Helpers.IsReferencedBy(analyzedType, mr.DeclaringType))
{
found = true;
break;
}
}
}
method.Body = null;
if (found)
{
yield return(new AnalyzedMethodTreeNode(method));
}
}
}
IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct)
{
string asmName = asm.AssemblyDefinition.Name.Name;
string name = analyzedProperty.Name;
string declTypeName = analyzedProperty.DeclaringType.FullName;
foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes))
{
ct.ThrowIfCancellationRequested();
SharpTreeNode newNode = null;
try {
if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false))
{
continue;
}
foreach (PropertyDefinition property in type.Properties)
{
ct.ThrowIfCancellationRequested();
if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property))
{
MethodDefinition anyAccessor = property.GetMethod ?? property.SetMethod;
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
newNode = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : "");
}
}
}
catch (ReferenceResolvingException) {
// ignore this type definition.
}
if (newNode != null)
{
yield return(newNode);
}
}
}
private IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct)
{
string asmName = asm.AssemblyDefinition.Name.Name;
string name = analyzedMethod.Name;
string declTypeName = analyzedMethod.DeclaringType.FullName;
foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes))
{
ct.ThrowIfCancellationRequested();
SharpTreeNode newNode = null;
try {
if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false))
{
continue;
}
foreach (MethodDefinition method in type.Methods)
{
ct.ThrowIfCancellationRequested();
if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method))
{
bool hidesParent = !method.IsVirtual ^ method.IsNewSlot;
newNode = new AnalyzedMethodTreeNode(method, hidesParent ? "(hides) " : "");
}
}
}
catch (ReferenceResolvingException) {
// ignore this type definition. maybe add a notification about such cases.
}
if (newNode != null)
{
yield return(newNode);
}
}
}
IEnumerable <IAnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (!TypesHierarchyHelpers.IsBaseType(analyzedEvent.DeclaringType, type, resolveTypeArguments: false))
{
yield break;
}
foreach (EventDef eventDef in type.Events)
{
if (TypesHierarchyHelpers.IsBaseEvent(analyzedEvent, eventDef))
{
MethodDef anyAccessor = eventDef.AddMethod ?? eventDef.RemoveMethod;
if (anyAccessor == null)
{
continue;
}
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
yield return(new EventNode(eventDef, hidesParent)
{
Context = Context
});
}
}
}
IEnumerable <AnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false))
{
yield break;
}
foreach (PropertyDef property in type.Properties)
{
if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property))
{
MethodDef anyAccessor = property.GetMethod ?? property.SetMethod;
if (anyAccessor == null)
{
continue;
}
bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot;
yield return(new PropertyNode(property, hidesParent)
{
Context = Context
});
}
}
}