private IEnumerable <SharpTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!type.HasInterfaces)
{
yield break;
}
TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Resolve() == analyzedMethod.DeclaringType);
if (implementedInterfaceRef == null)
{
yield break;
}
foreach (PropertyDefinition property in type.Properties.Where(e => e.Name == analyzedProperty.Name))
{
MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
yield return(new AnalyzedPropertyTreeNode(property));
}
yield break;
}
foreach (PropertyDefinition property in type.Properties.Where(e => e.Name.EndsWith(analyzedProperty.Name)))
{
MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod))
{
yield return(new AnalyzedPropertyTreeNode(property));
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!type.HasInterfaces)
{
yield break;
}
TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Resolve() == analyzedMethod.DeclaringType);
if (implementedInterfaceRef == null)
{
yield break;
}
foreach (MethodDefinition method in type.Methods.Where(m => m.Name == analyzedMethod.Name))
{
if (TypesHierarchyHelpers.MatchInterfaceMethod(method, analyzedMethod, implementedInterfaceRef))
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
yield break;
}
foreach (MethodDefinition method in type.Methods)
{
if (method.HasOverrides && method.Overrides.Any(m => m.Resolve() == analyzedMethod))
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
IEnumerable <AnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (analyzedMethod is null)
{
yield break;
}
if (type.IsInterface)
{
yield break;
}
var implementedInterfaceRef = InterfaceMethodImplementedByNode.GetInterface(type, analyzedMethod.DeclaringType);
if (implementedInterfaceRef is null)
{
yield break;
}
foreach (EventDef ev in type.Events.Where(e => e.Name.EndsWith(analyzedEvent.Name)))
{
var accessor = GetAccessor(ev);
// Don't include abstract accessors, they don't implement anything
if (accessor is null || !accessor.IsVirtual || accessor.IsAbstract)
{
continue;
}
if (accessor.HasOverrides && accessor.Overrides.Any(m => CheckEquals(m.MethodDeclaration.ResolveMethodDef(), analyzedMethod)))
{
yield return(new EventNode(ev)
{
Context = Context
});
yield break;
}
}
foreach (EventDef ev in type.Events.Where(e => e.Name == analyzedEvent.Name))
{
var accessor = GetAccessor(ev);
// Don't include abstract accessors, they don't implement anything
if (accessor is null || !accessor.IsVirtual || accessor.IsAbstract)
{
continue;
}
if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
yield return(new EventNode(ev)
{
Context = Context
});
yield break;
}
}
}
static bool Impl(MethodDef method, MethodDef ifaceMethod)
{
if (method.HasOverrides)
{
var comparer = new SigComparer(SigComparerOptions.CompareDeclaringTypes | SigComparerOptions.PrivateScopeIsComparable);
if (method.Overrides.Any(m => comparer.Equals(m.MethodDeclaration, ifaceMethod)))
{
return(true);
}
}
if (method.Name != ifaceMethod.Name)
{
return(false);
}
return(TypesHierarchyHelpers.MatchInterfaceMethod(method, ifaceMethod, ifaceMethod.DeclaringType));
}
IEnumerable <IAnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (analyzedMethod == null)
{
yield break;
}
if (!type.HasInterfaces)
{
yield break;
}
var iff = type.Interfaces.FirstOrDefault(i => new SigComparer().Equals(i.Interface, analyzedMethod.DeclaringType));
ITypeDefOrRef implementedInterfaceRef = iff == null ? null : iff.Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
//TODO: Can we compare property sigs too?
foreach (PropertyDef property in type.Properties.Where(e => e.Name == analyzedProperty.Name))
{
MethodDef accessor = property.GetMethod ?? property.SetMethod;
if (accessor != null && TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
yield return(new PropertyNode(property)
{
Context = Context
});
}
yield break;
}
foreach (PropertyDef property in type.Properties.Where(e => e.Name.EndsWith(analyzedProperty.Name)))
{
MethodDef accessor = property.GetMethod ?? property.SetMethod;
if (accessor != null && accessor.HasOverrides && accessor.Overrides.Any(m => m.MethodDeclaration.ResolveMethodDef() == analyzedMethod))
{
yield return(new PropertyNode(property)
{
Context = Context
});
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
if (analyzedMethod == null)
{
yield break;
}
if (!type.HasInterfaces)
{
yield break;
}
var iff = type.Interfaces.FirstOrDefault(i => new SigComparer().Equals(i.Interface, analyzedMethod.DeclaringType));
ITypeDefOrRef implementedInterfaceRef = iff == null ? null : iff.Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
//TODO: Can we compare property sigs too?
foreach (PropertyDef property in type.Properties.Where(e => e.Name == analyzedProperty.Name))
{
MethodDef accessor = property.GetMethod ?? property.SetMethod;
if (accessor != null && TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return(node);
}
yield break;
}
foreach (PropertyDef property in type.Properties.Where(e => e.Name.EndsWith(analyzedProperty.Name)))
{
MethodDef accessor = property.GetMethod ?? property.SetMethod;
if (accessor != null && accessor.HasOverrides && accessor.Overrides.Any(m => new SigComparer(SigComparerOptions.CompareDeclaringTypes | SigComparerOptions.PrivateScopeIsComparable).Equals(m.MethodDeclaration, analyzedMethod)))
{
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return(node);
}
}
}
IEnumerable <IAnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (!type.HasInterfaces || analyzedMethod == null)
{
yield break;
}
var iff = type.Interfaces.FirstOrDefault(i => new SigComparer().Equals(i.Interface, analyzedMethod.DeclaringType));
ITypeDefOrRef implementedInterfaceRef = iff == null ? null : iff.Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
//TODO: Can we compare event types too?
foreach (EventDef ev in type.Events.Where(e => e.Name == analyzedEvent.Name))
{
MethodDef accessor = ev.AddMethod ?? ev.RemoveMethod;
if (accessor != null && TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
yield return(new EventNode(ev)
{
Context = Context
});
}
}
foreach (EventDef ev in type.Events.Where(e => e.Name.EndsWith(analyzedEvent.Name)))
{
MethodDef accessor = ev.AddMethod ?? ev.RemoveMethod;
if (accessor != null && accessor.HasOverrides &&
accessor.Overrides.Any(m => m.MethodDeclaration.ResolveMethodDef() == analyzedMethod))
{
yield return(new EventNode(ev)
{
Context = Context
});
}
}
}
public static IEnumerable <VirtualMethod> VirtualAnalysis(IEnumerable <TypeDefinition> types)
{
var virtuals = new Dictionary <MethodDefinition, VirtualMethod>();
foreach (var t in types)
{
foreach (var m in t.Methods)
{
//types
var overrides = TypesHierarchyHelpers.FindBaseMethods(m).Where(b => b.IsVirtual);
foreach (var basem in overrides)
{
AddMethod(virtuals, m, basem);
}
foreach (var i in t.Interfaces)
{
foreach (var interfaceMethod in i.InterfaceType.Resolve().Methods)
{
// don't create virtual for the instance checker metod
if (interfaceMethod.Name.Contains("IsInstance"))
{
continue;
}
//if (MatchInterfaceMethod(interfaceMethod, m))
if (TypesHierarchyHelpers.MatchInterfaceMethod(interfaceMethod, m, i.InterfaceType))
{
AddMethod(virtuals, m, interfaceMethod);
}
}
}
}
}
return(virtuals.Values.ToArray());
}
IEnumerable <IAnalyzerTreeNodeData> FindReferencesInType(TypeDef type)
{
if (!type.HasInterfaces)
{
yield break;
}
var iff = type.Interfaces.FirstOrDefault(i => new SigComparer().Equals(i.Interface, analyzedMethod.DeclaringType));
ITypeDefOrRef implementedInterfaceRef = iff == null ? null : iff.Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
//TODO: Can we compare method sigs too?
foreach (MethodDef method in type.Methods.Where(m => m.Name == analyzedMethod.Name))
{
if (TypesHierarchyHelpers.MatchInterfaceMethod(method, analyzedMethod, implementedInterfaceRef))
{
yield return(new MethodNode(method)
{
Context = Context
});
}
yield break;
}
foreach (MethodDef method in type.Methods)
{
if (method.HasOverrides && method.Overrides.Any(m => m.MethodDeclaration.ResolveMethodDef() == analyzedMethod))
{
yield return(new MethodNode(method)
{
Context = Context
});
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
if (!type.HasInterfaces)
{
yield break;
}
ITypeDefOrRef implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Interface.ResolveTypeDef() == analyzedMethod.DeclaringType).Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
foreach (EventDef ev in type.Events.Where(e => e.Name == analyzedEvent.Name))
{
MethodDef accessor = ev.AddMethod ?? ev.RemoveMethod;
if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
yield break;
}
foreach (EventDef ev in type.Events.Where(e => e.Name.String.EndsWith(analyzedEvent.Name)))
{
MethodDef accessor = ev.AddMethod ?? ev.RemoveMethod;
if (accessor.HasOverrides && accessor.Overrides.Any(m => Decompiler.DnlibExtensions.Resolve(m.MethodDeclaration) == analyzedMethod))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
}
}
private IEnumerable <SharpTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!type.HasInterfaces)
{
yield break;
}
TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Resolve() == analyzedMethod.DeclaringType);
if (implementedInterfaceRef == null)
{
yield break;
}
foreach (EventDefinition ev in type.Events.Where(e => e.Name == analyzedEvent.Name))
{
MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
yield break;
}
foreach (EventDefinition ev in type.Events.Where(e => e.Name.EndsWith(analyzedEvent.Name)))
{
MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
if (!type.HasInterfaces)
{
yield break;
}
var iff = type.Interfaces.FirstOrDefault(i => new SigComparer().Equals(i.Interface, analyzedMethod.DeclaringType));
ITypeDefOrRef implementedInterfaceRef = iff == null ? null : iff.Interface;
if (implementedInterfaceRef == null)
{
yield break;
}
//TODO: Can we compare method sigs too?
foreach (MethodDef method in type.Methods.Where(m => m.Name == analyzedMethod.Name))
{
if (TypesHierarchyHelpers.MatchInterfaceMethod(method, analyzedMethod, implementedInterfaceRef))
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
yield break;
}
foreach (MethodDef method in type.Methods)
{
if (method.HasOverrides && method.Overrides.Any(m => new SigComparer(SigComparerOptions.CompareDeclaringTypes | SigComparerOptions.PrivateScopeIsComparable).Equals(m.MethodDeclaration, analyzedMethod)))
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
