Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

7.3 KB
Raw Blame
namespace Aetheris.Kernel.Firmament.FirmamentV2.Syntax;

/// <summary>Immutable syntax transformation. Identifier declarations, field labels and
/// member labels are distinct from references; none are inferred from source substrings.</summary>
internal class FirmamentSyntaxRewriter
{
    internal virtual BlockSyntax Block(BlockSyntax block) => block with { Statements = block.Statements.Select(Statement).ToArray() };
    internal virtual ArgumentSyntax Argument(ArgumentSyntax a) => a with { Value = Expression(a.Value), Default = a.Default is null ? null : Expression(a.Default) };
    internal virtual TypeSyntax Type(TypeSyntax t) => t with { Arguments = t.Arguments.Select(Argument).ToArray() };
    internal virtual StatementSyntax Statement(StatementSyntax s) => s switch
    {
        DeclarationSyntax d => d with { Type = Type(d.Type), Modifiers = d.Modifiers.Select(Type).ToArray(),
            Parameters = d.Parameters.Select(Argument).ToArray(), Annotation = Optional(d.Annotation), ResultType = Optional(d.ResultType),
            Target = Optional(d.Target), Clauses = d.Clauses.Select(c => c with { Value = Expression(c.Value) }).ToArray(),
            Initializer = Optional(d.Initializer), Body = d.Body is null ? null : Block(d.Body) },
        FieldSyntax f => f with { Value = Expression(f.Value) },
        DirectiveSyntax d => d with { Value = Expression(d.Value) },
        ExpressionStatementSyntax e => e with { Value = Expression(e.Value) },
        ReturnSyntax r => r with { Value = Expression(r.Value) },
        StatementBlockSyntax b => b with { Body = Block(b.Body) },
        MappingSyntax m => m with { Value = Statement(m.Value) },
        InterfaceRelationSyntax r => r with { First = Expression(r.First), Second = Expression(r.Second), Option = Optional(r.Option) },
        InterfaceFitSyntax f => f with { Shaft = Expression(f.Shaft), Bore = Expression(f.Bore) },
        InterfacePolicySyntax p => p with { Values = p.Values.Select(Argument).ToArray() },
        ReplacementSyntax r => r with { Target = Expression(r.Target), Replacement = (DeclarationSyntax)Statement(r.Replacement) },
        RoleRequirementSyntax or InterfaceMotionSyntax => s,
        _ => throw new InvalidOperationException($"Unowned syntax transformation: {s.GetType().Name}.")
    };
    protected ExpressionSyntax? Optional(ExpressionSyntax? e) => e is null ? null : Expression(e);
    internal virtual ExpressionSyntax Expression(ExpressionSyntax e) => e switch
    {
        UnarySyntax u => u with { Operand = Expression(u.Operand) },
        BinarySyntax b => b with { Left = Expression(b.Left), Right = Expression(b.Right) },
        QuantitySyntax q => q with { Value = Expression(q.Value) },
        ToleranceSyntax t => t with { Nominal = Expression(t.Nominal), Plus = Expression(t.Plus), Minus = Optional(t.Minus) },
        SequenceSyntax s => s with { Items = s.Items.Select(Argument).ToArray() },
        MemberSyntax m => m with { Target = Expression(m.Target) },
        IndexSyntax i => i with { Target = Expression(i.Target), Index = Optional(i.Index) },
        CallSyntax c => c with { Target = Expression(c.Target), Arguments = c.Arguments.Select(Argument).ToArray() },
        SpecializationSyntax s => s with { Target = Expression(s.Target), Arguments = s.Arguments.Select(Argument).ToArray() },
        ObjectSyntax o => o with { Type = Optional(o.Type), Body = Block(o.Body) },
        WithSyntax w => w with { Target = Expression(w.Target), Body = Block(w.Body) },
        FrameSyntax f => f with { Origin = Expression(f.Origin), Axes = f.Axes.Select(Argument).ToArray() },
        AliasSyntax a => a with { Value = Expression(a.Value) },
        TraceSyntax t => t with { Source = Expression(t.Source), From = Optional(t.From), To = Optional(t.To) },
        MemberSetSyntax m => m with { Target = Expression(m.Target), Members = m.Members.Select(Argument).ToArray() },
        TypedValueSyntax t => t with { Type = Expression(t.Type), Value = Expression(t.Value) },
        ProvenanceSyntax p => p with { Value = Expression(p.Value) },
        TypeParameterSyntax p => p with { Constraint = Optional(p.Constraint) },
        MatchSyntax m => m with { Scrutinee = Expression(m.Scrutinee), Arms = m.Arms.Select(a => a with { Pattern = Expression(a.Pattern), Value = Expression(a.Value) }).ToArray() },
        ReferenceSyntax or LiteralSyntax => e,
        _ => throw new InvalidOperationException($"Unowned expression transformation: {e.GetType().Name}.")
    };
}

