@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -0,0 +1,542 @@
+import { StructDecl, StructDeclAstFlags } from "../../ast/nodes/statements/declarations/StructDecl.js";
+import { TypeAliasDecl } from "../../ast/nodes/statements/declarations/TypeAliasDecl.js";
+import { ExportStarStmt } from "../../ast/nodes/statements/ExportStarStmt.js";
+import { ImportStarStmt } from "../../ast/nodes/statements/ImportStarStmt.js";
+import { ImportStmt } from "../../ast/nodes/statements/ImportStmt.js";
+import { Source, SourceKind } from "../../ast/Source/Source.js";
+import { SourceRange } from "../../ast/Source/SourceRange.js";
+import { DiagnosticEmitter } from "../../diagnostics/DiagnosticEmitter.js";
+import { DiagnosticCode } from "../../diagnostics/diagnosticMessages.generated.js";
+import { Parser } from "../../parser/Parser.js";
+import { createMemoryCompilerIoApi } from "../io/CompilerIoApi.js";
+import { TypedProgram } from "../tir/program/TypedProgram.js";
+import { TirAliasType } from "../tir/types/TirAliasType.js";
+import { TirDataStructType, TirSoPStructType, TirStructConstr, TirStructField } from "../tir/types/TirStructType.js";
+import { ExportStmt } from "../../ast/nodes/statements/ExportStmt.js";
+import { ResolveStackNode } from "./utils/deps/ResolveStackNode.js";
+import { AstCompilationCtx } from "./AstCompilationCtx.js";
+import { _compileDataEncodedConcreteType } from "./internal/types/_compileDataEncodedConcreteType.js";
+import { getAbsolutePath, getEnvRelativePath } from "../path/getAbsolutePath.js";
+import { _compileSopEncodedConcreteType } from "./internal/types/_compileSopEncodedConcreteType.js";
+import { InterfaceDecl } from "../../ast/nodes/statements/declarations/InterfaceDecl.js";
+import { AstFuncType } from "../../ast/nodes/types/AstNativeTypeExpr.js";
+import { FuncDecl } from "../../ast/nodes/statements/declarations/FuncDecl.js";
+import { InterfaceMethodImpl, TypeImplementsStmt } from "../../ast/nodes/statements/TypeImplementsStmt.js";
+import { PEBBLE_INTERNAL_IDENTIFIER_PREFIX } from "../internalVar.js";
+import { AstNamedTypeExpr } from "../../ast/nodes/types/AstNamedTypeExpr.js";
+import { FuncExpr } from "../../ast/nodes/expr/functions/FuncExpr.js";
+import { CommonFlags } from "../../common.js";
+import { SimpleVarDecl } from "../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { Identifier } from "../../ast/nodes/common/Identifier.js";
+import { ArrowKind } from "../../ast/nodes/expr/functions/ArrowKind.js";
+import { _compileFuncExpr } from "./internal/exprs/_compileFuncExpr.js";
+/*
+Handling type expressions that depend on other types
+(such as generics, function return types, and inferred types from complex expressions)
+requires a more structured approach.
+
+This typically involves a two-pass system:
+
+    1) First Pass (Declaration & Collection):
+        Collect all type information and dependencies.
+
+    2) Second Pass (Resolution & Inference):
+        Resolve dependent types, infer missing types,
+        and enforce type consistency.
+*/
+/**
+ * compiles Pebble AST to a Typed IR program (TypedProgram).
+ *
+ * AST -> TypedProgram (astCompiler.program)
+ *
+ * The AST is simply the result of tokenization and parsing.
+ *
+ * Therefore the AST is only syntactically correct, but not necessarily semantically correct.
+ *
+ * During the compilation from AST to TIR,
+ * missing types are inferred and the resulting TIR is checked for semantic correctness.
+ *
+ * In short, here is where type checking happens.
+ */
+export class AstCompiler extends DiagnosticEmitter {
+    cfg;
+    io;
+    /**
+     * The standard library scope.
+     *
+     * (ScriptContext, built-in functions, etc.)
+    **/
+    get preludeScope() {
+        return this.program.preludeScope;
+    }
+    program;
+    parsedAstSources = new Map();
+    get rootPath() {
+        return this.cfg.root;
+    }
+    constructor(cfg, io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), diagnostics) {
+        super(diagnostics);
+        this.cfg = cfg;
+        this.io = io;
+        this.program = new TypedProgram(this.diagnostics);
+    }
+    /**
+     * compiles the entry file specified in the config
+     *
+     * the result is store in `this.program`
+     */
+    async compile() {
+        const filePath = this.cfg.entry; // getEnvRelativePath( this.cfg.entry, this.rootPath );
+        if (!filePath) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
+            throw new Error("entry file not found");
+        }
+        if (!this.io.exsistSync(filePath))
+            throw new Error("AstCompiler.compile: entry file does not exist: " + filePath);
+        const entrySrc = await this.compileFile(filePath, true);
+        if (this.diagnostics.length > 0 || !entrySrc) {
+            let msg;
+            globalThis.console && console.log(this.diagnostics);
+            const fstErrorMsg = this.diagnostics[0].toString();
+            const nDiags = this.diagnostics.length;
+            while (msg = this.diagnostics.shift()) {
+                this.io.stdout.write(msg.toString() + "\n");
+            }
+            throw new Error("AstCompiler.compile: failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+        }
+        const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
+        if (this.program.contractTirFuncName === "" || !mainFuncExpr) {
+            this.error(DiagnosticCode.Main_function_is_missing, undefined);
+            return this.program;
+        }
+        if (!mainFuncExpr)
+            this.error(DiagnosticCode._0_is_not_defined, entrySrc.range.atStart(), "main");
+        return this.program;
+    }
+    // mutually recursive
+    async compileFile(path, isMain = false) {
+        const src = await this.getAbsoulteProjPathSource(path);
+        if (!src)
+            return;
+        // parse imports first
+        await this.compileAllDeps(ResolveStackNode.entry(src), isMain);
+        // if there were errors
+        if (this.diagnostics.length > 0)
+            return;
+        await this._compileParsedSource(src, isMain);
+        return src;
+    }
+    _srcDonelogUids = new Set();
+    /**
+     * translates the source AST statements
+     * to TIR statements; and saves the result in `this.program`
+     */
+    async _compileParsedSource(src, isMain = false) {
+        if (this._srcDonelogUids.has(src.uid))
+            return;
+        // clone array so we don't remove stmts from the original AST
+        const stmts = src.statements.slice();
+        const importsScope = this.preludeScope.newChildScope({ isFunctionDeclScope: false });
+        // defines imported symbols on top level scope, modifies stmts array
+        this._consumeImportsAddSymsInScope(stmts, src.absoluteProjPath, importsScope);
+        const topLevelScope = importsScope.newChildScope({ isFunctionDeclScope: false });
+        const srcExports = this.preludeScope.newChildScope({ isFunctionDeclScope: false });
+        // collect top level **type** (struct and aliases) declarations
+        this._collectTypeDeclarations(stmts, src.uid, topLevelScope, srcExports);
+        // collect top level **interface** declarations (NOT implementations)
+        this._collectInterfaceDeclarations(stmts, topLevelScope, srcExports);
+        // collects top level functions, methods (interface impls), and consts types
+        this._collectAllTopLevelSignatures(stmts, src.uid, topLevelScope, srcExports, isMain);
+        /*
+        this._compileTopLevelFunctionsAndConsts(
+            stmts,
+            src.uid,
+            topLevelScope,
+            srcExports
+        );
+        //*/
+        this.program.setExportedSymbols(src.absoluteProjPath, srcExports);
+        this._srcDonelogUids.add(src.uid);
+    }
+    _collectAllTopLevelSignatures(stmts, srcUid, topLevelScope, srcExports, isMain = false) {
+        for (let i = 0; i < stmts.length; i++) {
+            let stmt = stmts[i];
+            let exported = false;
+            let exportRange = undefined;
+            if (stmt instanceof ExportStmt) {
+                exported = true;
+                exportRange = stmt.range;
+                stmt = stmt.stmt;
+            }
+            if (!(stmt instanceof FuncDecl
+                || stmt instanceof TypeImplementsStmt))
+                continue;
+            if (exported && stmt instanceof TypeImplementsStmt)
+                this.error(DiagnosticCode.Interface_implementations_cannot_be_exported, exportRange ?? stmt.range);
+            if (stmt instanceof FuncDecl)
+                this._collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports, exportRange, isMain);
+            else
+                this._collectInterfaceImplSigs(stmt, srcUid, topLevelScope);
+            // remove from array so we don't process it again
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    _collectInterfaceImplSigs(stmt, srcUid, topLevelScope) {
+        stmt.typeIdentifier;
+        stmt.interfaceType;
+        stmt.methodImplementations;
+        // stmt.range;
+        if (stmt.typeIdentifier instanceof AstNamedTypeExpr
+            && stmt.typeIdentifier.tyArgs.length > 0)
+            return this.error(DiagnosticCode.Not_implemented_0, stmt.typeIdentifier.range, "generic types interface implementations");
+        const typeAstName = stmt.typeIdentifier.toAstName();
+        const possibleTirTypes = topLevelScope.resolveLocalType(typeAstName);
+        if (!possibleTirTypes)
+            return this.error(DiagnosticCode.Method_implementations_are_only_allowed_for_types_declared_locally, stmt.typeIdentifier.range);
+        const uniqueTypeAstName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + typeAstName + "_" + srcUid;
+        const typeMethodsMap = possibleTirTypes.methodsNames;
+        for (const method of stmt.methodImplementations) {
+            if (!(method instanceof InterfaceMethodImpl))
+                continue;
+            if (method.typeParameters.length > 0) {
+                this.error(DiagnosticCode.Not_implemented_0, method.methodName.range, "generic methods");
+                continue;
+            }
+            const astMethodName = method.methodName.text;
+            const tirMethodName = uniqueTypeAstName + "." + astMethodName;
+            if (typeMethodsMap.has(astMethodName)) {
+                this.error(DiagnosticCode.Method_0_is_already_implemented, method.methodName.range, astMethodName);
+                continue;
+            }
+            typeMethodsMap.set(astMethodName, tirMethodName);
+            const completeSig = new AstFuncType([
+                new SimpleVarDecl(new Identifier("this", stmt.typeIdentifier.range), stmt.typeIdentifier, undefined, // initExpr
+                CommonFlags.None, stmt.typeIdentifier.range),
+                ...method.signature.params
+            ], method.signature.returnType, method.signature.range);
+            const astFuncExpr = new FuncExpr(method.methodName, CommonFlags.None, [], // method.typeParameters,
+            completeSig, method.body, ArrowKind.None, method.range);
+            const funcExpr = _compileFuncExpr(AstCompilationCtx.fromScope(this.program, topLevelScope), astFuncExpr, undefined, true);
+            if (!funcExpr)
+                return undefined;
+            this.program.functions.set(tirMethodName, funcExpr);
+        }
+    }
+    _collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isMain = false) {
+        const astFuncExpr = stmt.expr;
+        const astFuncName = astFuncExpr.name.text;
+        const tirFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astFuncName + "_" + srcUid;
+        const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
+        const funcExpr = _compileFuncExpr(declContext, astFuncExpr, undefined, // sig
+        false // isMethod
+        );
+        if (!funcExpr)
+            return undefined;
+        this.program.functions.set(tirFuncName, funcExpr);
+        if (topLevelScope.functions.has(astFuncName))
+            return this.error(DiagnosticCode._0_is_already_defined, astFuncExpr.name.range, astFuncName);
+        topLevelScope.functions.set(astFuncName, tirFuncName);
+        if (exportRange && srcExports) {
+            if (srcExports.functions.has(astFuncName)
+                || srcExports.variables.has(astFuncName))
+                return this.error(DiagnosticCode._0_is_already_exported, exportRange, astFuncName);
+            else {
+                srcExports.functions.set(astFuncName, tirFuncName);
+            }
+        }
+        if (isMain
+            && this.program.contractTirFuncName === ""
+            && astFuncExpr.name.text === "main")
+            this.program.contractTirFuncName = tirFuncName;
+    }
+    _collectInterfaceDeclarations(stmts, topLevelScope, srcExports) {
+        for (let i = 0; i < stmts.length; i++) {
+            let stmt = stmts[i];
+            let exported = false;
+            if (stmt instanceof ExportStmt) {
+                exported = true;
+                stmt = stmt.stmt;
+            }
+            if (!(stmt instanceof InterfaceDecl))
+                continue;
+            const isGeneric = stmt.typeParams.length > 0;
+            if (isGeneric)
+                throw new Error("not implemented; generic interfaces");
+            const methods = new Map();
+            for (const astMethod of stmt.methods) {
+                if (astMethod.body)
+                    this.warning(DiagnosticCode.Default_method_implementatitons_are_not_supported_default_implementation_will_be_ignored, astMethod.body.range);
+                methods.set(astMethod.name.text, astMethod.signature);
+            }
+            topLevelScope.interfaces.set(stmt.name.text, methods);
+            if (exported)
+                srcExports.interfaces.set(stmt.name.text, new Map(methods));
+            // remove from array so we don't process it again
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    _collectTypeDeclarations(stmts, srcUid, topLevelScope, srcExports) {
+        for (let i = 0; i < stmts.length; i++) {
+            let stmt = stmts[i];
+            let exported = false;
+            if (stmt instanceof ExportStmt) {
+                exported = true;
+                stmt = stmt.stmt;
+            }
+            if (!(stmt instanceof StructDecl
+                || stmt instanceof TypeAliasDecl))
+                continue;
+            const isGeneric = stmt.typeParams.length > 0;
+            const tirTypes = stmt instanceof StructDecl
+                ? this._compileStructDecl(stmt, srcUid, topLevelScope)
+                : this._compileTypeAliasDecl(stmt, srcUid, topLevelScope);
+            if (!tirTypes // undefined
+                || !(tirTypes.sop || tirTypes.data) // or both undefined
+            )
+                continue; // ignore type decl
+            // define on program
+            if (tirTypes.sop)
+                this.program.types.set(tirTypes.sop.toConcreteTirTypeName(), tirTypes.sop);
+            if (tirTypes.data)
+                this.program.types.set(tirTypes.data.toConcreteTirTypeName(), tirTypes.data);
+            const sopTirName = tirTypes.sop?.toTirTypeKey() ?? tirTypes.data.toTirTypeKey();
+            const dataTirName = tirTypes.data?.toTirTypeKey();
+            const possibleTirTypes = Object.freeze({
+                sopTirName,
+                dataTirName,
+                allTirNames: new Set([
+                    sopTirName,
+                    dataTirName,
+                ].filter(str => typeof str === "string")),
+                methodsNames: tirTypes.methodsNames,
+                isGeneric,
+            });
+            // define on scope
+            void topLevelScope.defineType(stmt.name.text, possibleTirTypes);
+            if (exported) {
+                if (srcExports.types.has(stmt.name.text))
+                    this.error(DiagnosticCode._0_is_already_exported, stmt.name.range, stmt.name.text);
+                else if (isGeneric) {
+                    this.error(DiagnosticCode.Not_implemented_0, stmt.name.range, "typeParams");
+                    continue;
+                }
+                else {
+                    void srcExports.types.set(stmt.name.text, possibleTirTypes);
+                }
+            }
+            // remove from array so we don't process it again
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    _compileStructDecl(stmt, srcUid, topLevelScope) {
+        if (stmt.typeParams.length > 0)
+            throw new Error("not_implemented::AstCompiler::_compileStructDecl::typeParams");
+        const compiler = this;
+        const methodsNames = new Map();
+        let sop = undefined;
+        let data = undefined;
+        // sop encoded type
+        if (!stmt.hasFlag(StructDeclAstFlags.onlyDataEncoding)) {
+            sop = (new TirSoPStructType(stmt.name.text, srcUid, stmt.constrs.map(ctor => new TirStructConstr(ctor.name.text, ctor.fields.map(field => {
+                if (!field.type)
+                    return compiler.error(DiagnosticCode.Type_expected, field.name.range.atEnd());
+                // TODO: recursive struct definitions
+                const fieldType = _compileSopEncodedConcreteType(AstCompilationCtx.fromScope(compiler.program, topLevelScope), field.type);
+                if (!fieldType)
+                    return undefined;
+                return new TirStructField(field.name.text, fieldType);
+            })
+                .filter(f => f instanceof TirStructField))), methodsNames));
+        }
+        // data encoded type
+        if (!stmt.hasFlag(StructDeclAstFlags.onlySopEncoding)) {
+            let canEncodeToData = true;
+            const dataType = new TirDataStructType(stmt.name.text, srcUid, stmt.constrs.map(ctor => new TirStructConstr(ctor.name.text, ctor.fields.map(field => {
+                if (!field.type)
+                    return compiler.error(DiagnosticCode.Type_expected, field.name.range.atEnd());
+                if (!canEncodeToData)
+                    return undefined;
+                // TODO: recursive struct definitions
+                const fieldType = _compileDataEncodedConcreteType(AstCompilationCtx.fromScope(compiler.program, topLevelScope), field.type);
+                if (!fieldType) {
+                    canEncodeToData = false;
+                    return undefined;
+                }
+                return new TirStructField(field.name.text, fieldType);
+            })
+                .filter(f => f instanceof TirStructField))), methodsNames);
+            if (canEncodeToData)
+                data = dataType;
+            else if (stmt.hasFlag(StructDeclAstFlags.onlyDataEncoding))
+                this.error(DiagnosticCode.Type_0_cannot_be_encoded_as_data, stmt.name.range, stmt.name.text);
+            else
+                this.warning(DiagnosticCode.Type_0_cannot_be_encoded_as_data_but_it_has_a_runtime_encoding_Use_runtime_keyword_modifier_for_the_declaration, stmt.range, stmt.name.text);
+        }
+        return sop || data ? { sop, data, methodsNames } : undefined;
+    }
+    _compileTypeAliasDecl(stmt, srcUid, topLevelScope) {
+        if (stmt.typeParams.length > 0)
+            throw new Error("not_implemented::AstCompiler::_compileTypeAliasDecl::typeParams");
+        const compiler = this;
+        const sopAliasedT = _compileSopEncodedConcreteType(AstCompilationCtx.fromScope(compiler.program, topLevelScope), stmt.aliasedType);
+        const dataAliasedT = _compileDataEncodedConcreteType(AstCompilationCtx.fromScope(compiler.program, topLevelScope), stmt.aliasedType);
+        const methodsNames = new Map();
+        const sop = sopAliasedT ? new TirAliasType(stmt.name.text, srcUid, sopAliasedT, methodsNames // interface implementations
+        ) : undefined;
+        const data = dataAliasedT ? new TirAliasType(stmt.name.text, srcUid, dataAliasedT, methodsNames // interface implementations
+        ) : undefined;
+        return sop || data ? { sop, data, methodsNames } : undefined;
+    }
+    _consumeImportsAddSymsInScope(stmts, srcAbsPath, srcImportsScope) {
+        for (let i = 0; i < stmts.length; i++) {
+            const stmt = stmts[i];
+            if (stmt instanceof ImportStarStmt) {
+                this.error(DiagnosticCode.Not_implemented_0, stmt.range, "import *");
+                continue;
+            }
+            if (!(stmt instanceof ImportStmt))
+                continue;
+            const importAbsPath = getAbsolutePath(stmt.fromPath.string, srcAbsPath) ?? "";
+            // console.log(projAbsoultePath, [ ...this.program.files.keys() ]);
+            const importedSymbols = this.program.getExportedSymbols(importAbsPath);
+            if (!importedSymbols) {
+                return this.error(DiagnosticCode.File_0_not_found, stmt.fromPath.range, importAbsPath // stmt.fromPath.string
+                );
+            }
+            for (const importDecl of stmt.members) {
+                const declName = importDecl.identifier.text;
+                const isValue = importedSymbols.variables.has(declName);
+                const isType = importedSymbols.types.has(declName);
+                const isFunction = importedSymbols.functions.has(declName);
+                const isInterface = importedSymbols.interfaces.has(declName);
+                if (!(isValue
+                    || isType
+                    || isFunction
+                    || isInterface)) {
+                    this.error(DiagnosticCode.Module_0_has_no_exported_member_1, importDecl.identifier.range, stmt.fromPath.string, declName);
+                    continue;
+                }
+                // define on source top level scope
+                if (isValue)
+                    srcImportsScope.variables.set(declName, importedSymbols.variables.get(declName));
+                if (isFunction)
+                    srcImportsScope.functions.set(declName, importedSymbols.functions.get(declName));
+                if (isType)
+                    srcImportsScope.types.set(declName, importedSymbols.types.get(declName));
+                if (isInterface)
+                    srcImportsScope.interfaces.set(declName, importedSymbols.interfaces.get(declName));
+            }
+            // remove from array so we don't process it again
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    async _readFile(path) {
+        path = getEnvRelativePath(path, this.rootPath);
+        if (typeof path !== "string")
+            return undefined;
+        return await this.io.readFile(path, this.rootPath);
+    }
+    /** MUST NOT be used as a "seen" log */
+    _sourceCache = new Map();
+    async getAbsoulteProjPathSource(absoluteProjPath) {
+        const cached = this.parsedAstSources.get(absoluteProjPath) ?? this._sourceCache.get(absoluteProjPath);
+        if (cached)
+            return cached;
+        const srcText = await this._readFile(absoluteProjPath);
+        if (!srcText)
+            return this.error(DiagnosticCode.File_0_not_found, undefined, absoluteProjPath);
+        const src = new Source(SourceKind.User, absoluteProjPath, this.program.getFilePrefix(absoluteProjPath), srcText);
+        this._sourceCache.set(absoluteProjPath, src);
+        return src;
+    }
+    /**
+     * @returns `true` if there were no errors. `false` otherwise.
+     */
+    async compileAllDeps(_resolveStackNode, isMain = false) {
+        const src = _resolveStackNode.dependent; // resolveStackNode instanceof ResolveStackNode ? source.dependent : source;
+        const resolveStack = _resolveStackNode; // source instanceof ResolveStackNode ? source : new ResolveStackNode( undefined, src );
+        const isCycle = resolveStack.parent?.includesInternalPath(src.absoluteProjPath) ?? false;
+        if (isCycle) {
+            this._reportCircularDependency(src, resolveStack);
+            return false;
+        }
+        // if already parsed
+        if (this.parsedAstSources.has(src.absoluteProjPath))
+            return true;
+        Parser.parseSource(src, this.diagnostics);
+        this.parsedAstSources.set(src.absoluteProjPath, src);
+        if (this.diagnostics.length > 0)
+            return false;
+        // get all imports to parse recursively
+        const imports = src.statements.filter(isImportStmtLike);
+        const srcPath = resolveStack.dependent.absoluteProjPath;
+        const paths = this.importPathsFromStmts(imports, srcPath);
+        const importedSources = await Promise.all(paths.map(this.getAbsoulteProjPathSource.bind(this)));
+        for (const src of importedSources) {
+            if (!src)
+                continue; // error already reported in `importPathsFromStmts`
+            const nextStack = new ResolveStackNode(resolveStack, src);
+            // recursively parse imported files
+            if (!await this.compileAllDeps(nextStack))
+                return false;
+        }
+        this._compileParsedSource(src, isMain);
+        return true;
+    }
+    importPathsFromStmts(stmts, requestingPath) {
+        return stmts
+            .map(imp => {
+            const absoluteProjPath = getAbsolutePath(imp.fromPath.string, requestingPath);
+            if (!absoluteProjPath) {
+                this.error(DiagnosticCode.File_0_not_found, imp.fromPath.range, imp.fromPath.string);
+                return "";
+            }
+            return absoluteProjPath;
+        })
+            .filter(path => path !== "");
+    }
+    _reportCircularDependency(src, resolveStack) {
+        const offendingPath = src.absoluteProjPath;
+        let prevPath = offendingPath;
+        let req = resolveStack;
+        const pathsInCycle = [];
+        const seen = new Set();
+        // we go through the loop so we can signal the error
+        // at every offending import
+        while (req = req.parent) {
+            const importStmt = req.dependent.statements.find(stmt => {
+                if (!isImportStmtLike(stmt))
+                    return false;
+                const asRootPath = getAbsolutePath(stmt.fromPath.string, req.dependent.absoluteProjPath);
+                if (!asRootPath)
+                    return false;
+                return asRootPath === prevPath;
+            });
+            prevPath = req.dependent.absoluteProjPath;
+            if (!importStmt) {
+                this.error(DiagnosticCode.Import_path_0_is_part_of_a_circular_dependency, new SourceRange(req.dependent, 0, 0), offendingPath);
+                continue;
+            }
+            const thePath = importStmt.fromPath.string;
+            const last = seen.has(thePath);
+            if (!last) {
+                pathsInCycle.push(thePath);
+                seen.add(thePath);
+            }
+            pathsInCycle.push(thePath);
+            this.error(DiagnosticCode.Import_path_0_is_part_of_a_circular_dependency, importStmt.range, thePath);
+            if (last)
+                break;
+        }
+        ;
+    }
+}
+function isImportStmtLike(stmt) {
+    return (stmt instanceof ImportStmt
+        || stmt instanceof ImportStarStmt
+        || stmt instanceof ExportStarStmt);
+}

package/dist/compiler/AstCompiler/index.d.ts

@@ -0,0 +1 @@
+export * from "./AstCompiler.js";

package/dist/compiler/AstCompiler/index.js

@@ -0,0 +1 @@
+export * from "./AstCompiler.js";

package/dist/compiler/AstCompiler/internal/exprs/_compileBinaryExpr.d.ts

@@ -0,0 +1,5 @@
+import { BinaryExpr } from "../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { TirExpr } from "../../../tir/expressions/TirExpr.js";
+import { TirType } from "../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileBinaryExpr(ctx: AstCompilationCtx, expr: BinaryExpr, typeHint: TirType | undefined): TirExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compileBinaryExpr.js

@@ -0,0 +1,66 @@
+import { ExponentiationExpr, LessThanExpr, GreaterThanExpr, LessThanEqualExpr, GreaterThanEqualExpr, EqualExpr, NotEqualExpr, AddExpr, SubExpr, MultExpr, DivExpr, ModuloExpr, ShiftLeftExpr, ShiftRightExpr, BitwiseAndExpr, BitwiseXorExpr, BitwiseOrExpr, LogicalAndExpr, LogicalOrExpr, OptionalDefaultExpr } from "../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { _compileAddExpr } from "./binary/_compileAddExpr.js";
+import { _compileBitwiseAndExpr } from "./binary/_compileBitwiseAndExpr.js";
+import { _compileBitwiseOrExpr } from "./binary/_compileBitwiseOrExpr.js";
+import { _compileBitwiseXorExpr } from "./binary/_compileBitwiseXorExpr.js";
+import { _compileDivExpr } from "./binary/_compileDivExpr.js";
+import { _compileEqualExpr } from "./binary/_compileEqualExpr.js";
+import { _compileExponentiationExpr } from "./binary/_compileExponentiationExpr.js";
+import { _compileGreaterThanEqualExpr } from "./binary/_compileGreaterThanEqualExpr.js";
+import { _compileGreaterThanExpr } from "./binary/_compileGreaterThanExpr.js";
+import { _compileLessThanEqualExpr } from "./binary/_compileLessThanEqualExpr.js";
+import { _compileLessThanExpr } from "./binary/_compileLessThanExpr.js";
+import { _compileLogicalAndExpr } from "./binary/_compileLogicalAndExpr.js";
+import { _compileLogicalOrExpr } from "./binary/_compileLogicalOrExpr.js";
+import { _compileModuloExpr } from "./binary/_compileModuloExpr.js";
+import { _compileMultExpr } from "./binary/_compileMultExpr.js";
+import { _compileNotEqualExpr } from "./binary/_compileNotEqualExpr.js";
+import { _compileOptionalDefaultExpr } from "./binary/_compileOptionalDefaultExpr.js";
+import { _compileShiftLeftExpr } from "./binary/_compileShiftLeftExpr.js";
+import { _compileShiftRightExpr } from "./binary/_compileShiftRightExpr.js";
+import { _compileSubExpr } from "./binary/_compileSubExpr.js";
+export function _compileBinaryExpr(ctx, expr, typeHint) {
+    if (expr instanceof ExponentiationExpr)
+        return _compileExponentiationExpr(ctx, expr, typeHint);
+    if (expr instanceof LessThanExpr)
+        return _compileLessThanExpr(ctx, expr, typeHint);
+    if (expr instanceof GreaterThanExpr)
+        return _compileGreaterThanExpr(ctx, expr, typeHint);
+    if (expr instanceof LessThanEqualExpr)
+        return _compileLessThanEqualExpr(ctx, expr, typeHint);
+    if (expr instanceof GreaterThanEqualExpr)
+        return _compileGreaterThanEqualExpr(ctx, expr, typeHint);
+    if (expr instanceof EqualExpr)
+        return _compileEqualExpr(ctx, expr, typeHint);
+    if (expr instanceof NotEqualExpr)
+        return _compileNotEqualExpr(ctx, expr, typeHint);
+    if (expr instanceof AddExpr)
+        return _compileAddExpr(ctx, expr, typeHint);
+    if (expr instanceof SubExpr)
+        return _compileSubExpr(ctx, expr, typeHint);
+    if (expr instanceof MultExpr)
+        return _compileMultExpr(ctx, expr, typeHint);
+    if (expr instanceof DivExpr)
+        return _compileDivExpr(ctx, expr, typeHint);
+    if (expr instanceof ModuloExpr)
+        return _compileModuloExpr(ctx, expr, typeHint);
+    if (expr instanceof ShiftLeftExpr)
+        return _compileShiftLeftExpr(ctx, expr, typeHint);
+    if (expr instanceof ShiftRightExpr)
+        return _compileShiftRightExpr(ctx, expr, typeHint);
+    if (expr instanceof BitwiseAndExpr)
+        return _compileBitwiseAndExpr(ctx, expr, typeHint);
+    if (expr instanceof BitwiseXorExpr)
+        return _compileBitwiseXorExpr(ctx, expr, typeHint);
+    if (expr instanceof BitwiseOrExpr)
+        return _compileBitwiseOrExpr(ctx, expr, typeHint);
+    if (expr instanceof LogicalAndExpr)
+        return _compileLogicalAndExpr(ctx, expr, typeHint);
+    if (expr instanceof LogicalOrExpr)
+        return _compileLogicalOrExpr(ctx, expr, typeHint);
+    if (expr instanceof OptionalDefaultExpr)
+        return _compileOptionalDefaultExpr(ctx, expr, typeHint);
+    const tsEnsureExsautstiveCheck = expr;
+    console.error(expr);
+    throw new Error("unreachable::AstCompiler::_compileBinaryExpr");
+}

package/dist/compiler/AstCompiler/internal/exprs/_compileCallExpr.d.ts

@@ -0,0 +1,5 @@
+import { CallExpr } from "../../../../ast/nodes/expr/functions/CallExpr.js";
+import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
+import { TirType } from "../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileCallExpr(ctx: AstCompilationCtx, expr: CallExpr, typeHint: TirType | undefined): TirCallExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compileCallExpr.js

@@ -0,0 +1,36 @@
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
+import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
+import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "./_compileExpr.js";
+export function _compileCallExpr(ctx, expr, typeHint) {
+    // TODO: expr.genericTypeArgs
+    // expr.funcExpr;
+    // expr.args;
+    // expr.range;
+    if (!(typeHint instanceof TirFuncT))
+        typeHint = undefined;
+    const funcExpr = _compileExpr(ctx, expr.funcExpr, typeHint);
+    if (!funcExpr)
+        return undefined;
+    if (!(funcExpr.type instanceof TirFuncT))
+        return ctx.error(DiagnosticCode.Expression_is_not_callable, expr.funcExpr.range);
+    const funcType = funcExpr.type;
+    for (let i = funcType.argTypes.length; i < expr.args.length; i++) {
+        ctx.warning(DiagnosticCode.Unexpected_argument, expr.args[i].range); // not a big deal
+    }
+    if (funcType.argTypes.length < expr.args.length)
+        expr.args.length = funcType.argTypes.length; // drop extra
+    const finalCallExprType = funcType.argTypes.length === expr.args.length ?
+        funcType.returnType :
+        new TirFuncT(funcType.argTypes.slice(expr.args.length), funcType.returnType);
+    const args = expr.args.map((arg, i) => _compileExpr(ctx, arg, funcType.argTypes[i])); // we early return in case of undefined
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            return undefined;
+        if (!canAssignTo(arg.type, funcType.argTypes[i]))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, arg.type.toString(), funcType.argTypes[i].toString());
+    }
+    return new TirCallExpr(funcExpr, args, finalCallExprType, expr.range);
+}