Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

15.8 KB
Raw Blame
using System.Security.Cryptography;
using System.Text;

namespace Aetheris.Kernel.Firmament.FirmamentV2.Syntax;

/// <summary>Lexical identities for compile-time data. Identifier spans are lowered
/// only after AST lookup, at the existing source boundary to domain adapters.</summary>
internal sealed class FirmamentDataBinding
{
    internal static string? NamespaceFor(DeclarationSyntax declaration) => declaration.Type.Name.Text is "Record" or "Enum" ? "type"
        : declaration.Type.Name.Text=="Static" || declaration.Type.Name.Text=="Table" && declaration.Modifiers.Any(m=>m.Name.Text=="Static") ? "value" : null;
    internal sealed record Symbol(string Name, string Identity, string Namespace, string Scope, DeclarationSyntax Declaration);
    private sealed class Scope(Scope? parent, string identity)
    {
        internal string Identity => identity;
        internal readonly Dictionary<(string Namespace, string Name), Symbol> Symbols = new();
        internal readonly HashSet<string> Values = new(StringComparer.Ordinal);
        internal readonly HashSet<string> Types = new(StringComparer.Ordinal);
        internal Symbol? Resolve(string space, string name) => Symbols.GetValueOrDefault((space, name))
            ?? (space == "value" && Values.Contains(name) || space == "type" && Types.Contains(name) ? null : parent?.Resolve(space, name));
        internal bool HasValueShadow(string name) => Values.Contains(name) || parent?.HasValueShadow(name) == true;
        internal bool HasTypeShadow(string name) => Types.Contains(name) || parent?.HasTypeShadow(name) == true;
    }
    private sealed record Edit(FirmamentV2SourceSpan Span, string Text);
    private readonly List<Edit> edits = [];
    private readonly Dictionary<string, Symbol> identities = new(StringComparer.Ordinal);
    private readonly List<(FirmamentV2SourceSpan Span, Scope Scope)> scopeSpans = [];
    internal string OriginalSource { get; }
    internal string Source { get; }
    internal IReadOnlyList<Symbol> Symbols { get; }
    internal IReadOnlyList<FirmamentV2ValidationDiagnostic> Diagnostics { get; }
    internal bool IsChanged => edits.Count != 0;

