@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

package/dist/compiler/AstCompiler/internal/statements/_compileVarStmt.js

@@ -1,207 +0,0 @@
-import { ArrayLikeDeconstr } from "../../../../ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js";
-import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
-import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
-import { SingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirArrayLikeDeconstr } from "../../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
-import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { TirSingleDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
-import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
-import { isTirOptType } from "../../../tir/types/TirNativeType/native/Optional/isTirOptType.js";
-import { isTirStructType, TirStructConstr, TirStructField } from "../../../tir/types/TirStructType.js";
-import { getNamedDestructableType, getStructType, canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
-import { canCastToData } from "../../../tir/types/utils/canCastTo.js";
-import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
-import { _compileExpr } from "../exprs/_compileExpr.js";
-import { _compileSopEncodedConcreteType } from "../types/_compileSopEncodedConcreteType.js";
-export function _compileVarStmt(ctx, stmt) {
-    const tirVarDecls = new Array(stmt.declarations.length);
-    for (let i = 0; i < stmt.declarations.length; i++) {
-        const decl = stmt.declarations[i];
-        const tirDecl = _compileVarDecl(ctx, decl, undefined);
-        if (!tirDecl)
-            return undefined;
-        tirVarDecls[i] = tirDecl;
-    }
-    return tirVarDecls;
-}
-export function _compileVarDecl(ctx, decl, typeHint) {
-    if (decl instanceof SimpleVarDecl)
-        return _compileSimpleVarDecl(ctx, decl, typeHint);
-    if (decl instanceof NamedDeconstructVarDecl)
-        return _compileNamedDeconstructVarDecl(ctx, decl, typeHint);
-    if (decl instanceof SingleDeconstructVarDecl)
-        return _compileSingleDeconstructVarDecl(ctx, decl, typeHint);
-    if (decl instanceof ArrayLikeDeconstr)
-        return _compileArrayLikeDeconstr(ctx, decl, typeHint);
-    const tsEnsureExsautstiveCheck = decl;
-    console.error(decl);
-    throw new Error("unreachable::AstCompiler::_compileVarDecl");
-}
-export function _compileSimpleVarDecl(ctx, decl, typeHint) {
-    const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
-    if (!typeAndExpr)
-        return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
-    const success = ctx.scope.defineValue({
-        name: decl.name.text,
-        type: finalVarType,
-        isConstant: decl.isConst()
-    });
-    if (!success)
-        return ctx.error(DiagnosticCode.Duplicate_identifier_0, decl.name.range, decl.name.text);
-    return new TirSimpleVarDecl(decl.name.text, finalVarType, initExpr, decl.isConst(), decl.range);
-}
-export function _compileNamedDeconstructVarDecl(ctx, decl, typeHint) {
-    // const Spending{ ref, optionalDatum: datum as MyDatum } = purpose
-    // 
-    // if encoded as data becomes:
-    //
-    // const §rawPurposePair: §NativePair<int,List<data>> = purpose.raw;
-    // assert §rawPurposePair.fst === /* speding constructor index */;
-    // const §rawPurposeFields: List<data> = §rawPurposePair.snd;
-    // const ref: TxOutRef = §rawPurposeFields[/* `ref` field index */];
-    // const datum: MyDatum = §rawPurposeFields[/* `optionalDatum` field index */];
-    // 
-    // if encoded as SoP becomes:
-    // 
-    // SHIT I JUST REALISED THIS NEEDS TO BE OPTIMIZED AT LOWER LEVEL
-    const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
-    if (!typeAndExpr)
-        return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
-    const namedDestructableType = getNamedDestructableType(finalVarType);
-    if (!namedDestructableType
-        || !namedDestructableType.isConcrete())
-        return ctx.error(DiagnosticCode.Invaild_destructuring, decl.range);
-    if (isTirOptType(namedDestructableType)) {
-        const optConstrName = decl.name.text;
-        if (!(optConstrName === "Some"
-            || optConstrName === "None"))
-            return ctx.error(DiagnosticCode.Construcotr_0_is_not_part_of_the_definiton_of_1, decl.name.range, decl.name.text, namedDestructableType.toString());
-        const deconstructedFields = _getDeconstructedFields(ctx, decl, new TirStructConstr(optConstrName, optConstrName === "Some" ? [
-            new TirStructField("value", namedDestructableType.typeArg)
-        ] : []));
-        if (!deconstructedFields)
-            return undefined;
-        const [fieds, rest] = deconstructedFields;
-        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
-    }
-    if (isTirStructType(namedDestructableType)) {
-        const finalConstructorDef = namedDestructableType.constructors.find(ctor => ctor.name === decl.name.text);
-        if (!finalConstructorDef)
-            return ctx.error(DiagnosticCode.Construcotr_0_is_not_part_of_the_definiton_of_1, decl.name.range, decl.name.text, namedDestructableType.toString());
-        const deconstructedFields = _getDeconstructedFields(ctx, decl, finalConstructorDef);
-        if (!deconstructedFields)
-            return undefined;
-        const [fieds, rest] = deconstructedFields;
-        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
-    }
-}
-export function _compileSingleDeconstructVarDecl(ctx, decl, typeHint) {
-    const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
-    if (!typeAndExpr)
-        return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
-    const finalStructType = getStructType(finalVarType);
-    if (!finalStructType)
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.range, finalVarType.toString(), "Struct");
-    if (finalStructType.constructors.length !== 1)
-        return ctx.error(DiagnosticCode.Deconstructing_0_requires_the_name_of_the_constructor, decl.range, finalVarType.toString());
-    const deconstructedFields = _getDeconstructedFields(ctx, decl, finalStructType.constructors[0]);
-    if (!deconstructedFields)
-        return undefined;
-    const [fieds, rest] = deconstructedFields;
-    return new TirSingleDeconstructVarDecl(fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
-}
-export function _compileArrayLikeDeconstr(ctx, decl, typeHint) {
-    const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
-    if (!typeAndExpr)
-        return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
-    const elemsType = getListTypeArg(finalVarType);
-    if (!elemsType)
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.range, finalVarType.toString(), "List");
-    const elements = [];
-    for (const declElem of decl.elements) {
-        const compiled = _compileVarDecl(ctx, declElem, elemsType);
-        if (!compiled)
-            return undefined;
-        elements.push(compiled);
-    }
-    let rest = undefined;
-    if (decl.rest) {
-        rest = decl.rest.text;
-        const success = ctx.scope.defineValue({
-            name: rest,
-            type: finalVarType,
-            isConstant: decl.isConst()
-        });
-        if (!success)
-            return ctx.error(DiagnosticCode.Duplicate_identifier_0, decl.rest.range, decl.rest.text);
-    }
-    return new TirArrayLikeDeconstr(elements, rest, finalVarType, initExpr, decl.isConst(), decl.range);
-}
-export function _getDeconstructedFields(ctx, astDeconstruct, ctorDef) {
-    const tirFields = new Map();
-    const ctorDefFieldNames = ctorDef.fields.map(f => f.name);
-    const ctorNamesAlreadySpecified = [];
-    for (const [fieldIdentifier, varDecl] of astDeconstruct.fields) {
-        const fieldName = fieldIdentifier.text;
-        if (!ctorDefFieldNames.includes(fieldName))
-            return ctx.error(DiagnosticCode.Field_0_is_not_part_of_the_1_constructor_for_2_struct, fieldIdentifier.range, fieldName, ctorDef.name);
-        if (ctorNamesAlreadySpecified.includes(fieldName))
-            return ctx.error(DiagnosticCode.Duplicate_identifier_0, fieldIdentifier.range, fieldName);
-        ctorNamesAlreadySpecified.push(fieldName);
-        // adds to scope "simple" var decls
-        const tirVarDecl = _compileVarDecl(ctx, varDecl, ctorDef.fields.find(f => f.name === fieldName).type);
-        if (!tirVarDecl)
-            return undefined;
-        tirFields.set(fieldName, tirVarDecl);
-    }
-    if (astDeconstruct.rest && ctorDefFieldNames.length === ctorNamesAlreadySpecified.length)
-        return ctx.error(DiagnosticCode.Invalid_rest_parameter_there_are_no_more_fields, astDeconstruct.rest.range);
-    let rest = astDeconstruct.rest ? astDeconstruct.rest.text : undefined;
-    return [tirFields, rest];
-}
-export function _getVarDeclTypeAndExpr(ctx, decl, deconstructTypeHint) {
-    const declarationType = decl.type ? _compileSopEncodedConcreteType(ctx, decl.type) : undefined;
-    // const typeHint = (
-    //     declarationType ??
-    //     undefined
-    //     // _tryInferVarTypeByUsage(
-    //     //     decl.name.text,
-    //     //     sameLevelStmts,
-    //     //     stmtIdx
-    //     // )
-    // );
-    const typeHint = deconstructTypeHint ?? declarationType;
-    // even in deconstructions
-    // we allow for `as` type assertions
-    // and we store the type to be converted to in the var decl type
-    // here we check that the type assertion is valid
-    if (declarationType && deconstructTypeHint) {
-        // TODO: is data really a special case? or should we check for casts in general?
-        // special case for deconstructed data
-        // we need to check for casts
-        if (deconstructTypeHint instanceof TirDataT) {
-            if (!canCastToData(declarationType))
-                return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.type.range, declarationType.toString(), typeHint.toString());
-        }
-        else if (!canAssignTo(declarationType, typeHint))
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.type.range, declarationType.toString(), typeHint.toString());
-    }
-    let initExpr = undefined;
-    if (decl.initExpr) {
-        initExpr = _compileExpr(ctx, decl.initExpr, typeHint);
-        if (!initExpr)
-            return undefined;
-        if (typeHint && !canAssignTo(initExpr.type, typeHint))
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.initExpr.range, initExpr.type.toString(), typeHint.toString());
-    }
-    const finalVarType = typeHint ?? initExpr?.type;
-    if (!finalVarType)
-        return ctx.error(DiagnosticCode.Cannot_infer_variable_type_Try_to_make_the_type_explicit, decl.range);
-    return [finalVarType, initExpr];
-}

