Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
namespace Aetheris.Kernel.Firmament.FirmamentV2.Syntax;
/// <summary>Shared structural traversal for syntax owners and developer inspection.</summary>
public static class FirmamentSyntaxTraversal
{
public static IEnumerable<DeclarationSyntax> Declarations(DocumentSyntax document) =>
Statements(document).OfType<DeclarationSyntax>();
public static IEnumerable<StatementSyntax> Statements(DocumentSyntax document) => document.Statements.SelectMany(Descendants);
public static IEnumerable<ExpressionSyntax> Expressions(DocumentSyntax document) =>
Statements(document).SelectMany(s => s switch
{
FieldSyntax f => Expressions(f.Value),
ExpressionStatementSyntax e => Expressions(e.Value),
ReturnSyntax r => Expressions(r.Value),
InterfaceRelationSyntax r => Expressions(r.First).Concat(Expressions(r.Second)).Concat(r.Option is null ? [] : Expressions(r.Option)),
InterfaceFitSyntax f => Expressions(f.Shaft).Concat(Expressions(f.Bore)),
InterfacePolicySyntax p => p.Values.SelectMany(v => Expressions(v.Value)),
ReplacementSyntax r => Expressions(r.Target),
DirectiveSyntax d => Expressions(d.Value),
DeclarationSyntax d => Arguments(d.Type.Arguments)
.Concat(d.Modifiers.SelectMany(m => Arguments(m.Arguments)))
.Concat(Arguments(d.Parameters))
.Concat(d.ResultType is null ? [] : Expressions(d.ResultType))
.Concat(d.Annotation is null ? [] : Expressions(d.Annotation))
.Concat(d.Initializer is null ? [] : Expressions(d.Initializer))
.Concat(d.Target is null ? [] : Expressions(d.Target))
.Concat(d.Clauses.SelectMany(c => Expressions(c.Value))),
_ => []
});
private static IEnumerable<ExpressionSyntax> Arguments(IEnumerable<ArgumentSyntax> arguments) =>
arguments.SelectMany(a => Expressions(a.Value).Concat(a.Default is null ? [] : Expressions(a.Default)));
public static IEnumerable<ExpressionSyntax> Expressions(ExpressionSyntax expression)
{
yield return expression;
IEnumerable<ExpressionSyntax> children = expression switch
{
AliasSyntax a => [a.Value],
BinarySyntax b => [b.Left, b.Right],
UnarySyntax u => [u.Operand],
QuantitySyntax q => [q.Value],
ToleranceSyntax t => new[] { t.Nominal, t.Plus, t.Minus }.OfType<ExpressionSyntax>(),
SequenceSyntax s => s.Items.SelectMany(a => new[] { a.Value, a.Default }.OfType<ExpressionSyntax>()),
CallSyntax c => new[] { c.Target }.Concat(c.Arguments.SelectMany(a => new[] { a.Value, a.Default }.OfType<ExpressionSyntax>())),
SpecializationSyntax s => new[] { s.Target }.Concat(s.Arguments.SelectMany(a => new[] { a.Value, a.Default }.OfType<ExpressionSyntax>())),
MemberSyntax m => [m.Target],
IndexSyntax i => i.Index is null ? [i.Target] : [i.Target, i.Index],
WithSyntax w => [w.Target],
TraceSyntax t => new[] { t.Source, t.From, t.To }.OfType<ExpressionSyntax>(),
TypedValueSyntax t => [t.Type, t.Value],
ProvenanceSyntax p => [p.Value, p.Source],
TypeParameterSyntax p => p.Constraint is null ? [] : [p.Constraint],
ObjectSyntax o => o.Type is null ? [] : [o.Type],
FrameSyntax f => new[] { f.Origin }.Concat(f.Axes.Select(a => a.Value)),
MemberSetSyntax m => new[] { m.Target }.Concat(m.Members.Select(a => a.Value)),
MatchSyntax m => new[] { m.Scrutinee }.Concat(m.Arms.SelectMany(a => new[] { a.Pattern, a.Value })),
_ => []
};
foreach (var child in children)
foreach (var nested in Expressions(child)) yield return nested;
}
private static IEnumerable<StatementSyntax> Descendants(StatementSyntax statement)
{
yield return statement;
foreach (var child in ChildStatements(statement))
foreach (var descendant in Descendants(child)) yield return descendant;
}
public static IEnumerable<DeclarationSyntax> Declarations(StatementSyntax statement)
{
if (statement is DeclarationSyntax declaration) yield return declaration;
foreach (var child in ChildStatements(statement))
foreach (var nested in Declarations(child)) yield return nested;
}
private static IEnumerable<StatementSyntax> ChildStatements(StatementSyntax statement) => statement switch
{
DeclarationSyntax d => (d.Body?.Statements ?? []).Concat(d.Initializer is null ? [] : ExpressionBodies(d.Initializer))
.Concat(d.Annotation is null ? [] : ExpressionBodies(d.Annotation)),
FieldSyntax f => ExpressionBodies(f.Value),
ExpressionStatementSyntax e => ExpressionBodies(e.Value),
ReturnSyntax r => ExpressionBodies(r.Value),
StatementBlockSyntax b => b.Body.Statements,
MappingSyntax m => [m.Value],
ReplacementSyntax r => [r.Replacement],
_ => []
};
private static IEnumerable<StatementSyntax> ExpressionBodies(ExpressionSyntax expression) => expression switch
{
ObjectSyntax o => o.Body.Statements.Concat(o.Type is null ? [] : ExpressionBodies(o.Type)),
WithSyntax w => w.Body.Statements.Concat(ExpressionBodies(w.Target)),
SequenceSyntax s => s.Items.SelectMany(a => ExpressionBodies(a.Value)),
CallSyntax c => ExpressionBodies(c.Target).Concat(c.Arguments.SelectMany(a => ExpressionBodies(a.Value))),
SpecializationSyntax s => ExpressionBodies(s.Target).Concat(s.Arguments.SelectMany(a => ExpressionBodies(a.Value))),
BinarySyntax b => ExpressionBodies(b.Left).Concat(ExpressionBodies(b.Right)),
UnarySyntax u => ExpressionBodies(u.Operand),
MemberSyntax m => ExpressionBodies(m.Target),
IndexSyntax i => ExpressionBodies(i.Target).Concat(i.Index is null ? [] : ExpressionBodies(i.Index)),
QuantitySyntax q => ExpressionBodies(q.Value),
ToleranceSyntax t => ExpressionBodies(t.Nominal).Concat(ExpressionBodies(t.Plus)).Concat(t.Minus is null ? [] : ExpressionBodies(t.Minus)),
FrameSyntax f => ExpressionBodies(f.Origin).Concat(f.Axes.SelectMany(a => ExpressionBodies(a.Value))),
AliasSyntax a => ExpressionBodies(a.Value),
TraceSyntax t => ExpressionBodies(t.Source).Concat(t.From is null ? [] : ExpressionBodies(t.From)).Concat(t.To is null ? [] : ExpressionBodies(t.To)),
TypedValueSyntax t => ExpressionBodies(t.Type).Concat(ExpressionBodies(t.Value)),
ProvenanceSyntax p => ExpressionBodies(p.Value),
MatchSyntax m => ExpressionBodies(m.Scrutinee).Concat(m.Arms.SelectMany(a => ExpressionBodies(a.Pattern).Concat(ExpressionBodies(a.Value)))),
MemberSetSyntax m => ExpressionBodies(m.Target).Concat(m.Members.SelectMany(a => ExpressionBodies(a.Value))),
_ => []
};
}