Binder refactoring, Monster refactoring
This commit is contained in:
Michael Schimmel
+196
-176
@@ -12,8 +12,7 @@ uses
|
||||
Myc.Ast.Visitor,
|
||||
Myc.Ast.Scope,
|
||||
Myc.Ast.Types,
|
||||
Myc.Ast,
|
||||
Myc.Ast.Binding.Nodes;
|
||||
Myc.Ast;
|
||||
|
||||
type
|
||||
IAstTypeChecker = interface(IAstVisitor)
|
||||
@@ -27,33 +26,34 @@ type
|
||||
TTypeChecker = class(TAstTransformer, IAstTypeChecker)
|
||||
private
|
||||
FCurrentDescriptor: IScopeDescriptor;
|
||||
function SetType(const NodeData: TDataValue; const AType: IStaticType): TDataValue;
|
||||
function SetType(const Node: IAstNode; const AType: IStaticType): IAstNode;
|
||||
protected
|
||||
// Override all visit methods to perform type checking
|
||||
function VisitIdentifier(const Node: IIdentifierNode): TDataValue; override;
|
||||
function VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue; override;
|
||||
function VisitAssignment(const Node: IAssignmentNode): TDataValue; override;
|
||||
function VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue; override;
|
||||
function VisitFunctionCall(const Node: IFunctionCallNode): 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 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;
|
||||
function VisitRecurNode(const Node: IRecurNode): TDataValue; override;
|
||||
function VisitIdentifier(const Node: IIdentifierNode): IAstNode; override;
|
||||
function VisitVariableDeclaration(const Node: IVariableDeclarationNode): IAstNode; override;
|
||||
function VisitAssignment(const Node: IAssignmentNode): IAstNode; override;
|
||||
function VisitLambdaExpression(const Node: ILambdaExpressionNode): IAstNode; override;
|
||||
function VisitFunctionCall(const Node: IFunctionCallNode): IAstNode; override;
|
||||
function VisitBlockExpression(const Node: IBlockExpressionNode): IAstNode; override;
|
||||
function VisitIfExpression(const Node: IIfExpressionNode): IAstNode; override;
|
||||
function VisitTernaryExpression(const Node: ITernaryExpressionNode): IAstNode; override;
|
||||
function VisitBinaryExpression(const Node: IBinaryExpressionNode): IAstNode; override;
|
||||
function VisitUnaryExpression(const Node: IUnaryExpressionNode): IAstNode; override;
|
||||
function VisitMemberAccess(const Node: IMemberAccessNode): IAstNode; override;
|
||||
function VisitIndexer(const Node: IIndexerNode): IAstNode; override;
|
||||
function VisitRecordLiteral(const Node: IRecordLiteralNode): IAstNode; override;
|
||||
function VisitCreateSeries(const Node: ICreateSeriesNode): IAstNode; override;
|
||||
function VisitAddSeriesItem(const Node: IAddSeriesItemNode): IAstNode; override;
|
||||
function VisitSeriesLength(const Node: ISeriesLengthNode): IAstNode; override;
|
||||
function VisitRecurNode(const Node: IRecurNode): IAstNode; override;
|
||||
|
||||
// Base cases (types are already set by Binder)
|
||||
function VisitConstant(const Node: IConstantNode): IAstNode; override;
|
||||
function VisitKeyword(const Node: IKeywordNode): IAstNode; override;
|
||||
|
||||
// Base cases (types are already known from binder)
|
||||
function VisitConstant(const Node: IConstantNode): TDataValue; override;
|
||||
function VisitKeyword(const Node: IKeywordNode): TDataValue; override;
|
||||
// Compile-time nodes (should not be present)
|
||||
function VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue; override;
|
||||
function VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue; override;
|
||||
function VisitMacroExpansionNode(const Node: IMacroExpansionNode): IAstNode; override;
|
||||
function VisitMacroDefinition(const Node: IMacroDefinitionNode): IAstNode; override;
|
||||
public
|
||||
constructor Create(const ADescriptor: IScopeDescriptor);
|
||||
function Execute(const RootNode: IAstNode; const ADescriptor: IScopeDescriptor): IAstNode;
|
||||
@@ -85,165 +85,166 @@ end;
|
||||
function TTypeChecker.Execute(const RootNode: IAstNode; const ADescriptor: IScopeDescriptor): IAstNode;
|
||||
begin
|
||||
FCurrentDescriptor := ADescriptor;
|
||||
var transformedValue := Accept(RootNode);
|
||||
if transformedValue.IsVoid then
|
||||
Result := TAst.Block([])
|
||||
else
|
||||
Result := transformedValue.AsIntf<IAstNode>;
|
||||
(Result as TAstNode).StaticType := (Result as TAstNode).StaticType;
|
||||
Result := Accept(RootNode); // Use IAstNode-returning Accept
|
||||
if not Assigned(Result) then
|
||||
Result := TAst.Block([]);
|
||||
|
||||
// (Result as TAstNode).StaticType is set by the last Visit call
|
||||
end;
|
||||
|
||||
function TTypeChecker.SetType(const NodeData: TDataValue; const AType: IStaticType): TDataValue;
|
||||
function TTypeChecker.SetType(const Node: IAstNode; const AType: IStaticType): IAstNode;
|
||||
begin
|
||||
if (not NodeData.IsVoid) and (NodeData.Kind = vkInterface) then
|
||||
(NodeData.AsIntf<IAstNode> as TAstNode).StaticType := AType;
|
||||
Result := NodeData;
|
||||
if Assigned(Node) then
|
||||
(Node as TAstNode).StaticType := AType;
|
||||
Result := Node;
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitConstant(const Node: IConstantNode): TDataValue;
|
||||
function TTypeChecker.VisitConstant(const Node: IConstantNode): IAstNode;
|
||||
begin
|
||||
// Type was set by Binder, just propagate it up.
|
||||
Result := TDataValue.FromIntf<IConstantNode>(Node);
|
||||
Result := inherited VisitConstant(Node);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitKeyword(const Node: IKeywordNode): TDataValue;
|
||||
function TTypeChecker.VisitKeyword(const Node: IKeywordNode): IAstNode;
|
||||
begin
|
||||
// Type was set by Binder, just propagate it up.
|
||||
Result := TDataValue.FromIntf<IKeywordNode>(Node);
|
||||
Result := inherited VisitKeyword(Node);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitIdentifier(const Node: IIdentifierNode): TDataValue;
|
||||
function TTypeChecker.VisitIdentifier(const Node: IIdentifierNode): IAstNode;
|
||||
begin
|
||||
// Type was set by Binder (read from scope), just propagate it up.
|
||||
Result := TDataValue.FromIntf<IIdentifierNode>(Node);
|
||||
Result := inherited VisitIdentifier(Node);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitRecurNode(const Node: IRecurNode): TDataValue;
|
||||
function TTypeChecker.VisitRecurNode(const Node: IRecurNode): IAstNode;
|
||||
begin
|
||||
// Type was set by Binder (TTypes.Void), just propagate it up.
|
||||
Result := TDataValue.FromIntf<IRecurNode>(Node);
|
||||
Result := inherited VisitRecurNode(Node);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue;
|
||||
function TTypeChecker.VisitMacroDefinition(const Node: IMacroDefinitionNode): IAstNode;
|
||||
begin
|
||||
raise Exception.Create('TTypeChecker: MacroDefinition node encountered.');
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue;
|
||||
function TTypeChecker.VisitMacroExpansionNode(const Node: IMacroExpansionNode): IAstNode;
|
||||
begin
|
||||
raise Exception.Create('TTypeChecker: MacroExpansionNode node encountered.');
|
||||
// TypeChecker runs *after* expansion, so we just visit the body.
|
||||
Result := Accept(Node.ExpandedBody);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue;
|
||||
function TTypeChecker.VisitVariableDeclaration(const Node: IVariableDeclarationNode): IAstNode;
|
||||
var
|
||||
initNode: IAstNode;
|
||||
initType: IStaticType;
|
||||
boundIdent: TBoundIdentifierNode;
|
||||
boundIdent: TIdentifierNode;
|
||||
adr: TResolvedAddress;
|
||||
begin
|
||||
// 1. Visit the initializer (if it exists) to get its (now-inferred) type.
|
||||
// 1. Visit children first (Identifier is leaf, Initializer is traversed)
|
||||
inherited;
|
||||
|
||||
// 2. Get initializer type
|
||||
if Assigned(Node.Initializer) then
|
||||
begin
|
||||
initNode := Accept(Node.Initializer).AsIntf<IAstNode>;
|
||||
initType := (initNode as TAstNode).StaticType;
|
||||
end
|
||||
initType := (Node.Initializer as TAstNode).StaticType
|
||||
else
|
||||
initType := TTypes.Void;
|
||||
|
||||
// 2. Get the address from the bound identifier.
|
||||
boundIdent := (Node.Identifier as TBoundIdentifierNode);
|
||||
// 3. Get the address from the bound identifier.
|
||||
boundIdent := (Node.Identifier as TIdentifierNode);
|
||||
adr := boundIdent.Address;
|
||||
|
||||
// 3. Update the type in the scope descriptor (which was set to Unknown by the binder).
|
||||
// 4. Update the type in the scope descriptor (which was set to Unknown by the binder).
|
||||
FCurrentDescriptor.UpdateType(adr.SlotIndex, initType);
|
||||
|
||||
// 4. Update the static types of the nodes themselves.
|
||||
// 5. Update the static types of the nodes themselves.
|
||||
(boundIdent as TAstNode).StaticType := initType;
|
||||
Result := SetType(TDataValue.FromIntf(Node), initType);
|
||||
Result := SetType(Node, initType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitAssignment(const Node: IAssignmentNode): TDataValue;
|
||||
function TTypeChecker.VisitAssignment(const Node: IAssignmentNode): IAstNode;
|
||||
var
|
||||
boundIdentifier, boundValue: IAstNode;
|
||||
targetType, sourceType: IStaticType;
|
||||
begin
|
||||
boundIdentifier := Accept(Node.Identifier).AsIntf<IAstNode>;
|
||||
boundValue := Accept(Node.Value).AsIntf<IAstNode>;
|
||||
// 1. Visit children first (Identifier, Value)
|
||||
inherited;
|
||||
|
||||
targetType := (boundIdentifier as TAstNode).StaticType;
|
||||
sourceType := (boundValue as TAstNode).StaticType;
|
||||
// 2. Get types
|
||||
targetType := (Node.Identifier as TAstNode).StaticType;
|
||||
sourceType := (Node.Value as TAstNode).StaticType;
|
||||
|
||||
// 3. Check assignment
|
||||
if not TTypeRules.CanAssign(targetType, sourceType) then
|
||||
raise ETypeException.CreateFmt('Cannot assign type %s to %s', [sourceType.ToString, targetType.ToString]);
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IAssignmentNode>(Node), targetType);
|
||||
Result := SetType(Node, targetType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitLambdaExpression(const Node: ILambdaExpressionNode): IAstNode;
|
||||
var
|
||||
boundNode: TBoundLambdaExpressionNode;
|
||||
boundBody: IAstNode;
|
||||
boundNode: TLambdaExpressionNode;
|
||||
bodyType, methodType: IStaticType;
|
||||
paramTypes: TArray<IStaticType>;
|
||||
i: Integer;
|
||||
savedDescriptor: IScopeDescriptor;
|
||||
begin
|
||||
boundNode := (Node as TBoundLambdaExpressionNode);
|
||||
boundNode := (Node as TLambdaExpressionNode);
|
||||
|
||||
// 1. Enter the lambda's scope
|
||||
// 1. Enter the lambda's scope (which Binder already created)
|
||||
savedDescriptor := FCurrentDescriptor;
|
||||
FCurrentDescriptor := boundNode.ScopeDescriptor;
|
||||
try
|
||||
// 2. Set parameter types (currently Unknown, but required for signature)
|
||||
// 2. Parameters are leaves, so we don't try to evaluate them
|
||||
|
||||
// 3. Get parameter types (currently Unknown, but required for signature)
|
||||
SetLength(paramTypes, Length(boundNode.Parameters));
|
||||
for i := 0 to High(boundNode.Parameters) do
|
||||
paramTypes[i] := (boundNode.Parameters[i] as TAstNode).StaticType; // Propagates Unknown
|
||||
|
||||
// 3. Visit the body to infer its return type
|
||||
boundBody := Accept(boundNode.Body).AsIntf<IAstNode>;
|
||||
bodyType := (boundBody as TAstNode).StaticType;
|
||||
// 4. Visit the body to infer its return type
|
||||
Accept(boundNode.Body);
|
||||
bodyType := (boundNode.Body as TAstNode).StaticType;
|
||||
|
||||
// 4. Create the final method type
|
||||
// 5. Create the final method type
|
||||
methodType := TTypes.CreateMethod(paramTypes, bodyType);
|
||||
|
||||
// 5. Update the type for <self> (Slot 0) in the descriptor
|
||||
// 6. Update the type for <self> (Slot 0) in the descriptor
|
||||
FCurrentDescriptor.UpdateType(0, methodType);
|
||||
|
||||
finally
|
||||
// 6. Restore parent descriptor
|
||||
FCurrentDescriptor := FCurrentDescriptor.Parent;
|
||||
// 7. Restore parent descriptor
|
||||
FCurrentDescriptor := savedDescriptor;
|
||||
end;
|
||||
|
||||
// 7. Set the type of the lambda node itself
|
||||
Result := SetType(TDataValue.FromIntf<ILambdaExpressionNode>(boundNode), methodType);
|
||||
// 8. Set the type of the lambda node itself
|
||||
Result := SetType(boundNode, methodType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitFunctionCall(const Node: IFunctionCallNode): TDataValue;
|
||||
function TTypeChecker.VisitFunctionCall(const Node: IFunctionCallNode): IAstNode;
|
||||
var
|
||||
callee: IAstNode;
|
||||
args: TArray<IAstNode>;
|
||||
calleeType, retType: IStaticType;
|
||||
i: Integer;
|
||||
begin
|
||||
// 1. Visit children first (bottom-up)
|
||||
callee := Accept(Node.Callee).AsIntf<IAstNode>;
|
||||
args := AcceptNodes<IAstNode>(Node.Arguments);
|
||||
inherited;
|
||||
|
||||
// 2. Get callee type (now inferred)
|
||||
calleeType := (callee as TAstNode).StaticType;
|
||||
calleeType := (Node.Callee as TAstNode).StaticType;
|
||||
retType := TTypes.Unknown; // Default if not a method
|
||||
|
||||
// 3. Perform type checking
|
||||
if calleeType.Kind = TStaticTypeKind.stMethod then
|
||||
begin
|
||||
var signature := calleeType.Signature;
|
||||
if Length(args) <> Length(signature.ParamTypes) then
|
||||
raise ETypeException.CreateFmt('Function expects %d arguments, but got %d', [Length(signature.ParamTypes), Length(args)]);
|
||||
if Length(Node.Arguments) <> Length(signature.ParamTypes) then
|
||||
raise ETypeException
|
||||
.CreateFmt('Function expects %d arguments, but got %d', [Length(signature.ParamTypes), Length(Node.Arguments)]);
|
||||
|
||||
retType := signature.ReturnType;
|
||||
|
||||
// Check argument types
|
||||
for i := 0 to High(args) do
|
||||
for i := 0 to High(Node.Arguments) do
|
||||
begin
|
||||
var argType := (args[i] as TAstNode).StaticType;
|
||||
var argType := (Node.Arguments[i] as TAstNode).StaticType;
|
||||
var paramType := signature.ParamTypes[i];
|
||||
if not TTypeRules.CanAssign(paramType, argType) then
|
||||
raise ETypeException
|
||||
@@ -254,99 +255,111 @@ begin
|
||||
raise ETypeException.CreateFmt('Cannot invoke type %s as a function.', [calleeType.ToString]);
|
||||
|
||||
// 4. Set the type for this call node
|
||||
Result := SetType(TDataValue.FromIntf<IFunctionCallNode>(Node), retType);
|
||||
Result := SetType(Node, retType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitBlockExpression(const Node: IBlockExpressionNode): IAstNode;
|
||||
var
|
||||
blockType: IStaticType;
|
||||
exprs: TArray<IAstNode>;
|
||||
begin
|
||||
exprs := AcceptNodes<IAstNode>(Node.Expressions);
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
if Length(exprs) > 0 then
|
||||
blockType := (exprs[High(exprs)] as TAstNode).StaticType
|
||||
// 2. Type is type of last expression
|
||||
if Length(Node.Expressions) > 0 then
|
||||
blockType := (Node.Expressions[High(Node.Expressions)] as TAstNode).StaticType
|
||||
else
|
||||
blockType := TTypes.Void;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IBlockExpressionNode>(Node), blockType);
|
||||
Result := SetType(Node, blockType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitIfExpression(const Node: IIfExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitIfExpression(const Node: IIfExpressionNode): IAstNode;
|
||||
var
|
||||
condition, thenBranch, elseBranch: IAstNode;
|
||||
conditionType, thenType, elseType, resultType: IStaticType;
|
||||
begin
|
||||
condition := Accept(Node.Condition).AsIntf<IAstNode>;
|
||||
thenBranch := Accept(Node.ThenBranch).AsIntf<IAstNode>;
|
||||
elseBranch := Accept(Node.ElseBranch).AsIntf<IAstNode>; // Accept(nil) returns void
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
conditionType := (condition as TAstNode).StaticType;
|
||||
// 2. Check condition
|
||||
conditionType := (Node.Condition as TAstNode).StaticType;
|
||||
if (conditionType.Kind <> stUnknown) and not TTypeRules.CanAssign(TTypes.Ordinal, conditionType) then
|
||||
raise ETypeException.CreateFmt('If condition must be Ordinal, but got %s', [conditionType.ToString]);
|
||||
|
||||
thenType := (thenBranch as TAstNode).StaticType;
|
||||
// 3. Promote branch types
|
||||
thenType := (Node.ThenBranch as TAstNode).StaticType;
|
||||
elseType :=
|
||||
if elseBranch <> nil then (elseBranch as TAstNode).StaticType
|
||||
if Node.ElseBranch <> nil then (Node.ElseBranch as TAstNode).StaticType
|
||||
else TTypes.Void;
|
||||
|
||||
resultType := TTypeRules.Promote(thenType, elseType);
|
||||
Result := SetType(TDataValue.FromIntf<IIfExpressionNode>(Node), resultType);
|
||||
Result := SetType(Node, resultType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitTernaryExpression(const Node: ITernaryExpressionNode): IAstNode;
|
||||
var
|
||||
condition, thenBranch, elseBranch: IAstNode;
|
||||
conditionType, thenType, elseType, resultType: IStaticType;
|
||||
begin
|
||||
condition := Accept(Node.Condition).AsIntf<IAstNode>;
|
||||
thenBranch := Accept(Node.ThenBranch).AsIntf<IAstNode>;
|
||||
elseBranch := Accept(Node.ElseBranch).AsIntf<IAstNode>;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
conditionType := (condition as TAstNode).StaticType;
|
||||
// 2. Check condition
|
||||
conditionType := (Node.Condition as TAstNode).StaticType;
|
||||
if (conditionType.Kind <> stUnknown) and not TTypeRules.CanAssign(TTypes.Ordinal, conditionType) then
|
||||
raise ETypeException.CreateFmt('Ternary condition must be Ordinal, but got %s', [conditionType.ToString]);
|
||||
|
||||
thenType := (thenBranch as TAstNode).StaticType;
|
||||
elseType := (elseBranch as TAstNode).StaticType;
|
||||
// 3. Promote branch types
|
||||
thenType := (Node.ThenBranch as TAstNode).StaticType;
|
||||
elseType := (Node.ElseBranch as TAstNode).StaticType;
|
||||
|
||||
resultType := TTypeRules.Promote(thenType, elseType);
|
||||
Result := SetType(TDataValue.FromIntf<ITernaryExpressionNode>(Node), resultType);
|
||||
Result := SetType(Node, resultType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitBinaryExpression(const Node: IBinaryExpressionNode): IAstNode;
|
||||
var
|
||||
left, right: IAstNode;
|
||||
leftType, rightType, resultType: IStaticType;
|
||||
begin
|
||||
left := Accept(Node.Left).AsIntf<IAstNode>;
|
||||
right := Accept(Node.Right).AsIntf<IAstNode>;
|
||||
leftType := (left as TAstNode).StaticType;
|
||||
rightType := (right as TAstNode).StaticType;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
// 2. Get types
|
||||
leftType := (Node.Left as TAstNode).StaticType;
|
||||
rightType := (Node.Right as TAstNode).StaticType;
|
||||
|
||||
// 3. Resolve
|
||||
resultType := TTypeRules.ResolveBinaryOp(Node.Operator, leftType, rightType);
|
||||
Result := SetType(TDataValue.FromIntf<IBinaryExpressionNode>(Node), resultType);
|
||||
Result := SetType(Node, resultType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue;
|
||||
function TTypeChecker.VisitUnaryExpression(const Node: IUnaryExpressionNode): IAstNode;
|
||||
var
|
||||
right: IAstNode;
|
||||
rightType, resultType: IStaticType;
|
||||
begin
|
||||
right := Accept(Node.Right).AsIntf<IAstNode>;
|
||||
rightType := (right as TAstNode).StaticType;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
// 2. Get types
|
||||
rightType := (Node.Right as TAstNode).StaticType;
|
||||
|
||||
// 3. Resolve
|
||||
resultType := TTypeRules.ResolveUnaryOp(Node.Operator, rightType);
|
||||
Result := SetType(TDataValue.FromIntf<IUnaryExpressionNode>(Node), resultType);
|
||||
Result := SetType(Node, resultType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitMemberAccess(const Node: IMemberAccessNode): TDataValue;
|
||||
function TTypeChecker.VisitMemberAccess(const Node: IMemberAccessNode): IAstNode;
|
||||
var
|
||||
baseNode: IAstNode;
|
||||
baseType, elemType: IStaticType;
|
||||
fieldIndex: Integer;
|
||||
begin
|
||||
baseNode := Accept(Node.Base).AsIntf<IAstNode>;
|
||||
baseType := (baseNode as TAstNode).StaticType;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
// 2. Get types
|
||||
baseType := (Node.Base as TAstNode).StaticType;
|
||||
elemType := TTypes.Unknown;
|
||||
|
||||
// 3. Resolve
|
||||
if (baseType.Kind <> TStaticTypeKind.stUnknown) then
|
||||
begin
|
||||
if (baseType.Kind = TStaticTypeKind.stRecord) or (baseType.Kind = TStaticTypeKind.stRecordSeries) then
|
||||
@@ -376,20 +389,22 @@ begin
|
||||
end;
|
||||
end;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IMemberAccessNode>(Node), elemType);
|
||||
Result := SetType(Node, elemType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitIndexer(const Node: IIndexerNode): TDataValue;
|
||||
function TTypeChecker.VisitIndexer(const Node: IIndexerNode): IAstNode;
|
||||
var
|
||||
baseNode, indexNode: IAstNode;
|
||||
baseType, indexType, elemType: IStaticType;
|
||||
begin
|
||||
baseNode := Accept(Node.Base).AsIntf<IAstNode>;
|
||||
indexNode := Accept(Node.Index).AsIntf<IAstNode>;
|
||||
baseType := (baseNode as TAstNode).StaticType;
|
||||
indexType := (indexNode as TAstNode).StaticType;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
// 2. Get types
|
||||
baseType := (Node.Base as TAstNode).StaticType;
|
||||
indexType := (Node.Index as TAstNode).StaticType;
|
||||
elemType := TTypes.Unknown;
|
||||
|
||||
// 3. Resolve
|
||||
if (baseType.Kind <> TStaticTypeKind.stUnknown) then
|
||||
begin
|
||||
if (baseType.Kind <> TStaticTypeKind.stSeries) and (baseType.Kind <> TStaticTypeKind.stRecordSeries) then
|
||||
@@ -404,13 +419,12 @@ begin
|
||||
elemType := TTypes.CreateRecord(baseType.Definition);
|
||||
end;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IIndexerNode>(Node), elemType);
|
||||
Result := SetType(Node, elemType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitRecordLiteral(const Node: IRecordLiteralNode): TDataValue;
|
||||
function TTypeChecker.VisitRecordLiteral(const Node: IRecordLiteralNode): IAstNode;
|
||||
var
|
||||
i: Integer;
|
||||
boundFields: TArray<TRecordFieldLiteral>;
|
||||
scalarDefFields: TArray<TScalarRecordField>;
|
||||
def: IScalarRecordDefinition;
|
||||
staticType: IStaticType;
|
||||
@@ -418,19 +432,22 @@ var
|
||||
valType: IStaticType;
|
||||
scalarKind: TScalar.TKind;
|
||||
allScalar: Boolean;
|
||||
N: TGenericRecordLiteralNode; // Parser creates this type
|
||||
begin
|
||||
SetLength(boundFields, Length(Node.Fields));
|
||||
SetLength(scalarDefFields, Length(Node.Fields));
|
||||
// 1. Visit all child nodes first to infer their types
|
||||
inherited;
|
||||
|
||||
N := (Node as TGenericRecordLiteralNode);
|
||||
|
||||
SetLength(scalarDefFields, Length(N.Fields));
|
||||
allScalar := True;
|
||||
|
||||
// 1. Visit all child nodes first to infer their types
|
||||
for i := 0 to High(Node.Fields) do
|
||||
// 2. Check if this record literal can be a TScalarRecord
|
||||
for i := 0 to High(N.Fields) do
|
||||
begin
|
||||
valNode := Accept(Node.Fields[i].Value).AsIntf<IAstNode>;
|
||||
valNode := N.Fields[i].Value;
|
||||
valType := (valNode as TAstNode).StaticType;
|
||||
boundFields[i] := TRecordFieldLiteral.Create(Node.Fields[i].Key, valNode);
|
||||
|
||||
// 2. Check if this field fits the scalar path
|
||||
if (valType.Kind = stOrdinal) then
|
||||
scalarKind := TScalar.TKind.Ordinal
|
||||
else if (valType.Kind = stFloat) then
|
||||
@@ -444,51 +461,51 @@ begin
|
||||
end;
|
||||
|
||||
if allScalar then
|
||||
scalarDefFields[i] := TScalarRecordField.Create(Node.Fields[i].Key.Value, scalarKind);
|
||||
scalarDefFields[i] := TScalarRecordField.Create(N.Fields[i].Key.Value, scalarKind);
|
||||
end;
|
||||
|
||||
// 3. Create the appropriate record type (Scalar or Generic)
|
||||
// 3. Create the appropriate record type (Scalar or Generic) and mutate the node
|
||||
if allScalar then
|
||||
begin
|
||||
def := TScalarRecordRegistry.Intern(scalarDefFields);
|
||||
staticType := TTypes.CreateRecord(def);
|
||||
// We can re-use the TBoundRecordLiteralNode from the binder
|
||||
(Node as TBoundRecordLiteralNode).Definition := def;
|
||||
N.Definition := def; // Mutate
|
||||
N.GenericDefinition := nil; // Mutate
|
||||
end
|
||||
else
|
||||
begin
|
||||
var genDefFields: TArray<TPair<IKeyword, IStaticType>>;
|
||||
SetLength(genDefFields, Length(boundFields));
|
||||
for i := 0 to High(boundFields) do
|
||||
genDefFields[i] := TPair<IKeyword, IStaticType>.Create(boundFields[i].Key.Value, (boundFields[i].Value as TAstNode).StaticType);
|
||||
SetLength(genDefFields, Length(N.Fields));
|
||||
for i := 0 to High(N.Fields) do
|
||||
genDefFields[i] := TPair<IKeyword, IStaticType>.Create(N.Fields[i].Key.Value, (N.Fields[i].Value as TAstNode).StaticType);
|
||||
|
||||
var genDef := TGenericRecordRegistry.Intern(genDefFields);
|
||||
staticType := TTypes.CreateGenericRecord(genDef);
|
||||
// Re-use the TBoundGenericRecordLiteralNode from the binder
|
||||
(Node as TBoundGenericRecordLiteralNode).Definition := genDef;
|
||||
N.GenericDefinition := genDef; // Mutate
|
||||
N.Definition := nil; // Mutate
|
||||
end;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IRecordLiteralNode>(Node), staticType);
|
||||
Result := SetType(N, staticType);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue;
|
||||
function TTypeChecker.VisitCreateSeries(const Node: ICreateSeriesNode): IAstNode;
|
||||
begin
|
||||
// Type was set by Binder, just propagate it up.
|
||||
Result := TDataValue.FromIntf<ICreateSeriesNode>(Node);
|
||||
Result := inherited VisitCreateSeries(Node);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue;
|
||||
function TTypeChecker.VisitAddSeriesItem(const Node: IAddSeriesItemNode): IAstNode;
|
||||
var
|
||||
seriesNode, valueNode, lookbackNode: IAstNode;
|
||||
seriesType, valueType: IStaticType;
|
||||
begin
|
||||
seriesNode := Accept(Node.Series).AsIntf<IAstNode>;
|
||||
valueNode := Accept(Node.Value).AsIntf<IAstNode>;
|
||||
lookbackNode := Accept(Node.Lookback).AsIntf<IAstNode>;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
seriesType := (seriesNode as TAstNode).StaticType;
|
||||
valueType := (valueNode as TAstNode).StaticType;
|
||||
// 2. Get types
|
||||
seriesType := (Node.Series as TAstNode).StaticType;
|
||||
valueType := (Node.Value as TAstNode).StaticType;
|
||||
|
||||
// 3. Check types
|
||||
if (seriesType.Kind <> stUnknown) then
|
||||
begin
|
||||
if (seriesType.Kind <> TStaticTypeKind.stSeries) then
|
||||
@@ -499,30 +516,33 @@ begin
|
||||
.CreateFmt('Cannot add item of type %s to series of type %s', [valueType.ToString, seriesType.ElementType.ToString]);
|
||||
end;
|
||||
|
||||
if (lookbackNode <> nil) then
|
||||
if (Node.Lookback <> nil) then
|
||||
begin
|
||||
var lookbackType := (lookbackNode as TAstNode).StaticType;
|
||||
var lookbackType := (Node.Lookback as TAstNode).StaticType;
|
||||
if (lookbackType.Kind <> stUnknown) and not (lookbackType.Kind = TStaticTypeKind.stOrdinal) then
|
||||
raise ETypeException.Create('Lookback parameter for "add" must be an ordinal value.');
|
||||
end;
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<IAddSeriesItemNode>(Node), TTypes.Void);
|
||||
Result := SetType(Node, TTypes.Void);
|
||||
end;
|
||||
|
||||
function TTypeChecker.VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue;
|
||||
function TTypeChecker.VisitSeriesLength(const Node: ISeriesLengthNode): IAstNode;
|
||||
var
|
||||
seriesNode: IAstNode;
|
||||
seriesType: IStaticType;
|
||||
begin
|
||||
seriesNode := Accept(Node.Series).AsIntf<IAstNode>;
|
||||
seriesType := (seriesNode as TAstNode).StaticType;
|
||||
// 1. Visit children
|
||||
inherited;
|
||||
|
||||
// 2. Get type
|
||||
seriesType := (Node.Series as TAstNode).StaticType;
|
||||
|
||||
// 3. Check type
|
||||
if (seriesType.Kind <> stUnknown)
|
||||
and (seriesType.Kind <> TStaticTypeKind.stSeries)
|
||||
and (seriesType.Kind <> TStaticTypeKind.stRecordSeries) then
|
||||
raise ETypeException.CreateFmt('"length" requires a series, but got %s', [seriesType.ToString]);
|
||||
|
||||
Result := SetType(TDataValue.FromIntf<ISeriesLengthNode>(Node), TTypes.Ordinal);
|
||||
Result := SetType(Node, TTypes.Ordinal);
|
||||
end;
|
||||
|
||||
end.
|
||||
|
||||
Reference in New Issue
Block a user