Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

5.9 KB
Raw Blame
using Aetheris.Kernel.Firmament.FirmamentV2.Syntax;

namespace Aetheris.Kernel.Firmament.FirmamentV2;

/// <summary>Specialization hygiene for Profile-local construction. References and
/// published segment names are distinct from fields, types and string contents.</summary>
internal sealed class ProfileTemplateProjection(string instance) : FirmamentSyntaxRewriter
{
    private readonly Dictionary<BlockSyntax, FirmamentBindingScope> scopes = new(ReferenceEqualityComparer.Instance);
    private readonly Dictionary<DeclarationSyntax, string> names = new(ReferenceEqualityComparer.Instance);
    private readonly Stack<HashSet<string>> parameters = new();
    private FirmamentBindingScope scope = new(null, "profile");

    internal static string Render(string instance, string tail, string body, List<string> diagnostics)
    {
        var syntax = FirmamentSyntaxParser.Parse(body);
        if (!syntax.IsSuccess)
        {
            diagnostics.AddRange(syntax.Diagnostics.Select(d => d.Code + ": " + d.Message));
            return "Profile " + instance + tail + " {" + body + "}";
        }
        var block = new BlockSyntax(syntax.Document.Statements, syntax.Document.Span) { Delimited = false };
        var projection = new ProfileTemplateProjection(instance);
        projection.Collect(block, null);
        var result = projection.Block(block).Statements;
        var guides = result.OfType<DeclarationSyntax>().Where(IsGuide).ToHashSet<StatementSyntax>();
        return FirmamentSyntaxWriter.Statements(result.Where(guides.Contains), body) + "\nProfile " + instance + tail + " {\n"
            + FirmamentSyntaxWriter.Statements(result.Where(s => !guides.Contains(s)), body) + "\n}";
    }

    private static bool IsGuide(DeclarationSyntax d) =>
        d.Type.Name.Text == "Struct" && d.Modifiers.Any(m => m.Name.Text == "Concept")
        || ProfileAuthoringParser.OwnsDeclaration(d) && d.Type.Name.Text is not ("Profile" or "Span");

    private void Collect(BlockSyntax block, FirmamentBindingScope? parent)
    {
        var local = new FirmamentBindingScope(parent, "profile specialization");
        scopes.Add(block, local);
        foreach (var declaration in block.Statements.OfType<DeclarationSyntax>())
        {
            // Loop and Segment labels have their own identity namespace. They do
            // not shadow the construction guide a trace inside them references.
            if (declaration.Type.Name.Text is not ("Loop" or "Segment")) local.Declare("value", declaration);
            if (declaration.Name is {} name && IsGuide(declaration)) names.Add(declaration, instance + "_" + name.Text);
        }
        foreach (var declaration in block.Statements.OfType<DeclarationSyntax>())
            if (declaration.Body is {} child) Collect(child, local);
        foreach (var nested in block.Statements.OfType<StatementBlockSyntax>()) Collect(nested.Body, local);
    }

    internal override BlockSyntax Block(BlockSyntax block)
    {
        var enclosing = scope;
        if (!scopes.TryGetValue(block, out var local)) { Collect(block, enclosing); local = scopes[block]; }
        scope = local;
        var result = base.Block(block);
        scope = enclosing;
        return result;
    }

    internal override StatementSyntax Statement(StatementSyntax statement)
    {
        var shadowed = statement is DeclarationSyntax d ? d.Parameters.Select(p => p.Name?.Text).OfType<string>()
            : statement is MappingSyntax m ? [m.Key.Text] : Enumerable.Empty<string>();
        parameters.Push(shadowed.ToHashSet(StringComparer.Ordinal));
        var result = base.Statement(statement);
        parameters.Pop();
        if (statement is DeclarationSyntax original && result is DeclarationSyntax { Name: {} label } rewritten)
        {
            if (names.TryGetValue(original, out var renamed)) return rewritten with { Name = label with { Text = renamed } };
            // Retain existing published specialization identities when a Segment
            // was named after a local guide. Do not rename unrelated labels.
            if (original.Type.Name.Text == "Segment" && Resolve(label.Text) is {} guide && names.TryGetValue(guide, out renamed))
                return rewritten with { Name = label with { Text = renamed } };
        }
        return result;
    }

    private DeclarationSyntax? Resolve(string name) => parameters.Any(p => p.Contains(name)) ? null : scope.Resolve("value", name);
    private DeclarationSyntax? Referent(ExpressionSyntax expression) => expression switch
    {
        ReferenceSyntax r => Resolve(r.Name.Text),
        MemberSyntax m => Referent(m.Target)?.Body?.Statements.OfType<DeclarationSyntax>().FirstOrDefault(d => d.Name?.Text == m.Member.Text),
        _ => null
    };

    internal override ExpressionSyntax Expression(ExpressionSyntax expression)
    {
        if (expression is ReferenceSyntax r && Resolve(r.Name.Text) is {} declaration && names.TryGetValue(declaration, out var name))
            return r with { Name = r.Name with { Text = name } };
        if (expression is MemberSyntax m)
            return m with { Target = Expression(m.Target), Member = Referent(m) is {} member && names.TryGetValue(member, out var renamed)
                ? m.Member with { Text = renamed } : m.Member };
        if (expression is AliasSyntax alias && Resolve(alias.Name.Text) is {} guide && names.TryGetValue(guide, out var label))
            return alias with { Value = Expression(alias.Value), Name = alias.Name with { Text = label } };
        // Constructor names and typed object names occupy the type namespace.
        if (expression is CallSyntax { Target: ReferenceSyntax } call) return call with { Arguments = call.Arguments.Select(Argument).ToArray() };
        if (expression is ObjectSyntax obj) return obj with { Body = Block(obj.Body) };
        if (expression is TypedValueSyntax typed) return typed with { Value = Expression(typed.Value) };
        return base.Expression(expression);
    }
}