@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -1,532 +0,0 @@
-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");
-        }
-        const entrySrc = await this.compileFile(filePath, true);
-        if (this.diagnostics.length > 0 || !entrySrc)
-            throw new Error("AstCompiler.compile: compilation failed");
-        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

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

package/dist/compiler/AstCompiler/index.js

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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);
-}

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

@@ -1,6 +0,0 @@
-import { CaseExpr, CaseExprMatcher } from "../../../../ast/nodes/expr/CaseExpr.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileCaseExpr(ctx: AstCompilationCtx, expr: CaseExpr, typeHint: TirType | undefined): TirCaseExpr | undefined;
-export declare function _compileCaseExprMatcher(ctx: AstCompilationCtx, matcher: CaseExprMatcher, patternType: TirType, returnTypeHint: TirType | undefined): TirCaseMatcher | undefined;