protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
foundMethods = new Lazy <Hashtable>(LazyThreadSafetyMode.ExecutionAndPublication);
var includeAllModules = showWrites && CustomAttributesUtils.IsPseudoCustomAttributeType(analyzedField.DeclaringType);
var analyzer = new ScopedWhereUsedAnalyzer <AnalyzerTreeNodeData>(Context.DocumentService, analyzedField, FindReferencesInType, includeAllModules);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
foundMethods = null;
if (showWrites)
{
var hash = new HashSet <AssemblyDef>();
foreach (var module in analyzer.AllModules)
{
if (module.Assembly is AssemblyDef asm && hash.Add(asm))
{
foreach (var node in CheckCustomAttributeNamedArgumentWrite(Context, asm, analyzedField))
{
yield return(node);
}
}
foreach (var node in CheckCustomAttributeNamedArgumentWrite(Context, module, analyzedField))
{
yield return(node);
}
}
}
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.FileManager, analyzedType, FindTypeUsage);
return(analyzer.PerformAnalysis(ct)
.Cast <EntityNode>()
.Where(n => n.Member.DeclaringType != analyzedType)
.Distinct(new AnalyzerEntityTreeNodeComparer()));
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
if (analyzedMethod == null)
{
return(new List <IAnalyzerTreeNodeData>());
}
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.FileManager, analyzedMethod, FindReferencesInType);
return(analyzer.PerformAnalysis(ct));
}
protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
foundMethods = new Lazy <Hashtable>(LazyThreadSafetyMode.ExecutionAndPublication);
var analyzer = new ScopedWhereUsedAnalyzer <AnalyzerTreeNodeData>(Context.DocumentService, analyzedField, FindReferencesInType);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
foundMethods = null;
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
InitializeAnalyzer();
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.FileManager, analyzedMethod, FindReferencesInType);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
ReleaseAnalyzer();
}
protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
if (analyzedMethod == null)
{
yield break;
}
var analyzer = new ScopedWhereUsedAnalyzer <AnalyzerTreeNodeData>(Context.DocumentService, analyzedMethod, FindReferencesInType);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
foundMethods = new ConcurrentDictionary <MethodDef, int>();
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.FileManager, analyzedMethod, FindReferencesInType);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
foundMethods = null;
}
protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
InitializeAnalyzer();
if (isSetter)
{
property = analyzedMethod.DeclaringType.Properties.FirstOrDefault(a => a.SetMethod == analyzedMethod);
}
var includeAllModules = !(property is null) && CustomAttributesUtils.IsPseudoCustomAttributeType(analyzedMethod.DeclaringType);
ComUtils.GetMemberInfo(analyzedMethod, out isComType, out comGuid, out vtblIndex);
includeAllModules |= isComType;
var options = ScopedWhereUsedAnalyzerOptions.None;
if (includeAllModules)
{
options |= ScopedWhereUsedAnalyzerOptions.IncludeAllModules;
}
if (isComType)
{
options |= ScopedWhereUsedAnalyzerOptions.ForcePublic;
}
var analyzer = new ScopedWhereUsedAnalyzer <AnalyzerTreeNodeData>(Context.DocumentService, analyzedMethod, FindReferencesInType, options);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
if (!(property is null))
{
var hash = new HashSet <AssemblyDef>();
foreach (var module in analyzer.AllModules)
{
if (module.Assembly is AssemblyDef asm && hash.Add(module.Assembly))
{
foreach (var node in FieldAccessNode.CheckCustomAttributeNamedArgumentWrite(Context, asm, property))
{
yield return(node);
}
}
foreach (var node in FieldAccessNode.CheckCustomAttributeNamedArgumentWrite(Context, module, property))
{
yield return(node);
}
}
}
ReleaseAnalyzer();
}
protected override IEnumerable <AnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
foundMethods = new ConcurrentDictionary <MethodDef, int>();
if (isSetter)
{
property = analyzedMethod.DeclaringType.Properties.FirstOrDefault(a => a.SetMethod == analyzedMethod);
}
var includeAllModules = (property is not null && CustomAttributesUtils.IsPseudoCustomAttributeType(analyzedMethod.DeclaringType)) || implMapName is not null;
var options = ScopedWhereUsedAnalyzerOptions.None;
if (includeAllModules)
{
options |= ScopedWhereUsedAnalyzerOptions.IncludeAllModules;
}
if (implMapName is not null)
{
options |= ScopedWhereUsedAnalyzerOptions.ForcePublic;
}
var analyzer = new ScopedWhereUsedAnalyzer <AnalyzerTreeNodeData>(Context.DocumentService, analyzedMethod, FindReferencesInType, options);
foreach (var child in analyzer.PerformAnalysis(ct))
{
yield return(child);
}
if (property is not null)
{
var hash = new HashSet <AssemblyDef>();
foreach (var module in analyzer.AllModules)
{
if (module.Assembly is AssemblyDef asm && hash.Add(asm))
{
foreach (var node in FieldAccessNode.CheckCustomAttributeNamedArgumentWrite(Context, asm, property))
{
yield return(node);
}
}
foreach (var node in FieldAccessNode.CheckCustomAttributeNamedArgumentWrite(Context, module, property))
{
yield return(node);
}
}
}
foundMethods = null;
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.DocumentService, analyzedEvent, FindReferencesInType);
return(analyzer.PerformAnalysis(ct));
}
protected override IEnumerable <IAnalyzerTreeNodeData> FetchChildren(CancellationToken ct)
{
var analyzer = new ScopedWhereUsedAnalyzer <IAnalyzerTreeNodeData>(Context.FileManager, analyzedProperty, FindReferencesInType);
return(analyzer.PerformAnalysis(ct));
}
