public static void Analyze(MemberReference member)
{
TypeDefinition type = member as TypeDefinition;
if (type != null)
{
AnalyzerTreeView.Instance.Show(new AnalyzedTypeTreeNode(type));
}
FieldDefinition field = member as FieldDefinition;
if (field != null)
{
AnalyzerTreeView.Instance.Show(new AnalyzedFieldTreeNode(field));
}
MethodDefinition method = member as MethodDefinition;
if (method != null)
{
AnalyzerTreeView.Instance.Show(new AnalyzedMethodTreeNode(method));
}
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
{
AnalyzerTreeView.Instance.Show(propertyAnalyzer);
}
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
{
AnalyzerTreeView.Instance.Show(eventAnalyzer);
}
}
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 (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 || 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)) {
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return node;
}
yield break;
}
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 => new SigComparer(SigComparerOptions.CompareDeclaringTypes | SigComparerOptions.PrivateScopeIsComparable).Equals(m.MethodDeclaration, analyzedMethod))) {
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return node;
}
}
}
public static bool CanAnalyze(IMemberRef member)
{
member = MainWindow.ResolveReference(member);
return(member is TypeDef ||
member is FieldDef ||
member is MethodDef ||
AnalyzedPropertyTreeNode.CanShow(member) ||
AnalyzedEventTreeNode.CanShow(member));
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDef type)
{
if (analyzedType.IsEnum && type == analyzedType)
{
yield break;
}
if (!this.Language.ShowMember(type))
{
yield break;
}
foreach (FieldDef field in type.Fields)
{
if (TypeIsExposedBy(field))
{
var node = new AnalyzedFieldTreeNode(field);
node.Language = this.Language;
yield return(node);
}
}
foreach (PropertyDef property in type.Properties)
{
if (TypeIsExposedBy(property))
{
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return(node);
}
}
foreach (EventDef eventDef in type.Events)
{
if (TypeIsExposedBy(eventDef))
{
var node = new AnalyzedEventTreeNode(eventDef);
node.Language = this.Language;
yield return(node);
}
}
foreach (MethodDef method in type.Methods)
{
if (TypeIsExposedBy(method))
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
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(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;
}
}
}
public bool IsEnabled(SharpTreeNode[] selectedNodes)
{
foreach (IMemberTreeNode node in selectedNodes)
{
if (!(node.Member is TypeDefinition ||
node.Member is FieldDefinition ||
node.Member is MethodDefinition ||
AnalyzedPropertyTreeNode.CanShow(node.Member) ||
AnalyzedEventTreeNode.CanShow(node.Member)))
{
return(false);
}
}
return(true);
}
public static void Analyze(IMemberRef member)
{
TypeDef type = null;
if (member is ITypeDefOrRef)
{
type = ((ITypeDefOrRef)member).ResolveTypeDef();
}
if (type != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
}
FieldDef field = member as FieldDef;
if (field == null && member is IField && ((IField)member).IsField)
{
field = ((IField)member).ResolveFieldDef();
}
if (field != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
}
MethodDef method = member as MethodDef;
if (method == null && member is IMethod && ((IMethod)member).IsMethod)
{
method = ((IMethod)member).ResolveMethodDef();
}
if (method != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
}
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
}
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
}
public bool IsEnabled(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return(context.Reference != null && context.Reference.Reference is MemberReference);
}
foreach (IMemberTreeNode node in context.SelectedTreeNodes)
{
if (!(node.Member is TypeDefinition ||
node.Member is FieldDefinition ||
node.Member is MethodDefinition ||
AnalyzedPropertyTreeNode.CanShow(node.Member) ||
AnalyzedEventTreeNode.CanShow(node.Member)))
{
return(false);
}
}
return(true);
}
private IEnumerable<AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
if (analyzedType.IsEnum && type == analyzedType)
yield break;
if (!this.Language.ShowMember(type))
yield break;
foreach (FieldDefinition field in type.Fields) {
if (TypeIsExposedBy(field)) {
var node = new AnalyzedFieldTreeNode(field);
node.Language = this.Language;
yield return node;
}
}
foreach (PropertyDefinition property in type.Properties) {
if (TypeIsExposedBy(property)) {
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return node;
}
}
foreach (EventDefinition eventDef in type.Events) {
if (TypeIsExposedBy(eventDef)) {
var node = new AnalyzedEventTreeNode(eventDef);
node.Language = this.Language;
yield return node;
}
}
foreach (MethodDefinition method in type.Methods) {
if (TypeIsExposedBy(method)) {
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return node;
}
}
}
private IEnumerable <AnalyzerTreeNode> 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))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
yield break;
}
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 => new SigComparer(SigComparerOptions.CompareDeclaringTypes | SigComparerOptions.PrivateScopeIsComparable).Equals(m.MethodDeclaration, analyzedMethod)))
{
var node = new AnalyzedEventTreeNode(ev);
node.Language = this.Language;
yield return(node);
}
}
}
public static void Analyze(IMemberRef member)
{
var memberDef = MainWindow.ResolveReference(member) as IMemberDef;
var type = memberDef as TypeDef;
if (type != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedTypeTreeNode(type));
}
var field = memberDef as FieldDef;
if (field != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedFieldTreeNode(field));
}
var method = memberDef as MethodDef;
if (method != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(new AnalyzedMethodTreeNode(method));
}
var propertyAnalyzer = AnalyzedPropertyTreeNode.TryCreateAnalyzer(member);
if (propertyAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(propertyAnalyzer);
}
var eventAnalyzer = AnalyzedEventTreeNode.TryCreateAnalyzer(member);
if (eventAnalyzer != null)
{
AnalyzerTreeView.Instance.ShowOrFocus(eventAnalyzer);
}
}
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> FindReferencesWithinInType(TypeDef type, ITypeDefOrRef attrTypeRef)
{
bool searchRequired = (type.IsClass && usage.HasFlag(AttributeTargets.Class)) ||
(type.IsEnum && usage.HasFlag(AttributeTargets.Enum)) ||
(type.IsInterface && usage.HasFlag(AttributeTargets.Interface)) ||
(Decompiler.DnlibExtensions.IsValueType(type) && usage.HasFlag(AttributeTargets.Struct));
if (searchRequired)
{
if (type.HasCustomAttributes)
{
foreach (var attribute in type.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
var node = new AnalyzedTypeTreeNode(type);
node.Language = this.Language;
yield return(node);
break;
}
}
}
}
if ((this.usage & AttributeTargets.GenericParameter) != 0 && type.HasGenericParameters)
{
foreach (var parameter in type.GenericParameters)
{
if (parameter.HasCustomAttributes)
{
foreach (var attribute in parameter.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
var node = new AnalyzedTypeTreeNode(type);
node.Language = this.Language;
yield return(node);
break;
}
}
}
}
}
if ((this.usage & AttributeTargets.Field) != 0 && type.HasFields)
{
foreach (var field in type.Fields)
{
if (field.HasCustomAttributes)
{
foreach (var attribute in field.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
var node = new AnalyzedFieldTreeNode(field);
node.Language = this.Language;
yield return(node);
break;
}
}
}
}
}
if (((usage & AttributeTargets.Property) != 0) && type.HasProperties)
{
foreach (var property in type.Properties)
{
if (property.HasCustomAttributes)
{
foreach (var attribute in property.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return(node);
break;
}
}
}
}
}
if (((usage & AttributeTargets.Event) != 0) && type.HasEvents)
{
foreach (var _event in type.Events)
{
if (_event.HasCustomAttributes)
{
foreach (var attribute in _event.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
var node = new AnalyzedEventTreeNode(_event);
node.Language = this.Language;
yield return(node);
break;
}
}
}
}
}
if (type.HasMethods)
{
foreach (var method in type.Methods)
{
bool found = false;
if ((usage & (AttributeTargets.Method | AttributeTargets.Constructor)) != 0)
{
if (method.HasCustomAttributes)
{
foreach (var attribute in method.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
found = true;
break;
}
}
}
}
if (!found &&
((usage & AttributeTargets.ReturnValue) != 0) &&
method.Parameters.ReturnParameter.HasParamDef &&
method.Parameters.ReturnParameter.ParamDef.HasCustomAttributes)
{
foreach (var attribute in method.Parameters.ReturnParameter.ParamDef.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
found = true;
break;
}
}
}
if (!found &&
((usage & AttributeTargets.Parameter) != 0) &&
method.Parameters.Count > 0)
{
foreach (var parameter in method.Parameters.Where(param => param.HasParamDef))
{
if (parameter.IsHiddenThisParameter)
{
continue;
}
foreach (var attribute in parameter.ParamDef.CustomAttributes)
{
if (new SigComparer().Equals(attribute.AttributeType, attrTypeRef))
{
found = true;
break;
}
}
}
}
if (found)
{
MethodDef codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDef;
if (codeLocation != null && !HasAlreadyBeenFound(codeLocation))
{
var node = new AnalyzedMethodTreeNode(codeLocation);
node.Language = this.Language;
yield return(node);
}
}
}
}
}
private IEnumerable<AnalyzerTreeNode> FindReferencesWithinInType(TypeDefinition type, TypeReference attrTypeRef)
{
bool searchRequired = (type.IsClass && usage.HasFlag(AttributeTargets.Class))
|| (type.IsEnum && usage.HasFlag(AttributeTargets.Enum))
|| (type.IsInterface && usage.HasFlag(AttributeTargets.Interface))
|| (type.IsValueType && usage.HasFlag(AttributeTargets.Struct));
if (searchRequired) {
if (type.HasCustomAttributes) {
foreach (var attribute in type.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
var node = new AnalyzedTypeTreeNode(type);
node.Language = this.Language;
yield return node;
break;
}
}
}
}
if ((this.usage & AttributeTargets.GenericParameter) != 0 && type.HasGenericParameters) {
foreach (var parameter in type.GenericParameters) {
if (parameter.HasCustomAttributes) {
foreach (var attribute in parameter.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
var node = new AnalyzedTypeTreeNode(type);
node.Language = this.Language;
yield return node;
break;
}
}
}
}
}
if ((this.usage & AttributeTargets.Field) != 0 && type.HasFields) {
foreach (var field in type.Fields) {
if (field.HasCustomAttributes) {
foreach (var attribute in field.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
var node = new AnalyzedFieldTreeNode(field);
node.Language = this.Language;
yield return node;
break;
}
}
}
}
}
if (((usage & AttributeTargets.Property) != 0) && type.HasProperties) {
foreach (var property in type.Properties) {
if (property.HasCustomAttributes) {
foreach (var attribute in property.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
var node = new AnalyzedPropertyTreeNode(property);
node.Language = this.Language;
yield return node;
break;
}
}
}
}
}
if (((usage & AttributeTargets.Event) != 0) && type.HasEvents) {
foreach (var _event in type.Events) {
if (_event.HasCustomAttributes) {
foreach (var attribute in _event.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
var node = new AnalyzedEventTreeNode(_event);
node.Language = this.Language;
yield return node;
break;
}
}
}
}
}
if (type.HasMethods) {
foreach (var method in type.Methods) {
bool found = false;
if ((usage & (AttributeTargets.Method | AttributeTargets.Constructor)) != 0) {
if (method.HasCustomAttributes) {
foreach (var attribute in method.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
found = true;
break;
}
}
}
}
if (!found &&
((usage & AttributeTargets.ReturnValue) != 0) &&
method.MethodReturnType.HasCustomAttributes) {
foreach (var attribute in method.MethodReturnType.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
found = true;
break;
}
}
}
if (!found &&
((usage & AttributeTargets.Parameter) != 0) &&
method.HasParameters) {
foreach (var parameter in method.Parameters) {
foreach (var attribute in parameter.CustomAttributes) {
if (attribute.AttributeType == attrTypeRef) {
found = true;
break;
}
}
}
}
if (found) {
MethodDefinition codeLocation = this.Language.GetOriginalCodeLocation(method) as MethodDefinition;
if (codeLocation != null && !HasAlreadyBeenFound(codeLocation)) {
var node = new AnalyzedMethodTreeNode(codeLocation);
node.Language = this.Language;
yield return node;
}
}
}
}
}
