MycLib/Src/AST/Myc.Ast.Lowering.pas

unit Myc.Ast.Lowering;

interface

uses
    System.SysUtils,
    System.Classes,
    System.Generics.Collections,
    Myc.Data.Scalar,
    Myc.Data.Value,
    Myc.Ast.Nodes,
    Myc.Ast.Visitor,
    Myc.Ast.Scope,
    Myc.Ast.Types,
    Myc.Ast;

type
    IAstLowerer = interface(IAstVisitor)
        function Execute(const RootNode: IAstNode): IAstNode;
    end;

    // This transformer runs *after* TypeChecker (Phase 3).
    // It "lowers" the AST by rewriting complex nodes into simpler ones
    // that the evaluator can understand (e.g., operator folding).
    TAstLowerer = class(TAstTransformer, IAstLowerer)
    private
        FBinaryOperators: TDictionary<string, TScalar.TBinaryOp>;
        FUnaryOperators: TDictionary<string, TScalar.TUnaryOp>;
        function SetType(const Node: IAstNode; const AType: IStaticType): IAstNode;
    protected
        // Override to find nodes to lower
        function VisitFunctionCall(const Node: IFunctionCallNode): IAstNode; override;
    public
        constructor Create;
        destructor Destroy; override;
        function Execute(const RootNode: IAstNode): IAstNode;

        class function Lower(const RootNode: IAstNode): IAstNode; static;
    end;

implementation

uses
    System.Generics.Defaults,
    Myc.Data.Keyword;

{ TAstLowerer }

constructor TAstLowerer.Create;
var
    op: TScalar.TBinaryOp;
    uOp: TScalar.TUnaryOp; // Added for unary
begin
    inherited Create;

    // Operator folding maps
    FBinaryOperators := TDictionary<string, TScalar.TBinaryOp>.Create;
    for op := Low(TScalar.TBinaryOp) to High(TScalar.TBinaryOp) do
        FBinaryOperators.Add(op.ToString, op);

    FUnaryOperators := TDictionary<string, TScalar.TUnaryOp>.Create;
    for uOp := Low(TScalar.TUnaryOp) to High(TScalar.TUnaryOp) do // Changed
        FUnaryOperators.Add(uOp.ToString, uOp);
    // Note: '-' is handled as a special case in VisitFunctionCall
end;

destructor TAstLowerer.Destroy;
begin
    FUnaryOperators.Free;
    FBinaryOperators.Free;
    inherited;
end;

class function TAstLowerer.Lower(const RootNode: IAstNode): IAstNode;
begin
    var lowerer := TAstLowerer.Create as IAstLowerer;
    Result := lowerer.Execute(RootNode);
end;

function TAstLowerer.Execute(const RootNode: IAstNode): IAstNode;
begin
    Result := Accept(RootNode); // Use IAstNode-returning Accept
    if not Assigned(Result) then
        Result := TAst.Block([]);

    if Assigned(Result) then
        (Result as TAstNode).StaticType := (Result as TAstNode).StaticType;
end;

function TAstLowerer.SetType(const Node: IAstNode; const AType: IStaticType): IAstNode;
begin
    if Assigned(Node) then // Add nil check for safety
        (Node as TAstNode).StaticType := AType;
    Result := Node;
end;

function TAstLowerer.VisitFunctionCall(const Node: IFunctionCallNode): IAstNode;
var
    calleeIdentifier: TIdentifierNode;
    binaryOp: TScalar.TBinaryOp;
    unaryOp: TScalar.TUnaryOp;
    left, right: IAstNode;
begin
    // --- Optimization: Operator Folding ---
    if (Node.Callee is TIdentifierNode) then
    begin
        calleeIdentifier := Node.Callee as TIdentifierNode;

        if (Length(Node.Arguments) = 2) then
        begin
            if FBinaryOperators.TryGetValue(calleeIdentifier.Name, binaryOp) then
            begin
                // Note: We MUST visit children *before* creating the new node
                left := Accept(Node.Arguments[0]);
                right := Accept(Node.Arguments[1]);
                var binExpr := TAst.BinaryExpr(left, binaryOp, right);
                // Copy metadata (StaticType) from old node to new node
                Result := SetType(binExpr, (Node as TAstNode).StaticType);
                exit;
            end;
        end;

        if (Length(Node.Arguments) = 1) then
        begin
            if FUnaryOperators.TryGetValue(calleeIdentifier.Name, unaryOp) then
            begin
                right := Accept(Node.Arguments[0]);
                var unExpr := TAst.UnaryExpr(unaryOp, right);
                // Copy metadata
                Result := SetType(unExpr, (Node as TAstNode).StaticType);
                exit;
            end;

            if (calleeIdentifier.Name = '-') then
            begin
                right := Accept(Node.Arguments[0]);
                var unExpr := TAst.UnaryExpr(TScalar.TUnaryOp.Negate, right);
                // Copy metadata
                Result := SetType(unExpr, (Node as TAstNode).StaticType);
                exit;
            end;
        end;
    end;

    // If no rewrite matched, continue traversal using the base implementation
    Result := inherited VisitFunctionCall(Node);
end;

end.