package/dist/compiler/AstCompiler/internal/statements/_compileWhileStmt.d.ts

@@ -1,4 +0,0 @@
-import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
-import { TirWhileStmt } from "../../../tir/statements/TirWhileStmt.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileWhileStmt(ctx: AstCompilationCtx, stmt: WhileStmt): [TirWhileStmt] | undefined;

package/dist/compiler/AstCompiler/internal/statements/_compileWhileStmt.js

@@ -1,19 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirWhileStmt } from "../../../tir/statements/TirWhileStmt.js";
-import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
-import { bool_t } from "../../../tir/program/stdScope/stdScope.js";
-import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
-import { _compileExpr } from "../exprs/_compileExpr.js";
-import { _compileStatement } from "./_compileStatement.js";
-export function _compileWhileStmt(ctx, stmt) {
-    const tirCond = _compileExpr(ctx, stmt.condition, bool_t);
-    if (!tirCond)
-        return undefined;
-    if (!canAssignTo(tirCond.type, bool_t)
-        && !canAssignToOptional(tirCond.type))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.condition.range, tirCond.type.toString(), bool_t.toString());
-    const tirBody = wrapManyStatements(_compileStatement(ctx.newLoopChildScope(), stmt.body), stmt.body.range);
-    if (!tirBody)
-        return undefined;
-    return [new TirWhileStmt(tirCond, tirBody, stmt.range)];
-}

