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); } } }