private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
AnalyzerTreeNode newNode = null;
try {
if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false))
{
yield break;
}
foreach (MethodDefinition method in type.Methods)
{
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)
{
newNode.Language = this.Language;
yield return(newNode);
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!type.HasInterfaces)
{
yield break;
}
TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.InterfaceType.Resolve() == analyzedMethod.DeclaringType)?.InterfaceType;
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);
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
string name = analyzedMethod.Name;
foreach (MethodDefinition method in type.Methods)
{
bool found = false;
string prefix = string.Empty;
if (!method.HasBody)
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
MethodReference mr = instr.Operand as MethodReference;
if (mr != null && mr.Name == name)
{
// explicit call to the requested method
if (instr.OpCode.Code == Code.Call &&
Helpers.IsReferencedBy(analyzedMethod.DeclaringType, mr.DeclaringType) &&
mr.Resolve() == analyzedMethod)
{
found = true;
prefix = "(as base) ";
break;
}
// virtual call to base method
if (instr.OpCode.Code == Code.Callvirt)
{
MethodDefinition md = mr.Resolve();
if (md == null)
{
// cannot resolve the operand, so ignore this method
break;
}
if (md == baseMethod)
{
found = true;
break;
}
}
}
}
method.Body = null;
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);
}
}
}
}
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(TypeDefinition type)
{
// HACK: in lieu of proper flow analysis, I'm going to use a simple heuristic
// If the method accesses the event's backing field, and calls invoke on a delegate
// with the same signature, then it is (most likely) raise the given event.
foreach (MethodDefinition method in type.Methods)
{
bool readBackingField = false;
bool found = false;
if (!method.HasBody)
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
Code code = instr.OpCode.Code;
if (code == Code.Ldfld || code == Code.Ldflda)
{
FieldReference fr = instr.Operand as FieldReference;
if (fr != null && fr.Name == eventBackingField.Name && fr == eventBackingField)
{
readBackingField = true;
}
}
if (readBackingField && (code == Code.Callvirt || code == Code.Call))
{
MethodReference mr = instr.Operand as MethodReference;
if (mr != null && mr.Name == eventFiringMethod.Name && mr.Resolve() == eventFiringMethod)
{
found = true;
break;
}
}
}
method.Body = null;
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);
}
}
}
}
protected override IEnumerable <AnalyzerTreeNode> FetchChildren(CancellationToken ct)
{
foreach (var f in GetUsedFields().Distinct())
{
var node = new AnalyzedFieldTreeNode(f);
node.Language = this.Language;
yield return(node);
}
foreach (var m in GetUsedMethods().Distinct())
{
var node = new AnalyzedMethodTreeNode(m);
node.Language = this.Language;
yield return(node);
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
if (!HasExtensionAttribute(type))
{
yield break;
}
foreach (MethodDefinition method in type.Methods)
{
if (method.IsStatic && HasExtensionAttribute(method))
{
if (method.HasParameters && method.Parameters[0].ParameterType.Resolve() == analyzedType)
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
}
private IEnumerable <AnalyzerTreeNode> 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)
{
var node = new AnalyzedMethodTreeNode(method);
node.Language = this.Language;
yield return(node);
}
}
}
private IEnumerable <AnalyzerTreeNode> FindReferencesInType(TypeDefinition type)
{
string name = analyzedField.Name;
foreach (MethodDefinition method in type.Methods)
{
bool found = false;
if (!method.HasBody)
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
if (CanBeReference(instr.OpCode.Code))
{
FieldReference fr = instr.Operand as FieldReference;
if (fr != null && fr.Name == name &&
Helpers.IsReferencedBy(analyzedField.DeclaringType, fr.DeclaringType) &&
fr.Resolve() == analyzedField)
{
found = true;
break;
}
}
}
method.Body = null;
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);
}
}
}
}
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);
}
}
}
}
}
