Michael Schimmel
991 lines
34 KiB
ObjectPascal
991 lines
34 KiB
ObjectPascal
unit Myc.Ast.Compiler.TypeChecker;
|
|
|
|
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.Identities,
|
|
Myc.Ast;
|
|
|
|
type
|
|
IAstTypeChecker = interface(IAstVisitor)
|
|
function Execute(const RootNode: IAstNode): IAstNode;
|
|
end;
|
|
|
|
TTypeChecker = class(TAstTransformer, IAstTypeChecker)
|
|
private
|
|
type
|
|
TTypeContext = class
|
|
private
|
|
FParent: TTypeContext;
|
|
FLayout: IScopeLayout;
|
|
FSlotTypes: TArray<IStaticType>;
|
|
FUpvalueTypes: TArray<IStaticType>;
|
|
public
|
|
constructor Create(
|
|
AParent: TTypeContext;
|
|
ALayout: IScopeLayout;
|
|
const AUpvalueTypes: TArray<IStaticType>;
|
|
ADescriptor: IScopeDescriptor
|
|
);
|
|
function LookupType(const Address: TResolvedAddress): IStaticType;
|
|
procedure SetType(SlotIndex: Integer; AType: IStaticType);
|
|
property Types: TArray<IStaticType> read FSlotTypes;
|
|
end;
|
|
|
|
private
|
|
FCurrentContext: TTypeContext;
|
|
FLog: ICompilerLog;
|
|
FRootScope: IExecutionScope;
|
|
|
|
function CreateContextChain(L: IScopeLayout): TTypeContext;
|
|
|
|
// Helpers for Null Propagation
|
|
function PrepareBaseType(const BaseNode: IAstNode; out IsOptional: Boolean): IStaticType;
|
|
function ApplyOptionality(const AType: IStaticType; IsOptional: Boolean): IStaticType;
|
|
|
|
protected
|
|
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 VisitCondExpression(const Node: ICondExpressionNode): 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;
|
|
function VisitNop(const Node: INopNode): IAstNode; override;
|
|
|
|
function VisitConstant(const Node: IConstantNode): IAstNode; override;
|
|
function VisitKeyword(const Node: IKeywordNode): IAstNode; override;
|
|
|
|
public
|
|
constructor Create(const RootLayout: IScopeLayout; const RootScope: IExecutionScope; const ALog: ICompilerLog);
|
|
destructor Destroy; override;
|
|
|
|
function Execute(const RootNode: IAstNode): IAstNode;
|
|
|
|
class function CheckTypes(
|
|
const RootNode: IAstNode;
|
|
const Layout: IScopeLayout;
|
|
const RootScope: IExecutionScope;
|
|
const ALog: ICompilerLog
|
|
): IAstNode; static;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
System.Generics.Defaults,
|
|
Myc.Data.Keyword;
|
|
|
|
{ TTypeChecker.TTypeContext }
|
|
|
|
constructor TTypeChecker.TTypeContext.Create(
|
|
AParent: TTypeContext;
|
|
ALayout: IScopeLayout;
|
|
const AUpvalueTypes: TArray<IStaticType>;
|
|
ADescriptor: IScopeDescriptor
|
|
);
|
|
var
|
|
i: Integer;
|
|
begin
|
|
inherited Create;
|
|
FParent := AParent;
|
|
FLayout := ALayout;
|
|
FUpvalueTypes := AUpvalueTypes;
|
|
|
|
if Assigned(FLayout) then
|
|
begin
|
|
SetLength(FSlotTypes, FLayout.SlotCount);
|
|
|
|
if Assigned(ADescriptor) then
|
|
begin
|
|
// Load known types from descriptor (e.g. for Root Scope / RTL)
|
|
for i := 0 to High(FSlotTypes) do
|
|
FSlotTypes[i] := ADescriptor.GetSymbolType(i);
|
|
end
|
|
else
|
|
begin
|
|
// Initialize with Unknown for new scopes
|
|
for i := 0 to High(FSlotTypes) do
|
|
FSlotTypes[i] := TTypes.Unknown;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TTypeChecker.TTypeContext.LookupType(const Address: TResolvedAddress): IStaticType;
|
|
var
|
|
ctx: TTypeContext;
|
|
i: Integer;
|
|
begin
|
|
case Address.Kind of
|
|
akLocalOrParent:
|
|
begin
|
|
ctx := Self;
|
|
for i := 1 to Address.ScopeDepth do
|
|
begin
|
|
if not Assigned(ctx.FParent) then
|
|
begin
|
|
Result := TTypes.Unknown;
|
|
Exit;
|
|
end;
|
|
ctx := ctx.FParent;
|
|
end;
|
|
|
|
if (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(ctx.FSlotTypes)) then
|
|
Result := ctx.FSlotTypes[Address.SlotIndex]
|
|
else
|
|
Result := TTypes.Unknown;
|
|
end;
|
|
akUpvalue:
|
|
begin
|
|
if (Address.SlotIndex >= 0) and (Address.SlotIndex < Length(FUpvalueTypes)) then
|
|
Result := FUpvalueTypes[Address.SlotIndex]
|
|
else
|
|
Result := TTypes.Unknown;
|
|
end;
|
|
else
|
|
Result := TTypes.Unknown;
|
|
end;
|
|
end;
|
|
|
|
procedure TTypeChecker.TTypeContext.SetType(SlotIndex: Integer; AType: IStaticType);
|
|
begin
|
|
if (SlotIndex >= 0) and (SlotIndex < Length(FSlotTypes)) then
|
|
FSlotTypes[SlotIndex] := AType;
|
|
end;
|
|
|
|
{ TTypeChecker }
|
|
|
|
function TTypeChecker.CreateContextChain(L: IScopeLayout): TTypeContext;
|
|
var
|
|
p: TTypeContext;
|
|
desc: IScopeDescriptor;
|
|
begin
|
|
if L = nil then
|
|
exit(nil);
|
|
|
|
p := CreateContextChain(L.Parent);
|
|
|
|
desc := nil;
|
|
// Check if this layout is the root layout (has no parent).
|
|
// If so, attach the RootScope's descriptor to pull in RTL types (like +).
|
|
if (L.Parent = nil) and Assigned(FRootScope) then
|
|
begin
|
|
desc := FRootScope.Descriptor;
|
|
end;
|
|
|
|
Result := TTypeContext.Create(p, L, [], desc);
|
|
end;
|
|
|
|
constructor TTypeChecker.Create(const RootLayout: IScopeLayout; const RootScope: IExecutionScope; const ALog: ICompilerLog);
|
|
begin
|
|
inherited Create;
|
|
FLog := ALog;
|
|
FRootScope := RootScope;
|
|
|
|
FCurrentContext := CreateContextChain(RootLayout);
|
|
if FCurrentContext = nil then
|
|
FCurrentContext := TTypeContext.Create(nil, nil, [], nil);
|
|
end;
|
|
|
|
destructor TTypeChecker.Destroy;
|
|
begin
|
|
while Assigned(FCurrentContext) do
|
|
begin
|
|
var temp := FCurrentContext;
|
|
FCurrentContext := FCurrentContext.FParent;
|
|
temp.Free;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
class function TTypeChecker.CheckTypes(
|
|
const RootNode: IAstNode;
|
|
const Layout: IScopeLayout;
|
|
const RootScope: IExecutionScope;
|
|
const ALog: ICompilerLog
|
|
): IAstNode;
|
|
var
|
|
startLayout: IScopeLayout;
|
|
begin
|
|
// Determine the starting scope for the TypeChecker.
|
|
// The 'Layout' parameter represents the *inner* scope of the script (the "Room").
|
|
// To correctly simulate entering this scope (via VisitLambdaExpression), the TypeChecker
|
|
// must start in the *surrounding* scope (the "Hallway"), which is Layout.Parent.
|
|
if Assigned(Layout) then
|
|
startLayout := Layout.Parent
|
|
else
|
|
startLayout := nil;
|
|
|
|
var checker := TTypeChecker.Create(startLayout, RootScope, ALog) as IAstTypeChecker;
|
|
Result := checker.Execute(RootNode);
|
|
end;
|
|
|
|
function TTypeChecker.Execute(const RootNode: IAstNode): IAstNode;
|
|
begin
|
|
Result := Accept(RootNode);
|
|
if not Assigned(Result) then
|
|
Result := TAst.Block([], nil);
|
|
end;
|
|
|
|
// --- Helper ---
|
|
|
|
function TTypeChecker.PrepareBaseType(const BaseNode: IAstNode; out IsOptional: Boolean): IStaticType;
|
|
var
|
|
baseType: IStaticType;
|
|
begin
|
|
baseType := BaseNode.AsTypedNode.StaticType;
|
|
IsOptional := baseType.IsOptional;
|
|
Result := TTypes.Unwrap(baseType);
|
|
end;
|
|
|
|
function TTypeChecker.ApplyOptionality(const AType: IStaticType; IsOptional: Boolean): IStaticType;
|
|
begin
|
|
if IsOptional and (AType.Kind <> stUnknown) then
|
|
Result := TTypes.MakeOptional(AType)
|
|
else
|
|
Result := AType;
|
|
end;
|
|
|
|
// --- Visits ---
|
|
|
|
function TTypeChecker.VisitConstant(const Node: IConstantNode): IAstNode;
|
|
begin
|
|
Result := Node;
|
|
end;
|
|
|
|
function TTypeChecker.VisitKeyword(const Node: IKeywordNode): IAstNode;
|
|
begin
|
|
Result := Node;
|
|
end;
|
|
|
|
function TTypeChecker.VisitIdentifier(const Node: IIdentifierNode): IAstNode;
|
|
var
|
|
typ: IStaticType;
|
|
adr: TResolvedAddress;
|
|
identity: INamedIdentity;
|
|
begin
|
|
adr := Node.Address;
|
|
identity := Node.Identity.AsNamed;
|
|
|
|
if adr.Kind = akUnresolved then
|
|
begin
|
|
Result := TAst.Identifier(identity, adr, TTypes.Unknown);
|
|
Exit;
|
|
end;
|
|
|
|
typ := FCurrentContext.LookupType(adr);
|
|
Result := TAst.Identifier(identity, adr, typ);
|
|
end;
|
|
|
|
function TTypeChecker.VisitRecurNode(const Node: IRecurNode): IAstNode;
|
|
var
|
|
newArgs: TArray<IAstNode>;
|
|
i: Integer;
|
|
begin
|
|
SetLength(newArgs, Node.Arguments.Count);
|
|
for i := 0 to Node.Arguments.Count - 1 do
|
|
newArgs[i] := Accept(Node.Arguments[i]);
|
|
|
|
var argList := TArgumentList.Create(newArgs, Node.Arguments.Identity);
|
|
Result := TAst.Recur(Node.Identity, argList, TTypes.Void);
|
|
end;
|
|
|
|
function TTypeChecker.VisitVariableDeclaration(const Node: IVariableDeclarationNode): IAstNode;
|
|
var
|
|
initType: IStaticType;
|
|
newInitializer, newIdent: IAstNode;
|
|
adr: TResolvedAddress;
|
|
lambdaNode: ILambdaExpressionNode;
|
|
placeholderType: IStaticType;
|
|
i: Integer;
|
|
identNode: IIdentifierNode;
|
|
identIdentity: INamedIdentity;
|
|
begin
|
|
identNode := Node.Target.AsIdentifier;
|
|
identIdentity := identNode.Identity.AsNamed;
|
|
adr := identNode.Address;
|
|
initType := TTypes.Unknown;
|
|
|
|
if adr.Kind = akUnresolved then
|
|
begin
|
|
if Assigned(Node.Initializer) then
|
|
Accept(Node.Initializer);
|
|
Result := Node;
|
|
Exit;
|
|
end;
|
|
|
|
placeholderType := nil;
|
|
if (Node.Initializer <> nil) and (Node.Initializer.Kind = akLambdaExpression) then
|
|
begin
|
|
lambdaNode := Node.Initializer.AsLambdaExpression;
|
|
var paramTypes: TArray<IStaticType>;
|
|
SetLength(paramTypes, lambdaNode.Parameters.Count);
|
|
for i := 0 to High(paramTypes) do
|
|
paramTypes[i] := TTypes.Unknown;
|
|
|
|
placeholderType := TTypes.CreateMethod(paramTypes, TTypes.Unknown);
|
|
FCurrentContext.SetType(adr.SlotIndex, placeholderType);
|
|
initType := placeholderType;
|
|
end;
|
|
|
|
if Assigned(Node.Initializer) then
|
|
newInitializer := Accept(Node.Initializer)
|
|
else
|
|
newInitializer := nil;
|
|
|
|
if Assigned(newInitializer) then
|
|
initType := newInitializer.AsTypedNode.StaticType
|
|
else if not Assigned(placeholderType) then
|
|
initType := TTypes.Unknown;
|
|
|
|
if initType.Kind <> stUnknown then
|
|
FCurrentContext.SetType(adr.SlotIndex, initType);
|
|
|
|
newIdent := TAst.Identifier(identIdentity, adr, initType);
|
|
|
|
Result := TAst.VarDecl(Node.Identity, newIdent, newInitializer, initType, Node.IsBoxed);
|
|
end;
|
|
|
|
function TTypeChecker.VisitAssignment(const Node: IAssignmentNode): IAstNode;
|
|
var
|
|
targetType, sourceType: IStaticType;
|
|
newIdent, newValue: IAstNode;
|
|
adr: TResolvedAddress;
|
|
lambdaNode: ILambdaExpressionNode;
|
|
placeholderType: IStaticType;
|
|
i: Integer;
|
|
identNode: IIdentifierNode;
|
|
identIdentity: INamedIdentity;
|
|
begin
|
|
identNode := Node.Target.AsIdentifier;
|
|
identIdentity := identNode.Identity.AsNamed;
|
|
|
|
newIdent := Accept(Node.Target);
|
|
targetType := newIdent.AsTypedNode.StaticType;
|
|
adr := identNode.Address;
|
|
|
|
if adr.Kind = akUnresolved then
|
|
begin
|
|
Accept(Node.Value);
|
|
Result := Node;
|
|
Exit;
|
|
end;
|
|
|
|
placeholderType := nil;
|
|
if (Node.Value <> nil) and (Node.Value.Kind = akLambdaExpression) then
|
|
begin
|
|
lambdaNode := Node.Value.AsLambdaExpression;
|
|
if (targetType.Kind <> stMethod) then
|
|
begin
|
|
var paramTypes: TArray<IStaticType>;
|
|
SetLength(paramTypes, lambdaNode.Parameters.Count);
|
|
for i := 0 to High(paramTypes) do
|
|
paramTypes[i] := TTypes.Unknown;
|
|
|
|
placeholderType := TTypes.CreateMethod(paramTypes, TTypes.Unknown);
|
|
FCurrentContext.SetType(adr.SlotIndex, placeholderType);
|
|
targetType := placeholderType;
|
|
end;
|
|
end;
|
|
|
|
newValue := Accept(Node.Value);
|
|
sourceType := newValue.AsTypedNode.StaticType;
|
|
|
|
if (targetType.Kind <> stUnknown) and (sourceType.Kind <> stUnknown) then
|
|
begin
|
|
if not TTypeRules.CanAssign(targetType, sourceType) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Cannot assign type %s to %s', [sourceType.ToString, targetType.ToString]), Node);
|
|
end;
|
|
end;
|
|
|
|
if ((targetType.Kind = stUnknown) or Assigned(placeholderType)) and (sourceType.Kind <> stUnknown) then
|
|
begin
|
|
FCurrentContext.SetType(adr.SlotIndex, sourceType);
|
|
newIdent := TAst.Identifier(identIdentity, adr, sourceType);
|
|
targetType := sourceType;
|
|
end;
|
|
|
|
Result := TAst.Assign(Node.Identity, newIdent, newValue, targetType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitLambdaExpression(const Node: ILambdaExpressionNode): IAstNode;
|
|
var
|
|
newParams: TArray<IIdentifierNode>;
|
|
newBody: IAstNode;
|
|
bodyType, methodType: IStaticType;
|
|
paramTypes: TArray<IStaticType>;
|
|
upvalueTypes: TArray<IStaticType>;
|
|
upvalueAddrs: TArray<TResolvedAddress>;
|
|
i: Integer;
|
|
finalDescriptor: IScopeDescriptor;
|
|
paramIdent: IIdentifierNode;
|
|
paramIdentity: INamedIdentity;
|
|
lookupAddr: TResolvedAddress;
|
|
begin
|
|
// 1. Resolve Upvalue Types
|
|
upvalueAddrs := Node.Upvalues;
|
|
SetLength(upvalueTypes, Length(upvalueAddrs));
|
|
|
|
for i := 0 to High(upvalueAddrs) do
|
|
begin
|
|
lookupAddr := upvalueAddrs[i];
|
|
|
|
// CRITICAL: Scope Depth Adjustment
|
|
// The Binder calculated addresses relative to the *body* of this lambda (Internal View).
|
|
// FCurrentContext currently points to the *defining* scope (External View/Parent).
|
|
// Therefore, we must decrease the depth by 1 to look up the type in the current context.
|
|
if lookupAddr.Kind = akLocalOrParent then
|
|
begin
|
|
// Check > 0 to prevent crash if Binder somehow produced 0 (though logic says it shouldn't).
|
|
if lookupAddr.ScopeDepth > 0 then
|
|
Dec(lookupAddr.ScopeDepth)
|
|
else
|
|
begin
|
|
// Guard for Binder quirks or edge cases
|
|
if Assigned(FLog) then
|
|
FLog.AddWarning('Compiler integrity check warning: Upvalue Depth 0 encountered during type check.', Node);
|
|
end;
|
|
end;
|
|
|
|
upvalueTypes[i] := FCurrentContext.LookupType(lookupAddr);
|
|
end;
|
|
|
|
// 2. Enter New Scope (The "Room")
|
|
FCurrentContext := TTypeContext.Create(FCurrentContext, Node.Layout, upvalueTypes, nil);
|
|
try
|
|
// 3. Register Parameters
|
|
SetLength(newParams, Node.Parameters.Count);
|
|
SetLength(paramTypes, Node.Parameters.Count);
|
|
|
|
for i := 0 to Node.Parameters.Count - 1 do
|
|
begin
|
|
paramIdent := Node.Parameters[i];
|
|
paramIdentity := paramIdent.Identity.AsNamed;
|
|
var paramAdr := paramIdent.Address;
|
|
|
|
paramTypes[i] := TTypes.Unknown;
|
|
|
|
if paramAdr.Kind <> akUnresolved then
|
|
FCurrentContext.SetType(paramAdr.SlotIndex, paramTypes[i]);
|
|
|
|
newParams[i] := TAst.Identifier(paramIdentity, paramAdr, paramTypes[i]);
|
|
end;
|
|
|
|
// 4. Visit Body
|
|
newBody := Accept(Node.Body);
|
|
|
|
// 5. Determine Function Signature
|
|
bodyType := newBody.AsTypedNode.StaticType;
|
|
methodType := TTypes.CreateMethod(paramTypes, bodyType);
|
|
|
|
finalDescriptor := TScope.CreateDescriptor(Node.Layout, FCurrentContext.Types);
|
|
finally
|
|
// 6. Leave Scope
|
|
var temp := FCurrentContext;
|
|
FCurrentContext := FCurrentContext.FParent;
|
|
temp.Free;
|
|
end;
|
|
|
|
var paramList := TParameterList.Create(newParams, Node.Parameters.Identity);
|
|
Result :=
|
|
TAst.LambdaExpr(
|
|
Node.Identity,
|
|
paramList,
|
|
newBody,
|
|
Node.Layout,
|
|
finalDescriptor,
|
|
Node.Upvalues,
|
|
Node.HasNestedLambdas,
|
|
Node.IsPure,
|
|
methodType
|
|
);
|
|
end;
|
|
|
|
function TTypeChecker.VisitFunctionCall(const Node: IFunctionCallNode): IAstNode;
|
|
var
|
|
calleeType, retType: IStaticType;
|
|
i, j: Integer;
|
|
newCallee: IAstNode;
|
|
newArgs: TArray<IAstNode>;
|
|
argTypes: TArray<IStaticType>;
|
|
hasUnknownArgs: Boolean;
|
|
bestSig: IMethodSignature;
|
|
sig: IMethodSignature;
|
|
match: Boolean;
|
|
argsStr: string;
|
|
begin
|
|
newCallee := Accept(Node.Callee);
|
|
SetLength(newArgs, Node.Arguments.Count);
|
|
SetLength(argTypes, Node.Arguments.Count);
|
|
|
|
hasUnknownArgs := False;
|
|
for i := 0 to Node.Arguments.Count - 1 do
|
|
begin
|
|
newArgs[i] := Accept(Node.Arguments[i]);
|
|
argTypes[i] := newArgs[i].AsTypedNode.StaticType;
|
|
if argTypes[i].Kind = stUnknown then
|
|
hasUnknownArgs := True;
|
|
end;
|
|
|
|
calleeType := newCallee.AsTypedNode.StaticType;
|
|
retType := TTypes.Unknown;
|
|
|
|
if calleeType.Kind = TStaticTypeKind.stMethod then
|
|
begin
|
|
if not hasUnknownArgs then
|
|
begin
|
|
bestSig := nil;
|
|
for sig in calleeType.Signatures do
|
|
begin
|
|
if Length(sig.ParamTypes) <> Length(argTypes) then
|
|
continue;
|
|
|
|
match := True;
|
|
for j := 0 to High(argTypes) do
|
|
begin
|
|
if not TTypeRules.CanAssign(sig.ParamTypes[j], argTypes[j]) then
|
|
begin
|
|
match := False;
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
if match then
|
|
begin
|
|
bestSig := sig;
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
if Assigned(bestSig) then
|
|
retType := bestSig.ReturnType
|
|
else
|
|
begin
|
|
if Assigned(FLog) then
|
|
begin
|
|
argsStr := '';
|
|
for i := 0 to High(argTypes) do
|
|
argsStr := argsStr + argTypes[i].ToString + ' ';
|
|
FLog.AddError(
|
|
Format('No matching signature for call with args (%s) found on method %s', [argsStr, calleeType.ToString]),
|
|
Node
|
|
);
|
|
end;
|
|
retType := TTypes.Unknown;
|
|
end;
|
|
end;
|
|
end
|
|
else if calleeType.Kind <> TStaticTypeKind.stUnknown then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Cannot invoke type %s as a function.', [calleeType.ToString]), Node);
|
|
retType := TTypes.Unknown;
|
|
end;
|
|
|
|
var argList := TArgumentList.Create(newArgs, Node.Arguments.Identity);
|
|
Result := TAst.FunctionCall(Node.Identity, newCallee, argList, retType, Node.IsTailCall, nil, False);
|
|
end;
|
|
|
|
function TTypeChecker.VisitBlockExpression(const Node: IBlockExpressionNode): IAstNode;
|
|
var
|
|
blockType: IStaticType;
|
|
newExprs: TArray<IAstNode>;
|
|
i: Integer;
|
|
begin
|
|
SetLength(newExprs, Node.Expressions.Count);
|
|
for i := 0 to Node.Expressions.Count - 1 do
|
|
newExprs[i] := Accept(Node.Expressions[i]);
|
|
|
|
if Length(newExprs) > 0 then
|
|
blockType := newExprs[High(newExprs)].AsTypedNode.StaticType
|
|
else
|
|
blockType := TTypes.Void;
|
|
|
|
var exprList := TExpressionList.Create(newExprs, Node.Expressions.Identity);
|
|
Result := TAst.Block(Node.Identity, exprList, blockType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitIfExpression(const Node: IIfExpressionNode): IAstNode;
|
|
var
|
|
conditionType, thenType, elseType, resultType: IStaticType;
|
|
newCond, newThen, newElse: IAstNode;
|
|
begin
|
|
newCond := Accept(Node.Condition);
|
|
newThen := Accept(Node.ThenBranch);
|
|
newElse := Accept(Node.ElseBranch);
|
|
|
|
conditionType := newCond.AsTypedNode.StaticType;
|
|
if (conditionType.Kind <> stUnknown)
|
|
and not TTypeRules.CanAssign(TTypes.Ordinal, conditionType)
|
|
and not TTypeRules.CanAssign(TTypes.Boolean, conditionType) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('If condition must be Boolean or Ordinal, but got %s', [conditionType.ToString]), Node);
|
|
end;
|
|
|
|
thenType := newThen.AsTypedNode.StaticType;
|
|
elseType :=
|
|
if newElse <> nil then newElse.AsTypedNode.StaticType
|
|
else TTypes.Void;
|
|
|
|
resultType := TTypeRules.Promote(thenType, elseType);
|
|
if resultType = nil then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Cannot promote types %s and %s in If-Expression', [thenType.ToString, elseType.ToString]), Node);
|
|
resultType := TTypes.Unknown;
|
|
end;
|
|
|
|
Result := TAst.IfExpr(Node.Identity, newCond, newThen, newElse, resultType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitCondExpression(const Node: ICondExpressionNode): IAstNode;
|
|
var
|
|
i: Integer;
|
|
newPairs: TArray<TCondPair>;
|
|
newElse: IAstNode;
|
|
condType, branchType, resultType: IStaticType;
|
|
begin
|
|
SetLength(newPairs, Length(Node.Pairs));
|
|
resultType := nil;
|
|
|
|
for i := 0 to High(Node.Pairs) do
|
|
begin
|
|
var newCond := Accept(Node.Pairs[i].Condition);
|
|
condType := newCond.AsTypedNode.StaticType;
|
|
|
|
if (condType.Kind <> stUnknown)
|
|
and not TTypeRules.CanAssign(TTypes.Ordinal, condType)
|
|
and not TTypeRules.CanAssign(TTypes.Boolean, condType) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Cond condition must be Boolean or Ordinal, but got %s', [condType.ToString]), Node);
|
|
end;
|
|
|
|
var newBranch := Accept(Node.Pairs[i].Branch);
|
|
branchType := newBranch.AsTypedNode.StaticType;
|
|
|
|
newPairs[i] := TCondPair.Create(newCond, newBranch);
|
|
|
|
if resultType = nil then
|
|
resultType := branchType
|
|
else
|
|
begin
|
|
var promoted := TTypeRules.Promote(resultType, branchType);
|
|
if promoted = nil then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(
|
|
Format('Incompatible types in Cond branches: %s and %s', [resultType.ToString, branchType.ToString]),
|
|
Node
|
|
);
|
|
resultType := TTypes.Unknown;
|
|
end
|
|
else
|
|
resultType := promoted;
|
|
end;
|
|
end;
|
|
|
|
newElse := Accept(Node.ElseBranch);
|
|
var elseType := newElse.AsTypedNode.StaticType;
|
|
|
|
if resultType = nil then
|
|
resultType := elseType
|
|
else
|
|
begin
|
|
var promoted := TTypeRules.Promote(resultType, elseType);
|
|
if promoted = nil then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(
|
|
Format('Incompatible types in Cond branches (Else): %s and %s', [resultType.ToString, elseType.ToString]),
|
|
Node
|
|
);
|
|
resultType := TTypes.Unknown;
|
|
end
|
|
else
|
|
resultType := promoted;
|
|
end;
|
|
|
|
Result := TAst.CondExpr(Node.Identity, newPairs, newElse, resultType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitMemberAccess(const Node: IMemberAccessNode): IAstNode;
|
|
var
|
|
unwrappedBaseType, elemType: IStaticType;
|
|
fieldIndex: Integer;
|
|
newBase, newMember: IAstNode;
|
|
isOptionalAccess: Boolean;
|
|
begin
|
|
newBase := Accept(Node.Base);
|
|
newMember := Accept(Node.Member);
|
|
|
|
unwrappedBaseType := PrepareBaseType(newBase, isOptionalAccess);
|
|
elemType := TTypes.Unknown;
|
|
|
|
if (unwrappedBaseType.Kind <> TStaticTypeKind.stUnknown) then
|
|
begin
|
|
if (unwrappedBaseType.Kind = TStaticTypeKind.stRecord) or (unwrappedBaseType.Kind = TStaticTypeKind.stRecordSeries) then
|
|
begin
|
|
fieldIndex := unwrappedBaseType.Definition.IndexOf(Node.Member.Value);
|
|
if fieldIndex < 0 then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Member "%s" not found in type %s', [Node.Member.Value.Name, unwrappedBaseType.ToString]), Node);
|
|
end
|
|
else
|
|
begin
|
|
var fieldType := TTypes.FromScalarKind(unwrappedBaseType.Definition[fieldIndex].Value);
|
|
if unwrappedBaseType.Kind = TStaticTypeKind.stRecord then
|
|
elemType := fieldType
|
|
else
|
|
elemType := TTypes.CreateSeries(fieldType);
|
|
end;
|
|
end
|
|
else if (unwrappedBaseType.Kind = TStaticTypeKind.stGenericRecord) then
|
|
begin
|
|
var genDef := unwrappedBaseType.GenericDefinition;
|
|
fieldIndex := genDef.IndexOf(Node.Member.Value);
|
|
if fieldIndex < 0 then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Member "%s" not found in type %s', [Node.Member.Value.Name, unwrappedBaseType.ToString]), Node);
|
|
end
|
|
else
|
|
elemType := genDef[fieldIndex].Value;
|
|
end
|
|
else
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Member access requires a record type, but got %s', [unwrappedBaseType.ToString]), Node);
|
|
end;
|
|
end;
|
|
|
|
elemType := ApplyOptionality(elemType, isOptionalAccess);
|
|
|
|
Result := TAst.MemberAccess(Node.Identity, newBase, newMember.AsKeyword, elemType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitIndexer(const Node: IIndexerNode): IAstNode;
|
|
var
|
|
unwrappedBaseType, indexType, elemType: IStaticType;
|
|
newBase, newIndex: IAstNode;
|
|
isOptionalAccess: Boolean;
|
|
begin
|
|
newBase := Accept(Node.Base);
|
|
newIndex := Accept(Node.Index);
|
|
|
|
unwrappedBaseType := PrepareBaseType(newBase, isOptionalAccess);
|
|
|
|
indexType := newIndex.AsTypedNode.StaticType;
|
|
elemType := TTypes.Unknown;
|
|
|
|
if (unwrappedBaseType.Kind <> TStaticTypeKind.stUnknown) then
|
|
begin
|
|
if (unwrappedBaseType.Kind <> TStaticTypeKind.stSeries) and (unwrappedBaseType.Kind <> TStaticTypeKind.stRecordSeries) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Indexer `[]` can only be applied to series types, but got %s', [unwrappedBaseType.ToString]), Node);
|
|
end
|
|
else
|
|
begin
|
|
if unwrappedBaseType.Kind = TStaticTypeKind.stSeries then
|
|
elemType := unwrappedBaseType.ElementType
|
|
else
|
|
elemType := TTypes.CreateRecord(unwrappedBaseType.Definition);
|
|
end;
|
|
end;
|
|
|
|
if (indexType.Kind <> stUnknown) and not TTypeRules.CanAssign(TTypes.Ordinal, indexType) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Indexer `[]` requires an Ordinal index, but got %s', [indexType.ToString]), Node);
|
|
end;
|
|
|
|
elemType := ApplyOptionality(elemType, isOptionalAccess);
|
|
|
|
Result := TAst.Indexer(Node.Identity, newBase, newIndex, elemType);
|
|
end;
|
|
|
|
function TTypeChecker.VisitRecordLiteral(const Node: IRecordLiteralNode): IAstNode;
|
|
var
|
|
i: Integer;
|
|
scalarDefFields: TArray<TScalarRecordField>;
|
|
def: IScalarRecordDefinition;
|
|
staticType: IStaticType;
|
|
valType: IStaticType;
|
|
scalarKind: TScalar.TKind;
|
|
allScalar: Boolean;
|
|
newFields: TArray<IRecordFieldNode>;
|
|
begin
|
|
SetLength(newFields, Node.Fields.Count);
|
|
for i := 0 to Node.Fields.Count - 1 do
|
|
begin
|
|
var field := Node.Fields[i];
|
|
var newKey := Accept(field.Key).AsKeyword;
|
|
var newValue := Accept(field.Value);
|
|
|
|
if (newKey = field.Key) and (newValue = field.Value) then
|
|
newFields[i] := field
|
|
else
|
|
newFields[i] := TAst.RecordField(field.Identity, newKey, newValue);
|
|
end;
|
|
|
|
SetLength(scalarDefFields, Length(newFields));
|
|
allScalar := True;
|
|
|
|
for i := 0 to High(newFields) do
|
|
begin
|
|
valType := newFields[i].Value.AsTypedNode.StaticType;
|
|
|
|
if (valType.Kind = stOrdinal) then
|
|
scalarKind := TScalar.TKind.Ordinal
|
|
else if (valType.Kind = stFloat) then
|
|
scalarKind := TScalar.TKind.Float
|
|
else if (valType.Kind = stKeyword) then
|
|
scalarKind := TScalar.TKind.Keyword
|
|
else if (valType.Kind = stBoolean) then
|
|
scalarKind := TScalar.TKind.Boolean
|
|
else if (valType.Kind = stDateTime) then
|
|
scalarKind := TScalar.TKind.DateTime
|
|
else
|
|
begin
|
|
allScalar := False;
|
|
scalarKind := TScalar.TKind.Ordinal;
|
|
end;
|
|
|
|
if allScalar then
|
|
scalarDefFields[i] := TScalarRecordField.Create(newFields[i].Key.Value, scalarKind);
|
|
end;
|
|
|
|
var fieldList := TRecordFieldList.Create(newFields, Node.Fields.Identity);
|
|
|
|
if allScalar then
|
|
begin
|
|
def := TScalarRecord.TRegistry.Intern(scalarDefFields);
|
|
staticType := TTypes.CreateRecord(def);
|
|
Result := TAst.RecordLiteral(Node.Identity, fieldList, def, nil, staticType);
|
|
end
|
|
else
|
|
begin
|
|
var genDefFields: TArray<TPair<IKeyword, IStaticType>>;
|
|
SetLength(genDefFields, Length(newFields));
|
|
for i := 0 to High(newFields) do
|
|
genDefFields[i] := TPair<IKeyword, IStaticType>.Create(newFields[i].Key.Value, newFields[i].Value.AsTypedNode.StaticType);
|
|
|
|
var genDef := TGenericRecordRegistry.Intern(genDefFields);
|
|
staticType := TTypes.CreateGenericRecord(genDef);
|
|
Result := TAst.RecordLiteral(Node.Identity, fieldList, nil, genDef, staticType);
|
|
end;
|
|
end;
|
|
|
|
function TTypeChecker.VisitCreateSeries(const Node: ICreateSeriesNode): IAstNode;
|
|
var
|
|
elemType: IStaticType;
|
|
defIdentity: IDefinitionIdentity;
|
|
begin
|
|
try
|
|
defIdentity := Node.Identity.AsDefinition;
|
|
elemType := TTypes.FromScalarKind(TScalar.StringToKind(defIdentity.Definition));
|
|
except
|
|
on E: Exception do
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('Invalid type definition "%s" in new-series: %s', [Node.Definition, E.Message]), Node);
|
|
elemType := TTypes.Unknown;
|
|
end;
|
|
end;
|
|
|
|
Result := TAst.CreateSeries(defIdentity, TTypes.CreateSeries(elemType));
|
|
end;
|
|
|
|
function TTypeChecker.VisitAddSeriesItem(const Node: IAddSeriesItemNode): IAstNode;
|
|
var
|
|
seriesType, valueType: IStaticType;
|
|
newSeries, newValue, newLookback: IAstNode;
|
|
begin
|
|
newSeries := Accept(Node.Series);
|
|
newValue := Accept(Node.Value);
|
|
newLookback := Accept(Node.Lookback);
|
|
|
|
seriesType := newSeries.AsTypedNode.StaticType;
|
|
valueType := newValue.AsTypedNode.StaticType;
|
|
|
|
if (seriesType.Kind <> stUnknown) then
|
|
begin
|
|
if (seriesType.Kind <> TStaticTypeKind.stSeries) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('"add" requires a series as its first argument, but got %s', [seriesType.ToString]), Node);
|
|
end
|
|
else
|
|
begin
|
|
if (valueType.Kind <> stUnknown) and not TTypeRules.CanAssign(seriesType.ElementType, valueType) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(
|
|
Format('Cannot add item of type %s to series of type %s', [valueType.ToString, seriesType.ElementType.ToString]),
|
|
Node
|
|
);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if (newLookback <> nil) then
|
|
begin
|
|
var lookbackType := newLookback.AsTypedNode.StaticType;
|
|
if (lookbackType.Kind <> stUnknown) and not (lookbackType.Kind = TStaticTypeKind.stOrdinal) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError('Lookback parameter for "add" must be an ordinal value.', Node);
|
|
end;
|
|
end;
|
|
|
|
Result := TAst.AddSeriesItem(Node.Identity, newSeries.AsIdentifier, newValue, newLookback, TTypes.Void);
|
|
end;
|
|
|
|
function TTypeChecker.VisitNop(const Node: INopNode): IAstNode;
|
|
begin
|
|
Result := TAst.Nop(Node.Identity, TTypes.Void);
|
|
end;
|
|
|
|
function TTypeChecker.VisitSeriesLength(const Node: ISeriesLengthNode): IAstNode;
|
|
var
|
|
seriesType: IStaticType;
|
|
newSeries: IAstNode;
|
|
begin
|
|
newSeries := Accept(Node.Series);
|
|
seriesType := newSeries.AsTypedNode.StaticType;
|
|
|
|
if (seriesType.Kind <> stUnknown)
|
|
and (seriesType.Kind <> TStaticTypeKind.stSeries)
|
|
and (seriesType.Kind <> TStaticTypeKind.stRecordSeries) then
|
|
begin
|
|
if Assigned(FLog) then
|
|
FLog.AddError(Format('"length" requires a series, but got %s', [seriesType.ToString]), Node);
|
|
end;
|
|
|
|
Result := TAst.SeriesLength(Node.Identity, newSeries.AsIdentifier, TTypes.Ordinal);
|
|
end;
|
|
|
|
end.
|