    internal FirmamentDataBinding(string source, bool moduleContext = false)
    {
        OriginalSource = source;
        Source = source;
        var syntax = FirmamentSyntaxParser.Parse(source);
        if (!syntax.IsSuccess) { Symbols = []; Diagnostics = []; return; } // syntax owner presents recovery failures
        var errors = new List<FirmamentV2ValidationDiagnostic>();
        var symbols = new List<Symbol>();
        var scopes = new Dictionary<StatementSyntax, Scope>(ReferenceEqualityComparer.Instance);
        var definitions = new Dictionary<DeclarationSyntax, Symbol>(ReferenceEqualityComparer.Instance);
        var headers = new Dictionary<DeclarationSyntax, Scope>(ReferenceEqualityComparer.Instance);
        var root = new Scope(null, "document");
        scopeSpans.Add((new(0, source.Length), root));
        var occupied = syntax.Document.Tokens.Where(t => t.Kind == SyntaxTokenKind.Identifier).Select(t => t.Text).ToHashSet(StringComparer.Ordinal);
        Collect(syntax.Document.Statements, root);
        // Preserve all established unique spellings, including root declarations.
        foreach (var group in symbols.GroupBy(s => (s.Namespace, s.Name)))
        {
            var ordered = group.OrderBy(s => s.Scope == "document" ? 0 : 1).ThenBy(s => s.Declaration.Span.Start).ToArray();
            for (var i = 0; i < ordered.Length; i++)
            {
                var symbol = ordered[i];
                var identity = symbol.Name;
                if (i > 0)
                {
                    var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(symbol.Scope + "/" + symbol.Namespace + "/" + symbol.Name)))[..12];
                    identity = "__firmamentData_" + hash + "_" + symbol.Name;
                    while (!occupied.Add(identity)) identity += "_";
                }
                var bound = symbol with { Identity = identity };
                scopes[symbol.Declaration].Symbols[(symbol.Namespace, symbol.Name)] = bound;
                definitions[symbol.Declaration] = bound;
                identities[identity] = bound;
            }
        }
        Rewrite(syntax.Document.Statements);
        Symbols = definitions.Values.OrderBy(s => s.Declaration.Span.Start).ToArray();
        Diagnostics = errors;
        edits.Sort((a, b) => a.Span.Start.CompareTo(b.Span.Start));
        for (var i = edits.Count - 1; i >= 0; i--)
            Source = Source.Remove(edits[i].Span.Start, edits[i].Span.Length).Insert(edits[i].Span.Start, edits[i].Text);

        void Collect(IReadOnlyList<StatementSyntax> statements, Scope scope)
        {
            foreach (var statement in statements)
            {
                scopes[statement] = scope;
                if (statement is not DeclarationSyntax { Name: { } name } d) continue;
                if (d.Type.Name.Text == "Record" && d.Modifiers.Any(m => m.Name.Text == "Inventory"))
                {
                    scope.Values.Add(name.Text);
                    if (!moduleContext) Error("firmament-module-context-required", $"Inventory Record '{name.Text}' requires a project loader. Reference this module from a consuming project; it is not an ordinary data Record.", d.Span, name.Text, "Module binding");
                    continue;
                }
                var space = NamespaceFor(d);
                if (space is null) { scope.Values.Add(name.Text); continue; }
                var table = d.Type.Name.Text == "Table";
                if (d.HasParameterList || d.Type.Span.Length != d.Type.Name.Span.Length || d.Occurrence
                    || d.ResultType is not null || d.Clauses.Any(c => !table || c.Kind != ClauseKind.Key)
                    || d.Clauses.Count(c => c.Kind == ClauseKind.Key) > 1
                    || d.Modifiers.Any(m => !table || m.Name.Text != "Static"))
                {
                    Error("firmament-binding-invalid-data-header:" + name.Text, $"{d.Type.Name.Text} '{name.Text}' cannot carry ignored parameters, placement, generic or result clauses.", d.Span, name.Text);
                    continue;
                }
                var symbol = new Symbol(name.Text, name.Text, space, scope.Identity, d);
                if (!scope.Symbols.TryAdd((space, name.Text), symbol))
                    Error("firmament-binding-duplicate-name:" + name.Text, $"Compile-time {space} '{name.Text}' is declared more than once in scope '{scope.Identity}'.", d.Span, name.Text);
                else { symbols.Add(symbol); definitions[d] = symbol; }
            }
            var ordinals = new Dictionary<string, int>(StringComparer.Ordinal);
            foreach (var statement in statements)
            {
                if (statement is StatementBlockSyntax block) { Collect(block.Body.Statements, scope); continue; }
                if (statement is MappingSyntax m)
                {
                    var child = new Scope(scope, scope.Identity + "/mapping " + m.Key.Text); child.Values.Add(m.Key.Text);
                    Collect([m.Value], child); continue;
                }
                if (statement is not DeclarationSyntax d || d.Body is null && !d.HasParameterList) continue;
                var label = d.Type.Name.Text + " " + d.Name?.Text;
                var ordinal = ordinals.GetValueOrDefault(label); ordinals[label] = ordinal + 1;
                var header = new Scope(scope, scope.Identity + "/parameters " + label + "#" + ordinal);
                foreach (var p in d.Parameters.Concat(d.Modifiers.Where(m => m.Name.Text == "Template").SelectMany(m => m.Arguments)))
                    if (p.Name is not null)
                    {
                        if (p.Value is TypeParameterSyntax) header.Types.Add(p.Name.Text);
                        else header.Values.Add(p.Name.Text);
                    }
                headers[d] = header;
                if (d.Body is null) continue;
                var body = new Scope(header, scope.Identity + "/" + label + "#" + ordinal);
                // The curve parameter is a lexical Float local, like a Function
                // parameter. An unrelated Static cannot capture its declaration or uses.
                if (d.Type.Name.Text is "Curve2" or "Curve3"
                    && d.Body.Statements.OfType<FieldSyntax>().FirstOrDefault(f => f.Name.Text.Equals("parameter", StringComparison.OrdinalIgnoreCase))?.Value is ReferenceSyntax parameter)
                    body.Values.Add(parameter.Name.Text);
                scopeSpans.Add((d.Body.ContentSpan, body));
                Collect(d.Body.Statements, body);
            }
        }
        void Rewrite(IEnumerable<StatementSyntax> statements)
        {
            foreach (var statement in statements)
            {
                var scope = scopes[statement];
                if (statement is StatementBlockSyntax block) { Rewrite(block.Body.Statements); continue; }
                if (statement is MappingSyntax m) { Rewrite([m.Value]); continue; }
                if (statement is FieldSyntax f) { Expression(f.Value, scope, false); continue; }
                if (statement is ExpressionStatementSyntax e) { Expression(e.Value, scope, false); continue; }
                if (statement is ReturnSyntax r) { Expression(r.Value, scope, false); continue; }
                if (statement is not DeclarationSyntax d) continue;
                if (definitions.TryGetValue(d, out var symbol)) Rename(d.Name!, symbol.Identity);
                var parameters = d.Parameters.Concat(d.Modifiers.Where(m => m.Name.Text == "Template").SelectMany(m => m.Arguments)).ToArray();
                foreach (var p in parameters)
                {
                    Expression(p.Value, headers.GetValueOrDefault(d) ?? scope, true);
                    if (p.Default is not null) Expression(p.Default, headers.GetValueOrDefault(d) ?? scope, false);
                }
                if (d.Annotation is not null) Expression(d.Annotation, scope, true);
                if (d.ResultType is not null) Expression(d.ResultType, headers.GetValueOrDefault(d) ?? scope, true);
                if (d.Initializer is not null) Expression(d.Initializer, headers.GetValueOrDefault(d) ?? scope, false);
                foreach (var clause in d.Clauses.Where(c => c.Kind != ClauseKind.Key)) Expression(clause.Value, scope, false);
                if (d.Body is not null)
                {
                    if (d.Type.Name.Text == "Record")
                        foreach (var field in d.Body.Statements.OfType<FieldSyntax>()) Expression(field.Value, scope, true);
                    else Rewrite(d.Body.Statements);
                }
            }
        }
        void Expression(ExpressionSyntax expression, Scope scope, bool type)
        {
            switch (expression)
            {
                case ReferenceSyntax r:
                    var space = type ? "type" : "value";
                    var symbol = scope.Resolve(space, r.Name.Text);
                    if (symbol is not null) Rename(r.Name, symbol.Identity);
                    else if (!(space == "value" ? scope.HasValueShadow(r.Name.Text) : scope.HasTypeShadow(r.Name.Text)) && symbols.Any(s => s.Namespace == space && s.Name == r.Name.Text))
                        Error("firmament-binding-name-not-visible:" + r.Name.Text, $"Compile-time {space} '{r.Name.Text}' is not visible from scope '{scope.Identity}'.", r.Span, r.Name.Text);
                    return;
                case ObjectSyntax o:
                    if (o.Type is not null) Expression(o.Type, scope, true);
                    foreach (var f in o.Body.Statements.OfType<FieldSyntax>()) Expression(f.Value, scope, false);
                    return;
                case SpecializationSyntax s:
                    foreach (var a in s.Arguments) Expression(a.Value, scope, type);
                    return;
                case CallSyntax c:
                    foreach (var a in c.Arguments) Expression(a.Value, scope, false);
                    if (c.Target is not ReferenceSyntax) Expression(c.Target, scope, false);
                    return;
                case MemberSyntax { Target: ReferenceSyntax owner } m when scope.Resolve("type", owner.Name.Text) is { Declaration.Type.Name.Text: "Enum" } choice:
                    Rename(owner.Name, choice.Identity); return;
                case MemberSyntax m: Expression(m.Target, scope, type); return;
                case WithSyntax w:
                    Expression(w.Target, scope, false);
                    foreach (var f in w.Body.Statements.OfType<FieldSyntax>()) Expression(f.Value, scope, false);
                    return;
                case SequenceSyntax s: foreach (var a in s.Items) Expression(a.Value, scope, type); return;
                case TypeParameterSyntax: return;
                case UnarySyntax u: Expression(u.Operand, scope, type); return;
                case BinarySyntax b: Expression(b.Left, scope, type); Expression(b.Right, scope, type); return;
                case QuantitySyntax q: Expression(q.Value, scope, false); return;
                case IndexSyntax i: Expression(i.Target, scope, type); if (i.Index is not null) Expression(i.Index, scope, false); return;
                case TypedValueSyntax t: Expression(t.Type, scope, true); Expression(t.Value, scope, false); return;
                case ToleranceSyntax t:
                    Expression(t.Nominal, scope, false); Expression(t.Plus, scope, false); if (t.Minus is not null) Expression(t.Minus, scope, false); return;
                case MatchSyntax m: Expression(m.Scrutinee, scope, false); foreach (var a in m.Arms) { Expression(a.Pattern, scope, false); Expression(a.Value, scope, false); } return;
                case AliasSyntax a: Expression(a.Value, scope, type); return;
                case ProvenanceSyntax p: Expression(p.Value, scope, type); return;
                case FrameSyntax f:
                    Expression(f.Origin, scope, false); foreach (var a in f.Axes) Expression(a.Value, scope, false); return;
                case MemberSetSyntax m:
                    Expression(m.Target, scope, false); foreach (var a in m.Members) Expression(a.Value, scope, false); return;
                case TraceSyntax t:
                    Expression(t.Source, scope, false); if (t.From is not null) Expression(t.From, scope, false); if (t.To is not null) Expression(t.To, scope, false); return;
            }
        }
        void Rename(IdentifierSyntax name, string text)
        {
            if (name.Text != text && !edits.Any(e => e.Span == name.Span)) edits.Add(new(name.Span, text));
        }
        void Error(string code, string message, FirmamentV2SourceSpan span, string name, string stage = "Data binding") => errors.Add(new(code, "fatal", message, Target: name)
            { SourceSpan = span, IsOriginalSource = true, Stage = stage });
    }

    internal string DisplayName(string identity) => identities.TryGetValue(identity, out var symbol) ? symbol.Name : identity;
    internal string ResolveIdentity(string space, string name, int position) => scopeSpans
        .Where(s => position >= s.Span.Start && position < s.Span.Start + s.Span.Length).OrderBy(s => s.Span.Length)
        .FirstOrDefault().Scope?.Resolve(space, name)?.Identity ?? name;
    internal FirmamentV2SourceSpan OriginalSpan(FirmamentV2SourceSpan span)
    {
        int Position(int position)
        {
            var delta = 0;
            foreach (var edit in edits)
            {
                var start = edit.Span.Start + delta;
                if (position < start) break;
                if (position <= start + edit.Text.Length) return edit.Span.Start + Math.Min(position - start, edit.Span.Length);
                delta += edit.Text.Length - edit.Span.Length;
            }
            return position - delta;
        }
        var start = Position(span.Start); return new(start, Math.Max(0, Position(span.Start + span.Length) - start));
    }
}