@harmoniclabs/pebble 0.1.0-dev0

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

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

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

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

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

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

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

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

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

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