Binder refactoring, Monster refactoring
This commit is contained in:
Michael Schimmel
+137
-295
@@ -36,30 +36,24 @@ type
|
||||
procedure EnterScope;
|
||||
procedure ExitScope;
|
||||
function IsValidIdentifier(const Name: string): Boolean;
|
||||
function SetType(const NodeData: TDataValue; const AType: IStaticType): TDataValue; overload;
|
||||
|
||||
protected
|
||||
function VisitIdentifier(const Node: IIdentifierNode): TDataValue; override;
|
||||
function VisitKeyword(const Node: IKeywordNode): TDataValue; override;
|
||||
function VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue; override;
|
||||
function VisitAssignment(const Node: IAssignmentNode): TDataValue; override;
|
||||
function VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue; override;
|
||||
function VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue; override;
|
||||
function VisitFunctionCall(const Node: IFunctionCallNode): TDataValue; override;
|
||||
function VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue; override;
|
||||
function VisitRecurNode(const Node: IRecurNode): TDataValue; override;
|
||||
function VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue; override;
|
||||
function VisitIfExpression(const Node: IIfExpressionNode): TDataValue; override;
|
||||
function VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue; override;
|
||||
function VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue; override;
|
||||
function VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue; override;
|
||||
function VisitConstant(const Node: IConstantNode): TDataValue; override;
|
||||
function VisitMemberAccess(const Node: IMemberAccessNode): TDataValue; override;
|
||||
function VisitIndexer(const Node: IIndexerNode): TDataValue; override;
|
||||
function VisitRecordLiteral(const Node: IRecordLiteralNode): TDataValue; override;
|
||||
function VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue; override;
|
||||
function VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue; override;
|
||||
function VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue; override;
|
||||
// --- Core Binding Logic (Mutators) ---
|
||||
function VisitIdentifier(const Node: IIdentifierNode): IAstNode; override;
|
||||
function VisitVariableDeclaration(const Node: IVariableDeclarationNode): IAstNode; override;
|
||||
function VisitLambdaExpression(const Node: ILambdaExpressionNode): IAstNode; override;
|
||||
// --- Transformation Logic ---
|
||||
function VisitFunctionCall(const Node: IFunctionCallNode): IAstNode; override;
|
||||
|
||||
// --- Standard Traversal (Use inherited) ---
|
||||
function VisitKeyword(const Node: IKeywordNode): IAstNode; override;
|
||||
function VisitMacroDefinition(const Node: IMacroDefinitionNode): IAstNode; override;
|
||||
function VisitMacroExpansionNode(const Node: IMacroExpansionNode): IAstNode; override;
|
||||
function VisitRecurNode(const Node: IRecurNode): IAstNode; override;
|
||||
function VisitConstant(const Node: IConstantNode): IAstNode; override;
|
||||
function VisitCreateSeries(const Node: ICreateSeriesNode): IAstNode; override;
|
||||
function VisitAddSeriesItem(const Node: IAddSeriesItemNode): IAstNode; override;
|
||||
function VisitSeriesLength(const Node: ISeriesLengthNode): IAstNode; override;
|
||||
|
||||
public
|
||||
constructor Create(const AInitialScope: IExecutionScope);
|
||||
@@ -78,8 +72,7 @@ implementation
|
||||
uses
|
||||
System.Generics.Defaults,
|
||||
System.Character,
|
||||
Myc.Data.Keyword,
|
||||
Myc.Ast.Binding.Nodes;
|
||||
Myc.Data.Keyword;
|
||||
|
||||
type
|
||||
TResolvedAddressComparer = class(TEqualityComparer<TResolvedAddress>)
|
||||
@@ -111,7 +104,7 @@ begin
|
||||
|
||||
FInitialScope := AInitialScope;
|
||||
FCurrentDescriptor := AInitialScope.CreateDescriptor;
|
||||
FUpvalueStack := TObjectStack<TUpvalueMapping>.Create(True);
|
||||
FUpvalueStack := TObjectStack<TUpvalueMapping>.Create(True); // Use Comparer
|
||||
FNestedLambdaCount := 0;
|
||||
FBoxedDeclarations := nil;
|
||||
end;
|
||||
@@ -123,13 +116,6 @@ begin
|
||||
inherited;
|
||||
end;
|
||||
|
||||
function TAstBinder.SetType(const NodeData: TDataValue; const AType: IStaticType): TDataValue;
|
||||
begin
|
||||
if (not NodeData.IsVoid) and (NodeData.Kind = vkInterface) then
|
||||
(NodeData.AsIntf<IAstNode> as TAstNode).StaticType := AType;
|
||||
Result := NodeData;
|
||||
end;
|
||||
|
||||
class function TAstBinder.Bind(const InitialScope: IExecutionScope; const RootNode: IAstNode; out Descriptor: IScopeDescriptor): IAstNode;
|
||||
begin
|
||||
var binder := TAstBinder.Create(InitialScope) as IAstBinder;
|
||||
@@ -165,40 +151,42 @@ end;
|
||||
|
||||
function TAstBinder.Execute(const RootNode: IAstNode; out Descriptor: IScopeDescriptor): IAstNode;
|
||||
begin
|
||||
// Pre-pass: Find all variables that need boxing
|
||||
FBoxedDeclarations := TUpvalueAnalyzer.Analyze(RootNode, FCurrentDescriptor.Parent);
|
||||
try
|
||||
EnterScope;
|
||||
try
|
||||
var transformedValue := Accept(RootNode);
|
||||
if transformedValue.IsVoid then
|
||||
Result := TAst.Block([])
|
||||
else
|
||||
Result := transformedValue.AsIntf<IAstNode>;
|
||||
// Main pass: Run the mutator
|
||||
Result := Accept(RootNode); // Accept returns IAstNode
|
||||
if not Assigned(Result) then
|
||||
Result := TAst.Block([]);
|
||||
|
||||
// Set the type of the root expression (e.g., the final 'do' block)
|
||||
(Result as TAstNode).StaticType := TTypes.Unknown;
|
||||
Descriptor := FCurrentDescriptor;
|
||||
finally
|
||||
ExitScope;
|
||||
end;
|
||||
finally
|
||||
FBoxedDeclarations.Free; // Free the set
|
||||
FBoxedDeclarations := nil;
|
||||
end;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue;
|
||||
function TAstBinder.VisitMacroDefinition(const Node: IMacroDefinitionNode): IAstNode;
|
||||
begin
|
||||
// Macros are compile-time only. The Binder (Phase 2) should not see them.
|
||||
raise Exception.Create('TMyAstBinder: MacroDefinition node encountered.');
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue;
|
||||
function TAstBinder.VisitMacroExpansionNode(const Node: IMacroExpansionNode): IAstNode;
|
||||
begin
|
||||
// The MacroExpander (Phase 1) should have unwrapped this.
|
||||
// We only visit the *expanded* body.
|
||||
Result := Accept(Node.ExpandedBody);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitFunctionCall(const Node: IFunctionCallNode): TDataValue;
|
||||
var
|
||||
boundCall: TBoundFunctionCallNode;
|
||||
callee: IAstNode;
|
||||
args: TArray<IAstNode>;
|
||||
function TAstBinder.VisitFunctionCall(const Node: IFunctionCallNode): IAstNode;
|
||||
begin
|
||||
// --- Transformation: Keyword-as-Function ---
|
||||
if (Node.Callee is TKeywordNode) then
|
||||
@@ -209,105 +197,44 @@ begin
|
||||
'Keyword :%s expects exactly one argument (the record/map), but got %d',
|
||||
[keywordNode.Value.Name, Length(Node.Arguments)]);
|
||||
|
||||
var baseNode := Accept(Node.Arguments[0]).AsIntf<IAstNode>;
|
||||
// Manually visit the argument, as we are replacing this node
|
||||
var baseNode := Accept(Node.Arguments[0]);
|
||||
var memberAccessNode := TAst.MemberAccess(baseNode, keywordNode);
|
||||
|
||||
// Visit the *new* node to bind it
|
||||
Result := Accept(memberAccessNode);
|
||||
exit;
|
||||
end;
|
||||
|
||||
// --- Default: Bind as a standard function call ---
|
||||
callee := Accept(Node.Callee).AsIntf<IAstNode>;
|
||||
args := AcceptNodes<IAstNode>(Node.Arguments);
|
||||
// Use the inherited implementation to visit children (Callee, Arguments)
|
||||
// and mutate their properties in place.
|
||||
Result := inherited VisitFunctionCall(Node);
|
||||
|
||||
// Create the node, always marking IsTailCall as false.
|
||||
// The Lowerer (Phase 4) will set this flag correctly.
|
||||
boundCall := TBoundFunctionCallNode.Create(Node, callee, args, False);
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IFunctionCallNode>(boundCall), TTypes.Unknown);
|
||||
// Set metadata for *this* node
|
||||
(Node as TFunctionCallNode).IsTailCall := False; // Default, TCO (Phase 5) will set this
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitAssignment(const Node: IAssignmentNode): TDataValue;
|
||||
var
|
||||
boundIdentifier, boundValue: IAstNode;
|
||||
boundNode: IAssignmentNode;
|
||||
begin
|
||||
boundIdentifier := Accept(Node.Identifier).AsIntf<IAstNode>;
|
||||
boundValue := Accept(Node.Value).AsIntf<IAstNode>;
|
||||
boundNode := TAst.Assign(boundIdentifier as TBoundIdentifierNode, boundValue);
|
||||
Result := SetType(TDataValue.FromIntf<IAssignmentNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue;
|
||||
var
|
||||
left, right: IAstNode;
|
||||
boundNode: IBinaryExpressionNode;
|
||||
begin
|
||||
left := Accept(Node.Left).AsIntf<IAstNode>;
|
||||
right := Accept(Node.Right).AsIntf<IAstNode>;
|
||||
boundNode := TAst.BinaryExpr(left, Node.Operator, right);
|
||||
Result := SetType(TDataValue.FromIntf<IBinaryExpressionNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue;
|
||||
var
|
||||
exprs: TArray<IAstNode>;
|
||||
i: Integer;
|
||||
transformedValue: TDataValue;
|
||||
exprList: TList<IAstNode>;
|
||||
boundNode: IBlockExpressionNode;
|
||||
begin
|
||||
exprList := TList<IAstNode>.Create;
|
||||
try
|
||||
for i := 0 to High(Node.Expressions) do
|
||||
begin
|
||||
transformedValue := Accept(Node.Expressions[i]);
|
||||
if not transformedValue.IsVoid then
|
||||
exprList.Add(transformedValue.AsIntf<IAstNode>);
|
||||
end;
|
||||
exprs := exprList.ToArray;
|
||||
finally
|
||||
exprList.Free;
|
||||
end;
|
||||
|
||||
if (Length(exprs) = Length(Node.Expressions)) then
|
||||
begin
|
||||
var same := True;
|
||||
for i := 0 to High(exprs) do
|
||||
if exprs[i] <> Node.Expressions[i] then
|
||||
begin
|
||||
same := False;
|
||||
break;
|
||||
end;
|
||||
if same then
|
||||
boundNode := Node
|
||||
else
|
||||
boundNode := TAst.Block(exprs);
|
||||
end
|
||||
else
|
||||
boundNode := TAst.Block(exprs);
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IBlockExpressionNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitConstant(const Node: IConstantNode): TDataValue;
|
||||
function TAstBinder.VisitConstant(const Node: IConstantNode): IAstNode;
|
||||
begin
|
||||
// Set type (Phase 3)
|
||||
case Node.Value.Kind of
|
||||
TDataValueKind.vkScalar:
|
||||
Result := SetType(TDataValue.FromIntf<IConstantNode>(Node), TTypes.FromScalarKind(Node.Value.AsScalar.Kind));
|
||||
TDataValueKind.vkText: Result := SetType(TDataValue.FromIntf<IConstantNode>(Node), TTypes.Text);
|
||||
TDataValueKind.vkVoid: Result := SetType(TDataValue.FromIntf<IConstantNode>(Node), TTypes.Void);
|
||||
TDataValueKind.vkScalar: (Node as TAstNode).StaticType := TTypes.FromScalarKind(Node.Value.AsScalar.Kind);
|
||||
TDataValueKind.vkText: (Node as TAstNode).StaticType := TTypes.Text;
|
||||
TDataValueKind.vkVoid: (Node as TAstNode).StaticType := TTypes.Void;
|
||||
else
|
||||
Result := SetType(TDataValue.FromIntf<IConstantNode>(Node), TTypes.Unknown);
|
||||
(Node as TAstNode).StaticType := TTypes.Unknown;
|
||||
end;
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitKeyword(const Node: IKeywordNode): TDataValue;
|
||||
function TAstBinder.VisitKeyword(const Node: IKeywordNode): IAstNode;
|
||||
begin
|
||||
Result := SetType(TDataValue.FromIntf<IKeywordNode>(Node), TTypes.Keyword);
|
||||
(Node as TAstNode).StaticType := TTypes.Keyword;
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue;
|
||||
function TAstBinder.VisitCreateSeries(const Node: ICreateSeriesNode): IAstNode;
|
||||
var
|
||||
elemType: IStaticType;
|
||||
begin
|
||||
@@ -317,197 +244,100 @@ begin
|
||||
on E: Exception do
|
||||
elemType := TTypes.Unknown;
|
||||
end;
|
||||
Result := SetType(TDataValue.FromIntf<ICreateSeriesNode>(Node), TTypes.CreateSeries(elemType));
|
||||
(Node as TAstNode).StaticType := TTypes.CreateSeries(elemType);
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue;
|
||||
var
|
||||
seriesNode, valueNode, lookbackNode: IAstNode;
|
||||
function TAstBinder.VisitAddSeriesItem(const Node: IAddSeriesItemNode): IAstNode;
|
||||
begin
|
||||
seriesNode := Accept(Node.Series).AsIntf<IAstNode>;
|
||||
valueNode := Accept(Node.Value).AsIntf<IAstNode>;
|
||||
if Node.Lookback <> nil then
|
||||
lookbackNode := Accept(Node.Lookback).AsIntf<IAstNode>
|
||||
else
|
||||
lookbackNode := nil;
|
||||
|
||||
var boundNode := TAst.AddSeriesItem(seriesNode as TIdentifierNode, valueNode, lookbackNode);
|
||||
Result := SetType(TDataValue.FromIntf<IAddSeriesItemNode>(boundNode), TTypes.Void);
|
||||
// Visit children
|
||||
Result := inherited VisitAddSeriesItem(Node);
|
||||
(Node as TAstNode).StaticType := TTypes.Void;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue;
|
||||
function TAstBinder.VisitSeriesLength(const Node: ISeriesLengthNode): IAstNode;
|
||||
begin
|
||||
Accept(Node.Series);
|
||||
Result := SetType(TDataValue.FromIntf<ISeriesLengthNode>(Node), TTypes.Ordinal);
|
||||
// Visit children
|
||||
Result := inherited VisitSeriesLength(Node);
|
||||
(Node as TAstNode).StaticType := TTypes.Ordinal;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitIfExpression(const Node: IIfExpressionNode): TDataValue;
|
||||
var
|
||||
condition, thenBranch, elseBranch: IAstNode;
|
||||
boundNode: IIfExpressionNode;
|
||||
begin
|
||||
condition := Accept(Node.Condition).AsIntf<IAstNode>;
|
||||
thenBranch := Accept(Node.ThenBranch).AsIntf<IAstNode>;
|
||||
if Assigned(Node.ElseBranch) then
|
||||
elseBranch := Accept(Node.ElseBranch).AsIntf<IAstNode>
|
||||
else
|
||||
elseBranch := nil;
|
||||
|
||||
if (condition <> Node.Condition) or (thenBranch <> Node.ThenBranch) or (elseBranch <> Node.ElseBranch) then
|
||||
boundNode := TAst.IfExpr(condition, thenBranch, elseBranch)
|
||||
else
|
||||
boundNode := Node;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IIfExpressionNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitIndexer(const Node: IIndexerNode): TDataValue;
|
||||
var
|
||||
baseNode, indexNode: IAstNode;
|
||||
boundNode: IIndexerNode;
|
||||
begin
|
||||
baseNode := Accept(Node.Base).AsIntf<IAstNode>;
|
||||
indexNode := Accept(Node.Index).AsIntf<IAstNode>;
|
||||
boundNode := TAst.Indexer(baseNode, indexNode);
|
||||
Result := SetType(TDataValue.FromIntf<IIndexerNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitMemberAccess(const Node: IMemberAccessNode): TDataValue;
|
||||
var
|
||||
baseNode: IAstNode;
|
||||
boundNode: IMemberAccessNode;
|
||||
begin
|
||||
baseNode := Accept(Node.Base).AsIntf<IAstNode>;
|
||||
boundNode := TAst.MemberAccess(baseNode, Node.Member);
|
||||
Result := SetType(TDataValue.FromIntf<IMemberAccessNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitRecordLiteral(const Node: IRecordLiteralNode): TDataValue;
|
||||
var
|
||||
i: Integer;
|
||||
boundFields: TArray<TRecordFieldLiteral>;
|
||||
valNode: IAstNode;
|
||||
valType: IStaticType;
|
||||
allScalar: Boolean;
|
||||
begin
|
||||
SetLength(boundFields, Length(Node.Fields));
|
||||
allScalar := True;
|
||||
|
||||
for i := 0 to High(Node.Fields) do
|
||||
begin
|
||||
valNode := Accept(Node.Fields[i].Value).AsIntf<IAstNode>;
|
||||
valType := (valNode as TAstNode).StaticType;
|
||||
|
||||
if not (valType.Kind in [stOrdinal, stFloat, stKeyword, stUnknown]) then
|
||||
allScalar := False;
|
||||
|
||||
boundFields[i] := TRecordFieldLiteral.Create(Node.Fields[i].Key, valNode);
|
||||
end;
|
||||
|
||||
if allScalar then
|
||||
begin
|
||||
var boundNode := TBoundRecordLiteralNode.Create(boundFields, nil);
|
||||
Result := SetType(TDataValue.FromIntf<IRecordLiteralNode>(boundNode), TTypes.Unknown);
|
||||
end
|
||||
else
|
||||
begin
|
||||
var genBoundNode := TBoundGenericRecordLiteralNode.Create(boundFields, nil);
|
||||
Result := SetType(TDataValue.FromIntf<IRecordLiteralNode>(genBoundNode), TTypes.Unknown);
|
||||
end;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue;
|
||||
function TAstBinder.VisitLambdaExpression(const Node: ILambdaExpressionNode): IAstNode;
|
||||
var
|
||||
i: integer;
|
||||
boundParams: TArray<IIdentifierNode>;
|
||||
boundBody: IAstNode;
|
||||
lambdaScope: IScopeDescriptor;
|
||||
upvalues: TArray<TResolvedAddress>;
|
||||
hasNestedLambdas: Boolean;
|
||||
lastNestedLambdaCount: Integer;
|
||||
boundLambda: ILambdaExpressionNode;
|
||||
N: TLambdaExpressionNode;
|
||||
adr: TResolvedAddress;
|
||||
begin
|
||||
N := (Node as TLambdaExpressionNode);
|
||||
|
||||
// We do *not* call inherited, as we must manage the scope manually.
|
||||
|
||||
FUpvalueStack.Push(TUpvalueMapping.Create(TResolvedAddressComparer.Create));
|
||||
try
|
||||
EnterScope;
|
||||
try
|
||||
// Define <self> (slot 0)
|
||||
FCurrentDescriptor.Define('<self>', TTypes.Unknown);
|
||||
|
||||
SetLength(boundParams, Length(Node.Parameters));
|
||||
for i := 0 to High(Node.Parameters) do
|
||||
// Define parameters
|
||||
for i := 0 to High(N.Parameters) do
|
||||
begin
|
||||
var paramNode := Node.Parameters[i];
|
||||
var paramNode := N.Parameters[i];
|
||||
var slotIndex := FCurrentDescriptor.Define(paramNode.Name, TTypes.Unknown);
|
||||
var address := TResolvedAddress.Create(akLocalOrParent, 0, slotIndex);
|
||||
boundParams[i] := TBoundIdentifierNode.Create(paramNode, address);
|
||||
(boundParams[i] as TAstNode).StaticType := TTypes.Unknown;
|
||||
adr := TResolvedAddress.Create(akLocalOrParent, 0, slotIndex);
|
||||
|
||||
// Mutate the parameter node with its address
|
||||
(paramNode as TIdentifierNode).Address := adr;
|
||||
(paramNode as TAstNode).StaticType := TTypes.Unknown;
|
||||
end;
|
||||
|
||||
lastNestedLambdaCount := FNestedLambdaCount;
|
||||
boundBody := Accept(Node.Body).AsIntf<IAstNode>;
|
||||
hasNestedLambdas := FNestedLambdaCount > lastNestedLambdaCount;
|
||||
lambdaScope := FCurrentDescriptor;
|
||||
// Visit the body *within the new scope*
|
||||
var lastNestedLambdaCount := FNestedLambdaCount;
|
||||
N.Body := Accept(N.Body);
|
||||
N.HasNestedLambdas := FNestedLambdaCount > lastNestedLambdaCount;
|
||||
|
||||
// Save the descriptor for the evaluator
|
||||
N.ScopeDescriptor := FCurrentDescriptor;
|
||||
finally
|
||||
ExitScope;
|
||||
end;
|
||||
|
||||
// --- Extract Upvalues ---
|
||||
var upvalueMapping := FUpvalueStack.Peek;
|
||||
var sortedPairs := upvalueMapping.ToArray;
|
||||
// Sort by index (Value)
|
||||
TArray.Sort<TPair<TResolvedAddress, Integer>>(
|
||||
sortedPairs,
|
||||
TComparer<TPair<TResolvedAddress, Integer>>.Construct(
|
||||
function(const Left, Right: TPair<TResolvedAddress, Integer>): Integer begin Result := Left.Value - Right.Value; end
|
||||
)
|
||||
);
|
||||
SetLength(upvalues, Length(sortedPairs));
|
||||
for i := 0 to High(sortedPairs) do
|
||||
upvalues[i] := sortedPairs[i].Key;
|
||||
|
||||
var uvArr: TArray<TResolvedAddress>;
|
||||
SetLength(uvArr, Length(sortedPairs));
|
||||
for i := 0 to High(uvArr) do
|
||||
uvArr[i] := sortedPairs[i].Key;
|
||||
N.Upvalues := uvArr;
|
||||
|
||||
finally
|
||||
FUpvalueStack.Pop;
|
||||
end;
|
||||
|
||||
inc(FNestedLambdaCount);
|
||||
boundLambda := TBoundLambdaExpressionNode.Create(Node, boundBody, boundParams, lambdaScope, upvalues, hasNestedLambdas);
|
||||
Result := SetType(TDataValue.FromIntf<ILambdaExpressionNode>(boundLambda), TTypes.Unknown);
|
||||
// Type will be set by TypeChecker
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitRecurNode(const Node: IRecurNode): TDataValue;
|
||||
function TAstBinder.VisitRecurNode(const Node: IRecurNode): IAstNode;
|
||||
begin
|
||||
var boundNode := TAst.Recur(AcceptNodes<IAstNode>(Node.Arguments));
|
||||
Result := SetType(TDataValue.FromIntf<IRecurNode>(boundNode), TTypes.Void);
|
||||
// Visit children
|
||||
Result := inherited VisitRecurNode(Node);
|
||||
(Node as TAstNode).StaticType := TTypes.Void; // Recur never returns a value
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue;
|
||||
var
|
||||
condition, thenBranch, elseBranch: IAstNode;
|
||||
boundNode: ITernaryExpressionNode;
|
||||
begin
|
||||
condition := Accept(Node.Condition).AsIntf<IAstNode>;
|
||||
thenBranch := Accept(Node.ThenBranch).AsIntf<IAstNode>;
|
||||
elseBranch := Accept(Node.ElseBranch).AsIntf<IAstNode>;
|
||||
|
||||
if (condition <> Node.Condition) or (thenBranch <> Node.ThenBranch) or (elseBranch <> Node.ElseBranch) then
|
||||
boundNode := TAst.TernaryExpr(condition, thenBranch, elseBranch)
|
||||
else
|
||||
boundNode := Node;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<ITernaryExpressionNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue;
|
||||
var
|
||||
right: IAstNode;
|
||||
boundNode: IUnaryExpressionNode;
|
||||
begin
|
||||
right := Accept(Node.Right).AsIntf<IAstNode>;
|
||||
boundNode := TAst.UnaryExpr(Node.Operator, right);
|
||||
Result := SetType(TDataValue.FromIntf<IUnaryExpressionNode>(boundNode), TTypes.Unknown);
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitIdentifier(const Node: IIdentifierNode): TDataValue;
|
||||
function TAstBinder.VisitIdentifier(const Node: IIdentifierNode): IAstNode;
|
||||
var
|
||||
symbol: TResolvedSymbol;
|
||||
boundNode: IIdentifierNode;
|
||||
adr: TResolvedAddress;
|
||||
begin
|
||||
symbol := FCurrentDescriptor.FindSymbol(Node.Name);
|
||||
@@ -517,52 +347,64 @@ begin
|
||||
begin
|
||||
if (adr.ScopeDepth > 0) and (FUpvalueStack.Count > 0) then
|
||||
begin
|
||||
// Handle Upvalue
|
||||
var upvalue := FUpvalueStack.Peek;
|
||||
// --- Handle Upvalue ---
|
||||
var upvalueMap := FUpvalueStack.Peek;
|
||||
// Adjust address to be relative to the captured scope
|
||||
dec(adr.ScopeDepth);
|
||||
|
||||
var upvalueIndex: Integer;
|
||||
if not upvalue.TryGetValue(adr, upvalueIndex) then
|
||||
if not upvalueMap.TryGetValue(adr, upvalueIndex) then
|
||||
begin
|
||||
upvalueIndex := upvalue.Count;
|
||||
upvalue.Add(adr, upvalueIndex);
|
||||
// This is a new upvalue for this lambda
|
||||
upvalueIndex := upvalueMap.Count;
|
||||
upvalueMap.Add(adr, upvalueIndex);
|
||||
end;
|
||||
boundNode := TBoundIdentifierNode.Create(Node, TResolvedAddress.Create(akUpvalue, 0, upvalueIndex));
|
||||
|
||||
// Mutate the node to point to the Upvalue slot
|
||||
(Node as TIdentifierNode).Address := TResolvedAddress.Create(akUpvalue, 0, upvalueIndex);
|
||||
end
|
||||
else
|
||||
// Handle LocalOrParent
|
||||
boundNode := TBoundIdentifierNode.Create(Node, adr);
|
||||
begin
|
||||
// --- Handle LocalOrParent ---
|
||||
// Mutate the node to point to the Local/Parent slot
|
||||
(Node as TIdentifierNode).Address := adr;
|
||||
end;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IIdentifierNode>(boundNode), symbol.StaticType);
|
||||
(Node as TAstNode).StaticType := symbol.StaticType; // Set type from scope
|
||||
end
|
||||
else
|
||||
raise Exception.CreateFmt('Undefined identifier: "%s"', [Node.Name]);
|
||||
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TAstBinder.VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue;
|
||||
function TAstBinder.VisitVariableDeclaration(const Node: IVariableDeclarationNode): IAstNode;
|
||||
var
|
||||
initializer: IAstNode;
|
||||
slotIndex: Integer;
|
||||
address: TResolvedAddress;
|
||||
boundIdentifier: IIdentifierNode;
|
||||
isBoxed: Boolean;
|
||||
boundDecl: IVariableDeclarationNode;
|
||||
N: TVariableDeclarationNode;
|
||||
begin
|
||||
if not IsValidIdentifier(Node.Identifier.Name) then
|
||||
raise Exception.CreateFmt('Invalid identifier name: "%s".', [Node.Identifier.Name]);
|
||||
N := (Node as TVariableDeclarationNode);
|
||||
|
||||
initializer := nil;
|
||||
if Node.Initializer <> nil then
|
||||
initializer := Accept(Node.Initializer).AsIntf<IAstNode>;
|
||||
if not IsValidIdentifier(N.Identifier.Name) then
|
||||
raise Exception.CreateFmt('Invalid identifier name: "%s".', [N.Identifier.Name]);
|
||||
|
||||
slotIndex := FCurrentDescriptor.Define(Node.Identifier.Name, TTypes.Unknown);
|
||||
// 1. Visit initializer *first*
|
||||
if Assigned(N.Initializer) then
|
||||
N.Initializer := Accept(N.Initializer);
|
||||
|
||||
// 2. Define variable in *current* scope
|
||||
slotIndex := FCurrentDescriptor.Define(N.Identifier.Name, TTypes.Unknown);
|
||||
address := TResolvedAddress.Create(akLocalOrParent, 0, slotIndex);
|
||||
boundIdentifier := TBoundIdentifierNode.Create(Node.Identifier, address);
|
||||
(boundIdentifier as TAstNode).StaticType := TTypes.Unknown;
|
||||
|
||||
isBoxed := (FBoxedDeclarations <> nil) and FBoxedDeclarations.Contains(Node);
|
||||
boundDecl := TBoundVariableDeclarationNode.Create(boundIdentifier, initializer, isBoxed);
|
||||
// 3. Mutate the Identifier node (which is NOT visited by inherited call)
|
||||
(N.Identifier as TIdentifierNode).Address := address;
|
||||
(N.Identifier as TAstNode).StaticType := TTypes.Unknown; // TypeChecker will set this
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IVariableDeclarationNode>(boundDecl), TTypes.Unknown);
|
||||
// 4. Mutate this declaration node
|
||||
N.IsBoxed := (FBoxedDeclarations <> nil) and FBoxedDeclarations.Contains(Node);
|
||||
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
end.
|
||||
|
||||
Reference in New Issue
Block a user