/// <summary>Substitutes already-bound AST values. Nested parameters and mapping binders
/// shadow their enclosing environment. Declaration renaming is explicit and separate.</summary>
internal sealed class FirmamentSyntaxSubstitution(IReadOnlyDictionary<string, ExpressionSyntax> values,
    IReadOnlyDictionary<string, string>? renames = null) : FirmamentSyntaxRewriter
{
    private readonly Stack<HashSet<string>> shadows = new();
    private bool Shadowed(string name) => shadows.Any(s => s.Contains(name.Split('.')[0]));
    internal override StatementSyntax Statement(StatementSyntax statement)
    {
        var names = statement switch
        {
            DeclarationSyntax d => d.Parameters.Select(p => p.Name?.Text).OfType<string>()
                .Concat(d.Modifiers.Where(m => m.Name.Text == "Template").SelectMany(m => m.Arguments).Select(p => p.Name?.Text).OfType<string>())
                .Concat(d.Type.Name.Text == "Feature" ? d.Body?.Statements.OfType<DeclarationSyntax>().Where(l => l.Type.Name.Text == "let").Select(l => l.Name?.Text).OfType<string>() ?? [] : []),
            MappingSyntax m => [m.Key.Text],
            _ => []
        };
        shadows.Push(names.ToHashSet(StringComparer.Ordinal));
        var rewritten = base.Statement(statement);
        shadows.Pop();
        if (rewritten is DeclarationSyntax { Name: { } name } declaration && renames?.TryGetValue(name.Text, out var replacement) == true)
            return declaration with { Name = name with { Text = replacement } };
        return rewritten;
    }
    internal override ExpressionSyntax Expression(ExpressionSyntax expression)
    {
        // A constructor's type is not a value reference, even when a parameter
        // happens to have the same spelling (Profile: Profile, for example).
        if (expression is ObjectSyntax obj) return obj with { Body = Block(obj.Body) };
        if (expression is TypedValueSyntax typed) return typed with { Value = Expression(typed.Value) };
        if (expression is SpecializationSyntax specialization) return specialization with { Arguments = specialization.Arguments.Select(Argument).ToArray() };
        if (expression is CallSyntax { Target: ReferenceSyntax } call) return call with { Arguments = call.Arguments.Select(Argument).ToArray() };
        if (FirmamentSyntaxValues.Reference(expression) is { } name && expression is ReferenceSyntax or MemberSyntax && !Shadowed(name))
        {
            if (values.TryGetValue(name, out var value)) return value;
            if (renames?.TryGetValue(name, out var replacement) == true) return new ReferenceSyntax(new(replacement, expression.Span), expression.Span);
        }
        return base.Expression(expression);
    }
    // This is value substitution. Declaration type/variant names occupy the type
    // namespace; product Template type specialization has its separate owner.
    internal override TypeSyntax Type(TypeSyntax type) => type;
}