private static ImmutableArray <ISymbol> GetMembers(
INamespaceOrTypeSymbol container,
string qualifiedName,
out INamespaceOrTypeSymbol lastContainer
)
{
var parts = SplitMemberName(qualifiedName);
lastContainer = container;
for (int i = 0; i < parts.Length - 1; i++)
{
var nestedContainer = (INamespaceOrTypeSymbol)lastContainer.GetMember(parts[i]);
if (nestedContainer == null)
{
// If there wasn't a nested namespace or type with that name, assume it's a
// member name that includes dots (e.g. explicit interface implementation).
return(lastContainer.GetMembers(string.Join(".", parts.Skip(i))));
}
else
{
lastContainer = nestedContainer;
}
}
return(lastContainer.GetMembers(parts[parts.Length - 1]));
}
private void dfs_through_members(TreeNodeCollection treenode, INamespaceOrTypeSymbol symbol)
{
if (symbol != null && symbol.GetMembers() != null)
foreach (var el in symbol.GetMembers()) {
var cur = el as INamespaceOrTypeSymbol;
if (cur != null) {
treenode.Add(cur.Name.ToString());
dfs_through_members(treenode[treenode.Count - 1].Nodes, cur);
}
}
}
private void Bind(
int index, INamespaceOrTypeSymbol rootContainer, ArrayBuilder <ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[index];
if (node.IsRoot)
{
return;
}
if (_nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(GetName(node)));
}
else
{
using var _ = ArrayBuilder <ISymbol> .GetInstance(out var containerSymbols);
Bind(node.ParentIndex, rootContainer, containerSymbols, cancellationToken);
foreach (var containerSymbol in containerSymbols)
{
cancellationToken.ThrowIfCancellationRequested();
if (containerSymbol is INamespaceOrTypeSymbol nsOrType)
{
results.AddRange(nsOrType.GetMembers(GetName(node)));
}
}
}
}
private void Visit(INamespaceOrTypeSymbol type)
{
foreach (var method in type.GetMembers().OfType <IMethodSymbol>())
{
Visit(method);
}
}
static void AddInheritedMembers(
ITypeSymbol symbol,
INamespaceOrTypeSymbol type,
Dictionary <string, string?> dict,
IReadOnlyList <string> typeParameterNames,
IApiFilter apiFilter
)
{
foreach (var m in type.GetMembers()
.Where(m => !(m is INamedTypeSymbol))
.Where(
m => apiFilter.CanVisitApi(
m,
symbol.Equals(type) ||
!symbol.IsSealed ||
symbol.TypeKind != TypeKind.Struct
)
)
.Where(x => x.IsInheritable()))
{
var id = symbol.ToString()?.Trim();
if (id != null)
{
dict.TryAdd(id, type.Equals(symbol) ? null : m.ToDisplayString());
}
}
}
private void VisitNamespaceOrType(INamespaceOrTypeSymbol symbol)
{
foreach (ISymbol member in symbol.GetMembers())
{
Visit(member);
}
}
// returns all the symbols in the container corresponding to the node
private void Bind(int index, INamespaceOrTypeSymbol rootContainer, List <ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = this.nodes[index];
if (this.nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(node.Name));
}
else
{
var containerSymbols = SharedPools.Default <List <ISymbol> >().AllocateAndClear();
try
{
Bind(node.ParentIndex, rootContainer, containerSymbols, cancellationToken);
foreach (var containerSymbol in containerSymbols.OfType <INamespaceOrTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
results.AddRange(containerSymbol.GetMembers(node.Name));
}
}
finally
{
SharedPools.Default <List <ISymbol> >().ClearAndFree(containerSymbols);
}
}
}
private static IEnumerable <(ISymbol Original, string NewName)> GetSymbolsWithNewNames(INamespaceOrTypeSymbol containerSymbol, Compilation compilation)
{
var members = containerSymbol.GetMembers();
var symbolSets = GetLocalSymbolSets(containerSymbol, compilation, members).Concat(members.AsEnumerable().Yield());
return(symbolSets.SelectMany(GetUniqueNamesForSymbolSet));
}
private static void GetSourceMemberSymbols(INamespaceOrTypeSymbol symbol, List <ISymbol> list, LocalSymbolDumper localDumper)
{
foreach (var memberSymbol in symbol.GetMembers())
{
list.Add(memberSymbol);
switch (memberSymbol.Kind)
{
case SymbolKind.NamedType:
case SymbolKind.Namespace:
GetSourceMemberSymbols((INamespaceOrTypeSymbol)memberSymbol, list, localDumper);
break;
case SymbolKind.Method:
var method = (IMethodSymbol)memberSymbol;
foreach (var parameter in method.Parameters)
{
list.Add(parameter);
}
localDumper?.GetLocalSymbols(method.GetSymbol(), list);
break;
case SymbolKind.Field:
localDumper?.GetLocalSymbols(memberSymbol.GetSymbol <FieldSymbol>(), list);
break;
}
}
}
private void AddNodeIfNotExists(INamespaceOrTypeSymbol namedType, IntertypeRelationGraph graph, List <INamedTypeSymbol> typeSymbols)
{
if (namedType == null)
{
return;
}
if (namedType.IsType)
{
typeSymbols.Add((INamedTypeSymbol)namedType);
var typeName = GetTypeIdentifier(namedType);
if (!graph.Nodes.Contains(typeName))
{
graph.Nodes.Add(typeName);
}
}
else
{
foreach (var type in namedType.GetMembers())
{
AddNodeIfNotExists(type as INamespaceOrTypeSymbol, graph, typeSymbols);
}
}
}
protected void ProcessChildren(INamespaceOrTypeSymbol namespaceOrTypeSymbol, PolicyConfig policyConfig, IViolationReporter violationReporter)
{
foreach (ISymbol childSymbol in namespaceOrTypeSymbol.GetMembers())
{
new CodeCommentsFacade().GetSymbolProcessorFactory().CreateSymbolProcessor(childSymbol).Process(childSymbol, policyConfig, violationReporter);
}
}
private void VisitMembers(INamespaceOrTypeSymbol symbol)
{
foreach (var member in symbol.GetMembers())
{
member.Accept(this);
}
}
private static IEnumerable <ITypeSymbol> GetAwaitableTypes(INamespaceOrTypeSymbol namespaceOrTypeSymbol)
{
if (namespaceOrTypeSymbol == null || !namespaceOrTypeSymbol.DeclaredAccessibility.HasFlag(Accessibility.Public))
{
yield break;
}
foreach (var member in namespaceOrTypeSymbol.GetMembers())
{
switch (member)
{
case INamespaceOrTypeSymbol nsOrType:
foreach (var nested in GetAwaitableTypes(nsOrType))
{
yield return(nested);
}
break;
case IMethodSymbol method:
if (method.DeclaredAccessibility.HasFlag(Accessibility.Public) &&
method.IsExtensionMethod &&
method.Name == GetAwaiterMethodName &&
!method.Parameters.IsEmpty &&
ConformsToAwaiterPattern(method.ReturnType))
{
yield return(method.Parameters[0].Type);
}
break;
}
}
}
// returns all the symbols in the container corresponding to the node
private void Bind(int index, INamespaceOrTypeSymbol rootContainer, List <ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[index];
if (node.IsRoot)
{
return;
}
if (_nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(node.Name));
}
else
{
using (var containerSymbols = SharedPools.Default <List <ISymbol> >().GetPooledObject())
{
Bind(node.ParentIndex, rootContainer, containerSymbols.Object, cancellationToken);
foreach (var containerSymbol in containerSymbols.Object.OfType <INamespaceOrTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
results.AddRange(containerSymbol.GetMembers(node.Name));
}
}
}
}
private static IEnumerable <(ISymbol Original, string NewName)> GetSymbolsWithNewNames(INamespaceOrTypeSymbol containerSymbol, Compilation compilation)
{
var members = containerSymbol.GetMembers().Where(m => m.Locations.Any(loc => compilation.ContainsSyntaxTree(loc.SourceTree))).ToArray();
var symbolSets = GetLocalSymbolSets(containerSymbol, compilation, members).Concat(members.AsEnumerable().Yield());
return(symbolSets.SelectMany(GetUniqueNamesForSymbolSet));
}
public static IEnumerable <INamespaceOrTypeSymbol> EnumAllNamespaces(this INamespaceOrTypeSymbol source)
{
yield return(source);
foreach (var namespaceSymbolSub in source.GetMembers().OfType <INamespaceOrTypeSymbol>().SelectMany(EnumAllNamespaces))
{
yield return(namespaceSymbolSub);
}
}
private static IEnumerable <MappingInfo> AnalyzeModule(SemanticModel semanticModel,
INamespaceOrTypeSymbol moduleToAnalyze)
{
var loadMethods = moduleToAnalyze.GetMembers(ExternalLibraryInformation.Module.Load.Name)
.OfType <IMethodSymbol>()
.Where(loadMethod => loadMethod.Parameters.IsEmpty);
return(AnalyzeLoadMethods(semanticModel, loadMethods));
}
internal static async Task <ImmutableArray <UnusedSymbolInfo> > FindUnusedSymbolsAsync(
Project project,
Compilation compilation,
Func <ISymbol, bool> predicate = null,
IImmutableSet <ISymbol> ignoredSymbols = null,
IImmutableSet <Document> documents = null,
CancellationToken cancellationToken = default)
{
ImmutableArray <UnusedSymbolInfo> .Builder unusedSymbols = null;
var namespaceOrTypeSymbols = new Stack <INamespaceOrTypeSymbol>();
namespaceOrTypeSymbols.Push(compilation.Assembly.GlobalNamespace);
while (namespaceOrTypeSymbols.Count > 0)
{
INamespaceOrTypeSymbol namespaceOrTypeSymbol = namespaceOrTypeSymbols.Pop();
foreach (ISymbol symbol in namespaceOrTypeSymbol.GetMembers())
{
bool isUnused = false;
if (symbol.Kind != SymbolKind.Namespace &&
!symbol.IsImplicitlyDeclared &&
!symbol.IsOverride &&
(predicate == null || predicate(symbol)) &&
IsAnalyzable(symbol) &&
ignoredSymbols?.Contains(symbol) != true)
{
isUnused = await IsUnusedSymbolAsync(symbol, project.Solution, documents, cancellationToken).ConfigureAwait(false);
if (isUnused)
{
string id = symbol.GetDocumentationCommentId();
WriteLine($" {GetUnusedSymbolKind(symbol).ToString()} {symbol.ToDisplayString()}", ConsoleColor.Yellow, Verbosity.Normal);
WriteLine($" {symbol.GetSyntax(cancellationToken).SyntaxTree.FilePath}", ConsoleColor.DarkGray, Verbosity.Detailed);
WriteLine($" {id}", ConsoleColor.DarkGray, Verbosity.Diagnostic);
var unusedSymbolInfo = new UnusedSymbolInfo(symbol, id, project.Id);
(unusedSymbols ?? (unusedSymbols = ImmutableArray.CreateBuilder <UnusedSymbolInfo>())).Add(unusedSymbolInfo);
}
}
if (!isUnused &&
symbol is INamespaceOrTypeSymbol namespaceOrTypeSymbol2)
{
namespaceOrTypeSymbols.Push(namespaceOrTypeSymbol2);
}
}
}
return(unusedSymbols?.ToImmutableArray() ?? ImmutableArray <UnusedSymbolInfo> .Empty);
}
private IEnumerable <ISymbol> GetMembers(ISymbol parent)
{
INamespaceOrTypeSymbol container = parent as INamespaceOrTypeSymbol;
if (container != null)
{
return(container.GetMembers().AsEnumerable());
}
return(Enumerable.Empty <ISymbol>());
}
private void GetDeclaredSymbols(INamespaceOrTypeSymbol container, List <ISymbol> symbols)
{
foreach (var member in container.GetMembers())
{
symbols.Add(member);
if (member is INamespaceOrTypeSymbol nsOrType)
{
GetDeclaredSymbols(nsOrType, symbols);
}
}
}
private static void GetMatchingNamespaces(INamespaceOrTypeSymbol container, string memberName, List <ISymbol> results)
{
var members = container.GetMembers(memberName);
foreach (var symbol in members)
{
if (symbol.Kind == SymbolKind.Namespace)
{
results.Add(symbol);
}
}
}
public static IEnumerable <INamedTypeSymbol> GetNamedTypes(this INamespaceOrTypeSymbol sym)
{
if (sym is INamedTypeSymbol type)
{
yield return(type);
}
foreach (var child in sym.GetMembers().OfType <INamespaceOrTypeSymbol>().SelectMany(GetNamedTypes))
{
yield return(child);
}
}
private static IEnumerable <(ISymbol Original, string NewName)> GetSymbolsWithNewNames(INamespaceOrTypeSymbol containerSymbol)
{
var members = containerSymbol.GetMembers();
//TODO If container is a type, call GetCsLocalSymbolDeclarations and rename those too - see test called CaseConflict_LocalWithLocal
var membersByCaseInsensitiveName = members.ToLookup(m => m.Name, m => m, StringComparer.OrdinalIgnoreCase);
var names = new HashSet <string>(membersByCaseInsensitiveName.Select(ms => ms.Key),
StringComparer.OrdinalIgnoreCase);
var symbolsWithNewNames = membersByCaseInsensitiveName.Where(ms => ms.Count() > 1)
.SelectMany(symbolGroup => GetSymbolsWithNewNames(symbolGroup.ToArray(), names));
return(symbolsWithNewNames);
}
private static IEnumerable <ISymbol> GetApiAffectingMembers(INamespaceOrTypeSymbol symbol)
{
if (symbol == null || NoMembersAffectApi(symbol))
{
return(Enumerable.Empty <ISymbol>());
}
return(from member in symbol.GetMembers()
let methodKind = (member as IMethodSymbol)?.MethodKind
where methodKind != MethodKind.PropertyGet && methodKind != MethodKind.PropertySet
where methodKind != MethodKind.EventAdd && methodKind != MethodKind.EventRemove
where methodKind != MethodKind.Constructor || ((ITypeSymbol)symbol).TypeKind != TypeKind.Enum
select member);
}
private static string GetMessage(INamespaceOrTypeSymbol namedType, SymbolAnalysisContext analysisContext)
{
var disposableFields = namedType.GetMembers()
.OfType <IFieldSymbol>()
.Where(fs => fs.IsNonStaticNonPublicDisposableField(analysisContext.Compilation.GetLanguageVersion()))
.ToHashSet();
if (disposableFields.Count == 0)
{
return(string.Empty);
}
var otherInitializationsOfFields = namedType.GetMembers()
.OfType <IMethodSymbol>()
.SelectMany(m => GetAssignmentsToFieldsIn(m, analysisContext.Compilation))
.Where(f => disposableFields.Contains(f));
return(string.Join(", ", disposableFields.Where(IsOwnerSinceDeclaration)
.Union(otherInitializationsOfFields)
.Distinct()
.Select(symbol => $"'{symbol.Name}'")
.OrderBy(name => name)));
}
private static IEnumerable <(ISymbol Original, string NewName)> GetSymbolsWithNewNames(INamespaceOrTypeSymbol containerSymbol, Compilation compilation)
{
if (containerSymbol.IsNamespace)
{
return(Enumerable.Empty <(ISymbol Original, string NewName)>());
}
var members = containerSymbol.GetMembers()
.Where(m => m.Locations.Any(loc => loc.SourceTree != null && compilation.ContainsSyntaxTree(loc.SourceTree)))
.Where(s => containerSymbol.Name == s.Name || containerSymbol is INamedTypeSymbol nt && nt.IsEnumType() && SymbolRenamer.GetName(s).StartsWith(containerSymbol.Name, StringComparison.InvariantCulture));
var symbolSet = containerSymbol.Yield().Concat(members).ToArray();
return(SymbolRenamer.GetSymbolsWithNewNames(symbolSet, new HashSet <string>(symbolSet.Select(SymbolRenamer.GetName)), true));
}
private ITypeSymbol ResolveType(SemanticModel semanticModel, Type type)
{
string[] names = type.FullName.Split(new[] { '.', '+' }, StringSplitOptions.RemoveEmptyEntries);
INamespaceOrTypeSymbol scope = null;
for (int i = 0; i != names.Count(); ++i)
{
string metadataName = names[i];
string name = metadataName;
int index = name.IndexOf('`');
int numberOfGenericTypes = 0;
if (index != -1)
{
string sNumber = name.Substring(index + 1);
if (!int.TryParse(sNumber, out numberOfGenericTypes))
{
return(null);
}
name = name.Substring(0, index);
}
IEnumerable <ISymbol> symbols;
if (i == 0)
{
symbols = semanticModel.LookupNamespacesAndTypes(0, scope, name);
}
else
{
symbols = scope.GetMembers(name).Where(m => m.Kind == SymbolKind.Namespace || m.Kind == SymbolKind.NamedType);
}
if (numberOfGenericTypes != 0)
{
symbols = symbols.Where(s => s.MetadataName == metadataName);
}
if (symbols.Count() == 1)
{
scope = (INamespaceOrTypeSymbol)symbols.First();
}
else
{
scope = null;
break;
}
}
return((ITypeSymbol)scope);
}
private void GetAllTypes(List <INamedTypeSymbol> items, INamespaceOrTypeSymbol symbol)
{
if (symbol is INamedTypeSymbol typeSymbol)
{
items.Add(typeSymbol);
}
foreach (var member in symbol.GetMembers())
{
if (member is INamespaceOrTypeSymbol child)
{
GetAllTypes(items, child);
}
}
}
static void doGetTypes(List <INamedTypeSymbol> list, INamespaceOrTypeSymbol symbol)
{
if (symbol is INamedTypeSymbol type && IsSerializable(type))
{
list.Add(type);
}
foreach (ISymbol child in symbol.GetMembers())
{
if (child is INamespaceOrTypeSymbol namespaceOrType)
{
doGetTypes(list, namespaceOrType);
}
}
}
private void GetAllTypes(List <INamedTypeSymbol> result, INamespaceOrTypeSymbol symbol)
{
if (symbol is INamedTypeSymbol type)
{
result.Add(type);
}
foreach (var child in symbol.GetMembers())
{
if (child is INamespaceOrTypeSymbol nsChild)
{
GetAllTypes(result, nsChild);
}
}
}
private static void GetMatchingTypes(INamespaceOrTypeSymbol container, string memberName, int arity, List <ISymbol> results)
{
var members = container.GetMembers(memberName);
foreach (var symbol in members)
{
if (symbol.Kind == SymbolKind.NamedType)
{
var namedType = (INamedTypeSymbol)symbol;
if (namedType.Arity == arity)
{
results.Add(namedType);
}
}
}
}
// returns all the symbols in the container corresponding to the node
private void Bind(
int index, INamespaceOrTypeSymbol rootContainer, ArrayBuilder<ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[index];
if (node.IsRoot)
{
return;
}
if (_nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(GetName(node)));
}
else
{
var containerSymbols = ArrayBuilder<ISymbol>.GetInstance();
try
{
Bind(node.ParentIndex, rootContainer, containerSymbols, cancellationToken);
foreach (var containerSymbol in containerSymbols)
{
cancellationToken.ThrowIfCancellationRequested();
var nsOrType = containerSymbol as INamespaceOrTypeSymbol;
if (nsOrType != null)
{
results.AddRange(nsOrType.GetMembers(GetName(node)));
}
}
}
finally
{
containerSymbols.Free();
}
}
}
// returns all the symbols in the container corresponding to the node
private void Bind(int index, INamespaceOrTypeSymbol rootContainer, List<ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[index];
if (_nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(node.Name));
}
else
{
using (var containerSymbols = SharedPools.Default<List<ISymbol>>().GetPooledObject())
{
Bind(node.ParentIndex, rootContainer, containerSymbols.Object, cancellationToken);
foreach (var containerSymbol in containerSymbols.Object.OfType<INamespaceOrTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
results.AddRange(containerSymbol.GetMembers(node.Name));
}
}
}
}
private void dfs_through_members_build_name(String name, INamespaceOrTypeSymbol symbol)
{
if (symbol != null && symbol.GetMembers() != null)
foreach (var el in symbol.GetMembers())
{
var cur = el as INamespaceOrTypeSymbol;
if (cur != null)
{
var cur_name = name + "." + cur.Name.ToString();
current_names.Add(cur_name);
dfs_through_members_build_name(cur_name, cur);
}
}
}
// returns all the symbols in the container corresponding to the node
private void Bind(int index, INamespaceOrTypeSymbol rootContainer, List<ISymbol> results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var node = this.nodes[index];
if (this.nodes[node.ParentIndex].IsRoot)
{
results.AddRange(rootContainer.GetMembers(node.Name));
}
else
{
var containerSymbols = SharedPools.Default<List<ISymbol>>().AllocateAndClear();
try
{
Bind(node.ParentIndex, rootContainer, containerSymbols, cancellationToken);
foreach (var containerSymbol in containerSymbols.OfType<INamespaceOrTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
results.AddRange(containerSymbol.GetMembers(node.Name));
}
}
finally
{
SharedPools.Default<List<ISymbol>>().ClearAndFree(containerSymbols);
}
}
}
private static void dfs(Solution solution, Compilation compilation, INamespaceOrTypeSymbol v)
{
if (v == null) return;
foreach (var cur in v.GetMembers())
{
var to = cur as INamespaceOrTypeSymbol;
if (to != null)
{
var toAsType = to as ITypeSymbol;
if (toAsType != null)
{
if (toAsType.BaseType != null)
{
if (!_cacheTypesHierarchy[compilation].ContainsKey(toAsType.BaseType))
_cacheTypesHierarchy[compilation].Add(toAsType.BaseType, new HashSet<ITypeSymbol>());
_cacheTypesHierarchy[compilation][toAsType.BaseType].Add(toAsType);
}
}
dfs(solution, compilation, to);
}
var asMeth = cur as IMethodSymbol;
//if (asMeth != null)
//{
// if (asMeth.PartialImplementationPart != null)
// asMeth = asMeth.PartialImplementationPart; // if partial method => work with implementation
// var declarings = asMeth.DeclaringSyntaxReferences;
// if (declarings != null && declarings.Length == 1)// it is a method, so it could not be implemented in two places.
// foreach (var invocationExpression in
// declarings
// .First()
// .GetSyntax()
// .DescendantNodes()
// .OfType<InvocationExpressionSyntax>())
// foreach (var model in models)
// {
// try
// {
// //var t1 = invocationExpression.Parent;
// //var t2 = invocationExpression.Parent.Parent;
// //var t3 = invocationExpression.Parent.Parent.Parent;
// //var t4 = invocationExpression.Parent.Parent.Parent.Parent;
// SymbolInfo symbolInfo = model.GetSymbolInfo(invocationExpression);
// var calledMethod = (IMethodSymbol)symbolInfo.Symbol;
// if (!_cacheMethodsCoupling[compilation].ContainsKey(asMeth))
// _cacheMethodsCoupling[compilation].Add(asMeth, new HashSet<ISymbol>());
// _cacheMethodsCoupling[compilation][asMeth].Add(calledMethod);
// break;
// }
// catch
// { }
// }
//}
var asPro = cur as IPropertySymbol;
var MethodList = new List<IMethodSymbol> { asMeth };
//we do not need analyse property, because its methods already is members to see
//if (asPro != null) MethodList = new List<IMethodSymbol> { asPro.GetMethod, asPro.SetMethod};
foreach (var meth in MethodList)
{
if (meth != null)
{
//TODO : make it to parallel processes
var too = SymbolFinder.FindCallersAsync(meth, solution);
too.Wait();
var CallingMethods = new List<IMethodSymbol>();
foreach (var el in too.Result)
{
var method = el.CallingSymbol as IMethodSymbol;
if (method != null) CallingMethods.Add(method);
var property = el.CallingSymbol as IPropertySymbol;
if (property != null)
{
if (property.GetMethod != null) CallingMethods.Add(property.GetMethod);
if (property.SetMethod != null) CallingMethods.Add(property.SetMethod);
}
}
foreach (var el in CallingMethods)
{
if (el.ContainingType != meth.ContainingType)
{
if (!_cacheMethodsCoupling[compilation].ContainsKey(el))
_cacheMethodsCoupling[compilation].Add(el, new HashSet<ISymbol>());
_cacheMethodsCoupling[compilation][el].Add(meth);
}
}
}
}
///////////////////////////////////////////////////////////////
}
}
private void GetDeclaredSymbols(INamespaceOrTypeSymbol container, List<ISymbol> symbols)
{
foreach (var member in container.GetMembers())
{
symbols.Add(member);
var nsOrType = member as INamespaceOrTypeSymbol;
if (nsOrType != null)
{
GetDeclaredSymbols(nsOrType, symbols);
}
}
}
private void Visit(INamespaceOrTypeSymbol type)
{
foreach (var method in type.GetMembers().OfType<IMethodSymbol>())
{
Visit(method);
}
}
IEnumerable<ISymbol> GetAllSymbols(INamespaceOrTypeSymbol root) {
foreach(var m in root.GetMembers()) {
yield return m;
var r2 = m as INamespaceOrTypeSymbol;
if(r2 != null)
foreach(var m2 in GetAllSymbols(r2))
yield return m2;
}
}