package/dist/compiler/AstCompiler/internal/types/_compileDataEncodedConcreteType.d.ts

@@ -1,4 +0,0 @@
-import { AstTypeExpr } from "../../../../ast/nodes/types/AstTypeExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileDataEncodedConcreteType(ctx: AstCompilationCtx, typeExpr: AstTypeExpr, optionalsAsSop?: boolean): TirType | undefined;

package/dist/compiler/AstCompiler/internal/types/_compileDataEncodedConcreteType.js

@@ -1,61 +0,0 @@
-import { AstNamedTypeExpr } from "../../../../ast/nodes/types/AstNamedTypeExpr.js";
-import { AstVoidType, AstBooleanType, AstIntType, AstBytesType, AstNativeOptionalType, AstListType, AstLinearMapType, AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirLinearMapT } from "../../../tir/types/TirNativeType/native/linearMap.js";
-import { TirListT } from "../../../tir/types/TirNativeType/native/list.js";
-import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
-export function _compileDataEncodedConcreteType(ctx, typeExpr, optionalsAsSop = false) {
-    if (typeExpr instanceof AstVoidType)
-        return ctx.program.stdTypes.void;
-    if (typeExpr instanceof AstBooleanType)
-        return ctx.program.stdTypes.bool;
-    if (typeExpr instanceof AstIntType)
-        return ctx.program.stdTypes.int;
-    if (typeExpr instanceof AstBytesType)
-        return ctx.program.stdTypes.bytes;
-    if (typeExpr instanceof AstNativeOptionalType) {
-        const compiledArg = _compileDataEncodedConcreteType(ctx, typeExpr.typeArg);
-        if (!(compiledArg
-            // && compiledArg.isConcrete()
-            && compiledArg.hasDataEncoding()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(optionalsAsSop ? TirSopOptT.toTirTypeKey() : TirDataOptT.toTirTypeKey(), [compiledArg]);
-    }
-    if (typeExpr instanceof AstListType) {
-        const compiledArg = _compileDataEncodedConcreteType(ctx, typeExpr.typeArg);
-        if (!(compiledArg
-            // && compiledArg.isConcrete()
-            && compiledArg.hasDataEncoding()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(TirListT.toTirTypeKey(), [compiledArg]);
-    }
-    if (typeExpr instanceof AstLinearMapType) {
-        const kArg = _compileDataEncodedConcreteType(ctx, typeExpr.keyTypeArg);
-        const vArg = _compileDataEncodedConcreteType(ctx, typeExpr.valTypeArg);
-        if (!(kArg
-            && vArg
-            // && kArg.isConcrete()
-            // && vArg.isConcrete()
-            && kArg.hasDataEncoding()
-            && vArg.hasDataEncoding()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [kArg, vArg]);
-    }
-    if (typeExpr instanceof AstFuncType)
-        return undefined; // no data encoding for function types
-    if (typeExpr instanceof AstNamedTypeExpr) // struct, aliases and respective params
-     {
-        const possibleTirNames = ctx.scope.resolveType(typeExpr.name.text);
-        if (!possibleTirNames)
-            return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
-        if (possibleTirNames.isGeneric)
-            throw new Error("not implemented: _compileDataEncodedConcreteType for generic types");
-        if (typeof possibleTirNames.dataTirName !== "string")
-            return undefined;
-        return ctx.program.types.get(possibleTirNames.dataTirName);
-    }
-    const tsEnsureExsautstiveCheck = typeExpr;
-    console.error(typeExpr);
-    throw new Error("unreachable::AstCompiler::_compileDataEncodedConcreteType");
-}

package/dist/compiler/AstCompiler/internal/types/_compileSopEncodedConcreteType.d.ts

@@ -1,4 +0,0 @@
-import { AstTypeExpr } from "../../../../ast/nodes/types/AstTypeExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileSopEncodedConcreteType(ctx: AstCompilationCtx, typeExpr: AstTypeExpr): TirType | undefined;

package/dist/compiler/AstCompiler/internal/types/_compileSopEncodedConcreteType.js

@@ -1,59 +0,0 @@
-import { AstNamedTypeExpr } from "../../../../ast/nodes/types/AstNamedTypeExpr.js";
-import { AstVoidType, AstBooleanType, AstIntType, AstBytesType, AstNativeOptionalType, AstListType, AstLinearMapType, AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirLinearMapT } from "../../../tir/types/TirNativeType/native/linearMap.js";
-import { TirListT } from "../../../tir/types/TirNativeType/native/list.js";
-import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
-import { _compileDataEncodedConcreteType } from "./_compileDataEncodedConcreteType.js";
-export function _compileSopEncodedConcreteType(ctx, typeExpr) {
-    if (typeExpr instanceof AstVoidType)
-        return ctx.program.stdTypes.void;
-    if (typeExpr instanceof AstBooleanType)
-        return ctx.program.stdTypes.bool;
-    if (typeExpr instanceof AstIntType)
-        return ctx.program.stdTypes.int;
-    if (typeExpr instanceof AstBytesType)
-        return ctx.program.stdTypes.bytes;
-    if (typeExpr instanceof AstNativeOptionalType) {
-        const compiledArg = _compileSopEncodedConcreteType(ctx, typeExpr.typeArg);
-        if (!(compiledArg
-            && compiledArg.isConcrete()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(TirSopOptT.toTirTypeKey(), [compiledArg]);
-    }
-    if (typeExpr instanceof AstListType) {
-        // native list only supports low leve uplc types (no constrs, no functions etc.)
-        const compiledArg = _compileDataEncodedConcreteType(ctx, typeExpr.typeArg);
-        if (!(compiledArg
-            && compiledArg.isConcrete()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(TirListT.toTirTypeKey(), [compiledArg]);
-    }
-    if (typeExpr instanceof AstLinearMapType) {
-        // native linearMap only supports low leve uplc types (no constrs, no functions etc.)
-        const kArg = _compileDataEncodedConcreteType(ctx, typeExpr.keyTypeArg);
-        const vArg = _compileDataEncodedConcreteType(ctx, typeExpr.valTypeArg);
-        if (!(kArg
-            && vArg
-            && kArg.isConcrete()
-            && vArg.isConcrete()))
-            return undefined;
-        return ctx.program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [kArg, vArg]);
-    }
-    if (typeExpr instanceof AstFuncType)
-        return undefined; // no data encoding for function types
-    if (typeExpr instanceof AstNamedTypeExpr) // struct, aliases and respective params
-     {
-        const possibleTirNames = ctx.scope.resolveType(typeExpr.name.text);
-        if (!possibleTirNames)
-            return ctx.error(DiagnosticCode._0_is_not_defined, typeExpr.name.range, typeExpr.name.text);
-        if (possibleTirNames.isGeneric)
-            throw new Error("not implemented: _compileSopEncodedConcreteType for generic types");
-        if (typeof possibleTirNames.dataTirName !== "string")
-            return undefined;
-        return ctx.program.types.get(possibleTirNames.dataTirName);
-    }
-    const tsEnsureExsautstiveCheck = typeExpr;
-    console.error(typeExpr);
-    throw new Error("unreachable::AstCompiler::_compileSopEncodedConcreteType");
-}

package/dist/compiler/AstCompiler/scope/AstScope.d.ts

@@ -1,102 +0,0 @@
-import { AstFuncType } from "../../../ast/nodes/types/AstNativeTypeExpr.js";
-import { TypedProgram } from "../../tir/program/TypedProgram.js";
-import { TirType } from "../../tir/types/TirType.js";
-export interface ScopeInfos {
-    isFunctionDeclScope: boolean;
-    isMethodScope: boolean;
-}
-export type AstFuncName = string;
-export type TirFuncName = string;
-export interface IAvaiableConstructor {
-    declaredName: string;
-    originalName: string;
-    structType: TirType;
-}
-export interface JsonScope {
-    variables: {
-        [x: string]: string;
-    };
-    /** tir name -> unambigous function type */
-    functions: {
-        [x: string]: string;
-    };
-    /** tir names of types */
-    types: string[];
-    child: JsonScope | undefined;
-}
-export interface ResolveValueResult {
-    variableInfos: IVariableInfos;
-    isDefinedOutsideFuncScope: boolean;
-}
-export interface IVariableInfos {
-    name: string;
-    type: TirType;
-    isConstant: boolean;
-}
-export interface PossibleTirTypes {
-    sopTirName: string;
-    dataTirName: string | undefined;
-    allTirNames: Set<string>;
-    methodsNames: Map<AstFuncName, TirFuncName>;
-    isGeneric: boolean;
-}
-export declare class AstScope {
-    readonly program: TypedProgram;
-    readonly parent: AstScope | undefined;
-    /**
-     * ast name -> Set<tir name>
-     *
-     * a single ast name can correspond to multiple tir names
-     * eg. a struct can have either SoP or data encoding
-     * so those are 2 different tir names
-     **/
-    readonly types: Map<string, PossibleTirTypes>;
-    /**
-     * interfaces are not a thing in tir
-     */
-    readonly interfaces: Map<string, Map<string, AstFuncType>>;
-    /**
-     * ast name -> tir name
-     *
-     * the process is:
-     * (->) 1 to 1
-     * (=>) 1 to many
-     *
-     * ast name
-     * -> tir name (in program)
-     * => signatures (different encodings) (ast node saved here)
-     * => func values (registered in the program)
-     *
-     * user overloads NOT SUPPORTED
-     **/
-    readonly functions: Map<AstFuncName, TirFuncName>;
-    /**
-     * ast name -> variable infos (name, type, isConstant)
-     */
-    readonly variables: Map<string, IVariableInfos>;
-    readonly aviableConstructors: Map<string, IAvaiableConstructor>;
-    private _isReadonly;
-    readonly infos: ScopeInfos;
-    constructor(parent: AstScope | undefined, program: TypedProgram, infos: Partial<ScopeInfos>);
-    defineValue(valueInfos: IVariableInfos): boolean;
-    resolveValue(name: string): ResolveValueResult | undefined;
-    defineUnambigousType(name: string, tirTypeKey: string, allowsDataEncoding: boolean, methodsNames: Map<AstFuncName, TirFuncName>): boolean;
-    defineType(name: string, possibleTirTypes: PossibleTirTypes): boolean;
-    resolveLocalType(name: string): PossibleTirTypes | undefined;
-    resolveType(name: string): PossibleTirTypes | undefined;
-    toJSON(): JsonScope;
-    toJson(child?: JsonScope | undefined): JsonScope;
-    readonly(): void;
-    newChildScope(infos: Partial<ScopeInfos>): AstScope;
-    /**
-     * @returns `true` if the constructor was defined successfully
-     *
-     * @returns `false`
-     *      if it was already defined in this scope (shadows any similar definitions in parent scopes),
-     *      or if the type symbol is not assignable to a struct,
-     *      or if it is a struct but is not concrete
-     */
-    defineAviableConstructorIfValid(declaredName: string, originalName: string, structOrAliasType: TirType): boolean;
-    inferStructTypeFromConstructorName(name: string): IAvaiableConstructor | undefined;
-    clone(): AstScope;
-}

package/dist/compiler/AstCompiler/scope/AstScope.js

@@ -1,195 +0,0 @@
-import { getStructType } from "../../tir/types/utils/canAssignTo.js";
-const defauldScopeInfos = Object.freeze({
-    isFunctionDeclScope: false,
-    isMethodScope: false
-});
-function normalizeScopeInfos(infos) {
-    const result = {
-        ...defauldScopeInfos,
-        ...infos
-    };
-    result.isFunctionDeclScope = !!result.isFunctionDeclScope;
-    result.isMethodScope = !!result.isMethodScope;
-    // method scope == true
-    // implies function decl scope also == true
-    result.isFunctionDeclScope = result.isFunctionDeclScope || result.isMethodScope;
-    return result;
-}
-const invalidSymbolNames = new Set([
-    "this"
-]);
-export class AstScope {
-    program;
-    parent;
-    /**
-     * ast name -> Set<tir name>
-     *
-     * a single ast name can correspond to multiple tir names
-     * eg. a struct can have either SoP or data encoding
-     * so those are 2 different tir names
-     **/
-    types = new Map();
-    /**
-     * interfaces are not a thing in tir
-     */
-    interfaces = new Map();
-    /**
-     * ast name -> tir name
-     *
-     * the process is:
-     * (->) 1 to 1
-     * (=>) 1 to many
-     *
-     * ast name
-     * -> tir name (in program)
-     * => signatures (different encodings) (ast node saved here)
-     * => func values (registered in the program)
-     *
-     * user overloads NOT SUPPORTED
-     **/
-    functions = new Map();
-    /**
-     * ast name -> variable infos (name, type, isConstant)
-     */
-    variables = new Map();
-    aviableConstructors = new Map();
-    _isReadonly = false;
-    infos;
-    constructor(parent, program, infos) {
-        this.program = program;
-        this.infos = normalizeScopeInfos(infos);
-        this._isReadonly = false;
-        this.parent = parent;
-    }
-    defineValue(valueInfos) {
-        if (this._isReadonly)
-            return false;
-        if (invalidSymbolNames.has(valueInfos.name)
-            && !(valueInfos.name === "this" && this.infos.isMethodScope))
-            return false;
-        if (this.variables.has(valueInfos.name))
-            return false; // already defined
-        this.variables.set(valueInfos.name, valueInfos);
-        return true;
-    }
-    resolveValue(name) {
-        const localValue = this.variables.get(name);
-        if (localValue)
-            return {
-                variableInfos: localValue,
-                isDefinedOutsideFuncScope: false
-            };
-        if (this.parent) {
-            const parentValue = this.parent.resolveValue(name);
-            if (!parentValue)
-                return undefined;
-            return {
-                variableInfos: parentValue.variableInfos,
-                isDefinedOutsideFuncScope: parentValue.isDefinedOutsideFuncScope || this.infos.isFunctionDeclScope
-            };
-        }
-        return undefined;
-    }
-    defineUnambigousType(name, tirTypeKey, allowsDataEncoding, methodsNames) {
-        if (this._isReadonly)
-            return false;
-        if (invalidSymbolNames.has(name))
-            return false;
-        if (this.types.has(name))
-            return false; // already defined
-        this.types.set(name, {
-            sopTirName: tirTypeKey,
-            dataTirName: allowsDataEncoding ? undefined : tirTypeKey,
-            allTirNames: new Set([tirTypeKey]),
-            methodsNames,
-            isGeneric: false
-        });
-        return true;
-    }
-    defineType(name, possibleTirTypes) {
-        if (this._isReadonly)
-            return false;
-        if (invalidSymbolNames.has(name))
-            return false;
-        if (this.types.has(name))
-            return false; // already defined
-        this.types.set(name, possibleTirTypes);
-        return true;
-    }
-    resolveLocalType(name) {
-        return this.types.get(name);
-    }
-    resolveType(name) {
-        return (this.resolveLocalType(name)
-            ?? this.parent?.resolveType(name));
-    }
-    toJSON() { return this.toJson(); }
-    toJson(child = undefined) {
-        const localValues = {};
-        for (const [key, value] of this.variables)
-            localValues[key] = value.type.toConcreteTirTypeName();
-        const localFunctions = {};
-        for (const [_key, value] of this.functions)
-            for (const [tirName, tirType] of value)
-                localFunctions[tirName] = tirType.toString();
-        const localTypes = [];
-        for (const [astTypeName, _possibleTirTypeNames] of this.types)
-            localTypes.push(astTypeName);
-        const thisResult = {
-            variables: localValues,
-            functions: localFunctions,
-            types: localTypes,
-            child
-        };
-        if (this.parent)
-            return this.parent.toJson(thisResult);
-        else
-            return thisResult;
-    }
-    readonly() { this._isReadonly = true; }
-    newChildScope(infos) {
-        return new AstScope(this, this.program, infos);
-    }
-    /**
-     * @returns `true` if the constructor was defined successfully
-     *
-     * @returns `false`
-     *      if it was already defined in this scope (shadows any similar definitions in parent scopes),
-     *      or if the type symbol is not assignable to a struct,
-     *      or if it is a struct but is not concrete
-     */
-    defineAviableConstructorIfValid(declaredName, originalName, structOrAliasType) {
-        const structType = getStructType(structOrAliasType);
-        if (!structType || !structType.isConcrete() || !structOrAliasType.isConcrete())
-            return false; // not a concrete struct
-        if (this.aviableConstructors.has(declaredName))
-            return false; // already defined
-        this.aviableConstructors.set(declaredName, {
-            declaredName,
-            originalName,
-            structType: structOrAliasType
-        });
-        return true;
-    }
-    inferStructTypeFromConstructorName(name) {
-        return (this.aviableConstructors.get(name)
-            ?? this.parent?.inferStructTypeFromConstructorName(name));
-    }
-    clone() {
-        const cloned = new AstScope(this.parent, this.program, this.infos);
-        for (const [key, value] of this.variables)
-            cloned.variables.set(key, { ...value });
-        for (const [key, value] of this.functions)
-            cloned.functions.set(key, value);
-        for (const [key, value] of this.types)
-            cloned.types.set(key, value);
-        for (const [key, value] of this.aviableConstructors)
-            cloned.aviableConstructors.set(key, {
-                ...value,
-                structType: value.structType.clone(),
-            });
-        for (const [name, methods] of this.interfaces)
-            cloned.interfaces.set(name, new Map(methods));
-        return cloned;
-    }
-}