public override Node Visit(NamespaceDeclaration node)
{
try
{
var root = new NamespaceDeclarationNode(node.Identifiers);
foreach (var m in node.Members)
{
if (m is TypeDeclaration td)
{
var visitor = Context?.VisitFactory?.GetVisitor(nameof(TypeDeclaration)) as ICILVisitor <TypeDeclaration>;
Node outNode = td.AcceptVisitor(visitor);
if (!(outNode is MemberDeclarationNode member))
{
throw new VisitorException($"{nameof(TypeDeclaration)} visitor returned {outNode.Type}.");
}
root.Members.Add(member);
}
else if (m is DelegateDeclaration dd)
{
var visitor = Context?.VisitFactory?.GetVisitor(nameof(DelegateDeclaration)) as ICILVisitor <DelegateDeclaration>;
Node outNode = dd.AcceptVisitor(visitor);
if (!(outNode is FunctionEntityDeclarationNode delegateNode))
{
throw new VisitorException($"{nameof(DelegateDeclaration)} visitor returned {outNode.Type}.");
}
root.Members.Add(delegateNode);
}
else
{
throw new NotImplementedException($"{m.GetType()} is not supported in namespaces.");
}
}
foreach (var c in node.Children.Except(node.Members).Except(new AstNode[] { node.NamespaceName }))
{
Node outNode = Context?.VisitFactory?.GetVisitor(c)?.Visit(c);
if (outNode != null)
{
root.Children.Add(outNode);
}
}
return(root);
}
catch (Exception e)
{
throw new VisitorException(e);
}
}
// TODO: check if this works
private NamespaceWrapper Split(IEnumerable <NamespaceWrapper> parent, int level)
{
NamespaceWrapper bottom = parent.SingleOrDefault(p => p.Identifiers.Length == level + 1);
NamespaceDeclarationNode node;
NamespaceDeclarationNode declaration;
List <NamespaceWrapper> deeper;
if (bottom != null)
{
declaration = new NamespaceDeclarationNode(bottom.Identifiers[level]);
node = bottom.Node;
foreach (var c in node.Members)
{
declaration.Members.Add(c);
}
foreach (var c in node.Children)
{
declaration.Children.Add(c);
}
deeper = parent.Except(new NamespaceWrapper[] { bottom }).ToList();
}
else
{
NamespaceWrapper first = parent.First();
declaration = new NamespaceDeclarationNode(first.Identifiers[level]);
node = first.Node;
deeper = parent.ToList();
}
while (deeper.Count > 0)
{
var commonParent = deeper.Where(d => d.Identifiers[level + 1] == deeper[0].Identifiers[level + 1]).ToArray();
var split = Split(commonParent, level + 1);
declaration.Members.Add(split.Node);
foreach (var w in commonParent)
{
deeper.Remove(w);
}
}
return(new NamespaceWrapper(declaration));
}
public NamespaceWrapper(NamespaceDeclarationNode node)
{
Node = node;
Identifiers = node.Identifiers.ToArray();
}
object IVisitor.Visit(NamespaceDeclarationNode node)
{
return(Visit((Node)node));
}
/// <inheritdoc/>
public override void VisitNamespaceDeclarationNode(NamespaceDeclarationNode node)
{
VisitList <ParseTreeNode>(node.NamespaceMemberDeclarations);
}
public object Visit(NamespaceDeclarationNode node)
{
return(Visit((Node)node));
}
