private void PrepareUsings(UsingCache cache, Constraint constraint)
{
if (constraint is TypeNameConstraint typeName)
{
PrepareUsings(cache, typeName.Value);
}
}
private void PrepareUsings(UsingCache cache, ParameterNode node)
{
if (node == null)
{
return;
}
PrepareUsings(cache, node.Type);
}
private void PrepareUsings(UsingCache cache, TypeConstraintNode node)
{
if (node == null)
{
return;
}
node.Constraints?.ForEach(c => PrepareUsings(cache, c));
}
private void PrepareUsings(UsingCache cache, MemberNode node)
{
if (node == null)
{
return;
}
PrepareUsings(cache, node.ReturnType);
if (node is MethodNode methodNode)
{
methodNode.TypeConstraints?.ForEach(t => PrepareUsings(cache, t));
methodNode.Parameters?.ForEach(p => PrepareUsings(cache, p));
}
}
private void PrepareUsings(UsingCache cache, TypeNode node)
{
if (node is TypeGenericNode g)
{
g.TypeConstraints?.ForEach(c => PrepareUsings(cache, c));
}
switch (node)
{
case InterfaceNode i:
i.Members?.ForEach(m => PrepareUsings(cache, m));
break;
case TypeStructClassNode sc:
sc.Members?.ForEach(m => PrepareUsings(cache, m));
break;
}
}
private void PrepareUsings(UsingCache cache, UsingNode node)
{
if (node == null)
{
return;
}
if (cache.IsUsingNamespace(node))
{
return;
}
if (string.IsNullOrWhiteSpace(node.Namespace))
{
return;
}
cache.Map[node.Namespace] = node;
}
protected virtual void VisitUsings(UsingCache cache)
{
if (cache == null)
{
return;
}
cache.Namespaces.AddRange(cache.Map.Keys);
cache.Namespaces.Sort();
for (var i = 0; i < cache.Namespaces.Count; i++)
{
if (cache.Map.TryGetValue(cache.Namespaces[i], out var node))
{
cache.Usings.Add(node);
}
}
cache.Usings.ForEach(u => VisitUsingNode(u));
}
private void PrepareUsings(UsingCache cache, SimpleType type)
{
if (type == null || type.IsExplicit)
{
return;
}
if (cache.IsUsingNamespace(type))
{
return;
}
if (string.IsNullOrWhiteSpace(type.Namespace))
{
return;
}
cache.Map[type.Namespace] = new UsingNode {
Namespace = type.Namespace
};
}
