Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

6.6 KB
Raw Blame
using Aetheris.Kernel.Firmament.FirmamentV2.FirmamentInterop;
using System.Globalization;

namespace Aetheris.Kernel.Firmament.FirmamentV2.Syntax;

/// <summary>Consumption of an existing declaration tree by its semantic owner.
/// This is not a parser or a field schema. Owners take their fields/children,
/// then close the tree; every remaining statement is an error.</summary>
public sealed class FirmamentSyntaxScope
{
    private readonly string source;
    private readonly string sourceFile;
    private readonly Func<ExpressionSyntax, ExpressionSyntax>? bind;
    private readonly Func<FirmamentV2SourceSpan, FirmamentV2SourceSpan?>? origin;
    private readonly List<FirmamentSyntaxScope> scopes;
    private readonly Dictionary<DeclarationSyntax, FirmamentSyntaxScope> children = [];
    private readonly HashSet<StatementSyntax> consumed = [];
    private readonly List<string> errors = [];
    private readonly FirmamentSyntaxFields fields;
    private readonly HashSet<string> modifiers = new(StringComparer.Ordinal);
    private bool admitAnnotation;
    private bool admitInitializer;
    private bool admitPlacement;
    public FirmamentSyntaxScope AdmitPlacement() { admitPlacement=true; return this; }
    public FirmamentSyntaxScope AdmitAnnotation() { admitAnnotation=true; return this; }
    public FirmamentSyntaxScope AdmitInitializer() { admitInitializer=true; return this; }
    public DeclarationSyntax Declaration { get; }
    public string Name => Declaration.Name?.Text ?? Declaration.Type.Name.Text;
    public string Kind => Declaration.Type.Name.Text;
    public FirmamentV2SourceSpan Span => Declaration.Span;
    public int Start => Span.Start;
    public int Length => Span.Length;
    public FirmamentSyntaxScope Body => this;

    public FirmamentSyntaxScope(DeclarationSyntax declaration, string source, string sourceFile = "memory",
        Func<ExpressionSyntax, ExpressionSyntax>? bind = null,
        Func<FirmamentV2SourceSpan, FirmamentV2SourceSpan?>? origin = null)
        : this(declaration, source, sourceFile, bind, origin, []) { }

    private FirmamentSyntaxScope(DeclarationSyntax declaration, string source, string sourceFile,
        Func<ExpressionSyntax, ExpressionSyntax>? bind, Func<FirmamentV2SourceSpan, FirmamentV2SourceSpan?>? origin,
        List<FirmamentSyntaxScope> scopes)
    {
        Declaration = declaration; this.source = source; this.sourceFile = sourceFile;
        this.bind = bind; this.origin = origin; this.scopes = scopes; scopes.Add(this);
        fields = new(declaration, errors, bind: bind);
    }
    public FirmamentSyntaxScope AllowModifier(string modifier) { modifiers.Add(modifier); return this; }
    public IReadOnlyList<FirmamentSyntaxScope> Children(string kind, bool legacyCase = false)
    {
        var result = new List<FirmamentSyntaxScope>();
        foreach (var child in Declaration.Body?.Statements.OfType<DeclarationSyntax>() ?? [])
        {
            if (!string.Equals(child.Type.Name.Text, kind, legacyCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) continue;
            consumed.Add(child);
            if (!children.TryGetValue(child, out var scope)) children[child] = scope = new(child, source, sourceFile, bind, origin, scopes);
            result.Add(scope);
        }
        return result;
    }
    public void Consume(StatementSyntax statement) => consumed.Add(statement);
    private static string Canonical(string name) => name.Length == 0 ? name : char.ToUpperInvariant(name[0]) + name[1..];
    public ExpressionSyntax? Take(string name) => fields.Take(Canonical(name));
    public IReadOnlyList<FieldSyntax> TakeAll(string name) => fields.TakeAll(Canonical(name)).Select(f=>f with { Value=bind?.Invoke(f.Value)??f.Value }).ToArray();
    public string? Word(string name) => fields.Reference(Canonical(name));
    public string? Raw(string name)
    {
        var authored = Declaration.Body?.Statements.OfType<FieldSyntax>().FirstOrDefault(f => FirmamentSyntaxFields.SameField(f.Name.Text, Canonical(name)));
        var expression = Take(name);
        if (expression is null) return null;
        var text = FirmamentSyntaxWriter.Expression(expression);
        if (authored is not null && text == FirmamentSyntaxWriter.Expression(authored.Value))
            return source.Substring(authored.Value.Span.Start, authored.Value.Span.Length);
        if (FirmamentNumericEvaluation.TryEvaluate(expression, out var number) && double.IsFinite(number.Number))
            return number.Number.ToString("R", CultureInfo.InvariantCulture) + number.Unit;
        return text;
    }
    public void Invalid(string name, string? message = null) => errors.Add($"firmament-v2-field-value-invalid:{Kind}:{name}" + (message is null ? "" : ": " + message));
    public IReadOnlyList<FirmamentV2ValidationDiagnostic> CompleteTree()
    {
        var diagnostics = new List<FirmamentV2ValidationDiagnostic>();
        foreach (var scope in scopes)
        {
            if (scope.Declaration.Type.Arguments.Count != 0 || scope.Declaration.HasParameterList
                || scope.Declaration.Modifiers.Any(m => !scope.modifiers.Contains(m.Name.Text)))
                scope.errors.Add($"{FirmamentV2Parser.CanonicalDeclarationUnknown}:{scope.Kind}:header");
            scope.fields.Complete(scope.consumed, scope.admitAnnotation, scope.admitInitializer, scope.admitPlacement);
            foreach (var code in scope.errors.Distinct(StringComparer.Ordinal))
            {
                var parts = code.Split(':');
                var label = parts.Length > 2 ? parts[2] : "";
                var field = scope.Declaration.Body?.Statements.OfType<FieldSyntax>().FirstOrDefault(f => FirmamentSyntaxFields.SameField(f.Name.Text, label));
                var child = scope.Declaration.Body?.Statements.OfType<DeclarationSyntax>().FirstOrDefault(d => d.Type.Name.Text == label);
                var span = field?.Name.Span ?? child?.Span ?? scope.Span;
                var mapped = origin?.Invoke(span) ?? (origin is null ? span : null);
                var explanation=code.IndexOf(": ",StringComparison.Ordinal);
                var message=FirmamentV2DiagnosticAdapter.MessageFor(code)+(explanation<0?"":" "+code[(explanation+2)..]);
                diagnostics.Add(new(parts[0], "error", message, label, scope.Kind + " " + scope.Name)
                { SourceFile = sourceFile, SourceSpan = mapped, IsOriginalSource = mapped is not null, Stage = "Binding",
                    LocationNote = mapped is null ? "Original-source provenance is unavailable after expansion." : mapped != span ? "Location identifies the original enclosing construct after compile-time expansion." : null });
            }
        }
        return diagnostics;
    }
}