@harmoniclabs/pebble 0.1.0-dev0 → 0.1.0-dev2

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

@@ -1,47 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
-import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
-import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
-import { _compileVarDecl } from "../statements/_compileVarStmt.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileCaseExpr(ctx, expr, typeHint) {
-    const matchExpr = _compileExpr(ctx, expr.matchExpr, typeHint);
-    if (!matchExpr)
-        return undefined;
-    const cases = expr.cases.map(branch => _compileCaseExprMatcher(ctx, branch, matchExpr.type, typeHint)); // we early return in case of undefined so this is safe
-    if (cases.some(c => !c))
-        return undefined;
-    const returnType = cases[0]?.body.type ?? typeHint;
-    if (!returnType)
-        return ctx.error(DiagnosticCode.Cannot_infer_return_type_Try_to_make_the_type_explicit, expr.range);
-    if (!expr.wildcardCase)
-        return new TirCaseExpr(matchExpr, cases, undefined, returnType, expr.range);
-    const wildcardCase = _compileCaseWildcardMatcher(ctx, expr.wildcardCase, returnType);
-    if (!wildcardCase)
-        return undefined;
-    return new TirCaseExpr(matchExpr, cases, wildcardCase, returnType, expr.range);
-}
-export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHint) {
-    const pattern = _compileVarDecl(ctx, matcher.pattern, patternType);
-    if (!pattern)
-        return undefined;
-    if (pattern instanceof TirSimpleVarDecl)
-        return ctx.error(DiagnosticCode._case_expression_must_decontructed_the_inspected_value, matcher.pattern.range);
-    if (!canAssignTo(pattern.type, patternType))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, matcher.pattern.range, pattern.type.toString(), patternType.toString());
-    const body = _compileExpr(ctx, matcher.body, returnTypeHint);
-    if (!body)
-        return undefined;
-    if (returnTypeHint && !canAssignTo(body.type, returnTypeHint))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, matcher.body.range, body.type.toString(), returnTypeHint.toString());
-    if (!(pattern instanceof TirNamedDeconstructVarDecl))
-        return ctx.error(DiagnosticCode._case_expression_must_decontructed_the_inspected_value, matcher.pattern.range);
-    return new TirCaseMatcher(pattern, body, matcher.range);
-}
-function _compileCaseWildcardMatcher(ctx, wildcardCase, returnTypeHint) {
-    const bodyExpr = _compileExpr(ctx, wildcardCase.body, returnTypeHint);
-    if (!bodyExpr)
-        return undefined;
-    return new TirWildcardCaseMatcher(bodyExpr, wildcardCase.range);
-}

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

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

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

@@ -1,23 +0,0 @@
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirElemAccessExpr } from "../../../tir/expressions/TirElemAccessExpr.js";
-import { TirListT } from "../../../tir/types/TirNativeType/native/list.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
-import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileElemAccessExpr(ctx, expr, typeHint) {
-    const int_t = ctx.program.stdTypes.int;
-    const litsTypeHint = typeHint ? new TirListT(typeHint) : undefined;
-    const arrLikeExpr = _compileExpr(ctx, expr.arrLikeExpr, litsTypeHint);
-    if (!arrLikeExpr)
-        return undefined;
-    const arrLikeType = arrLikeExpr.type;
-    const elemsType = getListTypeArg(arrLikeType);
-    if (!elemsType)
-        return ctx.error(DiagnosticCode.This_expression_cannot_be_indexed, expr.arrLikeExpr.range);
-    const indexExpr = _compileExpr(ctx, expr.indexExpr, int_t);
-    if (!indexExpr)
-        return undefined;
-    if (!canAssignTo(indexExpr.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.indexExpr.range, indexExpr.type.toString(), int_t.toString());
-    return new TirElemAccessExpr(arrLikeExpr, indexExpr, elemsType, expr.range);
-}

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

@@ -1,22 +0,0 @@
-import { PebbleExpr } from "../../../../ast/nodes/expr/PebbleExpr.js";
-import { TirExpr } from "../../../tir/expressions/TirExpr.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-/**
- * here we just translate to TIR
- *
- * WE DO NOT OPTIMIZE
- *
- * optimizaitons are part of the TIR -> TermIR compilation
-**/
-export declare function _compileExpr(ctx: AstCompilationCtx, expr: PebbleExpr, 
-/**
- * this is just a type **hint**
- * it is only used as last resource to
- * disambiguate the type of an expression.
- *
- * it is **NOT guaranteed** that the returned expression will be assignable to this type
- *
- * if that is the case, it needs to be checked OUTSIDE this function
-**/
-typeHint: TirType | undefined): TirExpr | undefined;

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

@@ -1,77 +0,0 @@
-import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
-import { isBinaryExpr } from "../../../../ast/nodes/expr/binary/BinaryExpr.js";
-import { CaseExpr } from "../../../../ast/nodes/expr/CaseExpr.js";
-import { ElemAccessExpr } from "../../../../ast/nodes/expr/ElemAccessExpr.js";
-import { CallExpr } from "../../../../ast/nodes/expr/functions/CallExpr.js";
-import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
-import { isLitteralExpr } from "../../../../ast/nodes/expr/litteral/LitteralExpr.js";
-import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
-import { isPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
-import { TernaryExpr } from "../../../../ast/nodes/expr/TernaryExpr.js";
-import { TypeConversionExpr } from "../../../../ast/nodes/expr/TypeConversionExpr.js";
-import { NonNullExpr } from "../../../../ast/nodes/expr/unary/NonNullExpr.js";
-import { isUnaryPrefixExpr } from "../../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
-import { _compileBinaryExpr } from "./_compileBinaryExpr.js";
-import { _compileCallExpr } from "./_compileCallExpr.js";
-import { _compileCaseExpr } from "./_compileCaseExpr.js";
-import { _compileElemAccessExpr } from "./_compileElemAccessExpr.js";
-import { _compileFuncExpr } from "./_compileFuncExpr.js";
-import { _compileLitteralExpr } from "./_compileLitteralExpr.js";
-import { _compileNonNullExpr } from "./_compileNonNullExpr.js";
-import { _compilePropAccessExpr } from "./_compilePropAccessExpr.js";
-import { _compileTernaryExpr } from "./_compileTernaryExpr.js";
-import { _compileTypeConversionExpr } from "./_compileTypeConversionExpr.js";
-import { _compileUnaryPrefixExpr } from "./_compileUnaryPrefixExpr.js";
-import { _compileVarAccessExpr } from "./_compileVarAccessExpr.js";
-/**
- * here we just translate to TIR
- *
- * WE DO NOT OPTIMIZE
- *
- * optimizaitons are part of the TIR -> TermIR compilation
-**/
-export function _compileExpr(ctx, expr, 
-/**
- * this is just a type **hint**
- * it is only used as last resource to
- * disambiguate the type of an expression.
- *
- * it is **NOT guaranteed** that the returned expression will be assignable to this type
- *
- * if that is the case, it needs to be checked OUTSIDE this function
-**/
-typeHint) {
-    if (expr instanceof Identifier)
-        return _compileVarAccessExpr(ctx, expr, typeHint);
-    if (isUnaryPrefixExpr(expr))
-        return _compileUnaryPrefixExpr(ctx, expr, typeHint);
-    if (expr instanceof NonNullExpr)
-        return _compileNonNullExpr(ctx, expr, typeHint);
-    if (expr instanceof ParentesizedExpr)
-        return _compileExpr(ctx, expr.expr, typeHint);
-    if (expr instanceof FuncExpr)
-        return _compileFuncExpr(ctx, expr, typeHint);
-    if (expr instanceof CallExpr)
-        return _compileCallExpr(ctx, expr, typeHint);
-    if (expr instanceof CaseExpr)
-        return _compileCaseExpr(ctx, expr, typeHint);
-    if (expr instanceof TypeConversionExpr)
-        return _compileTypeConversionExpr(ctx, expr, typeHint);
-    if (expr instanceof NonNullExpr)
-        return _compileNonNullExpr(ctx, expr, typeHint);
-    // if( expr instanceof IsExpr ) return _compileIsExpr( ctx, expr, typeHint );
-    if (expr instanceof ElemAccessExpr)
-        return _compileElemAccessExpr(ctx, expr, typeHint);
-    if (expr instanceof TernaryExpr)
-        return _compileTernaryExpr(ctx, expr, typeHint);
-    if (isPropAccessExpr(expr))
-        return _compilePropAccessExpr(ctx, expr, typeHint);
-    if (isBinaryExpr(expr))
-        return _compileBinaryExpr(ctx, expr, typeHint);
-    //*/
-    if (isLitteralExpr(expr))
-        return _compileLitteralExpr(ctx, expr, typeHint);
-    const tsEnsureExsautstiveCheck = expr;
-    console.error(expr);
-    throw new Error("unreachable::AstCompiler::_compileExpr");
-}

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

@@ -1,26 +0,0 @@
-import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
-import { AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
-import { TirFuncExpr } from "../../../tir/expressions/TirFuncExpr.js";
-import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileFuncExpr(ctx: AstCompilationCtx, expr: FuncExpr, expectedFuncType: TirType | undefined, isMethod?: boolean): TirFuncExpr | undefined;
-/**
- * [NOTE: abmigous param encoding defaults to data]
- *
- * when we can encode a struct (or alias of struct) both as sop or data,
- * we default to data encoding
- *
- * this is because, not know much about what was the original encoding,
- * converting sop to data is usually cheaper
- * than data to sop, where we would need to decode all fields,
- * even if we don't use them.
- *
- * encoding is cheaper than decoding and can be done outside the function, before the call
- *
- * Optionals are sop, but the value is follows the rules above.
- *
- * TODO: in the future we should implement a "fully extracted form" (FEF)
- * so that we don't care about data or sop. (only exception is if the function calls `equalsData` builtin)
-    **/
-export declare function getDataFuncSignature(ctx: AstCompilationCtx, signature: AstFuncType): TirFuncT | undefined;

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

@@ -1,163 +0,0 @@
-import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
-import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
-import { AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { getUniqueInternalName } from "../../../internalVar.js";
-import { TirFuncExpr } from "../../../tir/expressions/TirFuncExpr.js";
-import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
-import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
-import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
-import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
-import { _compileBlockStmt } from "../statements/_compileBlockStmt.js";
-import { _compileVarDecl } from "../statements/_compileVarStmt.js";
-import { _compileDataEncodedConcreteType } from "../types/_compileDataEncodedConcreteType.js";
-import { _compileSopEncodedConcreteType } from "../types/_compileSopEncodedConcreteType.js";
-/*
-- add "self" as first parameter
-- replace `node( arg )` as `self( Node{ arg } )`
-
-```
-function isOdd( n: int ): boolean
-{
-    return n == 1 || !isEven( n - 1 );
-}
-
-function isEven( n: int ): boolean
-{
-    return n == 0 || !isOdd( n - 1 );
-}
-```
-
-becomes
-
-```
-runtime struct _Choice {
-    IsOdd{ n: int },
-    IsEven{ n: int },
-}
-
-function _isOdd( mutual_chooser: any, n: int ): boolean
-{
-    return n == 1 || !mutual_chooser( IsEven{ n: n - 1 } );
-}
-
-function _isEven( mutual_chooser: any, n: int ): boolean
-{
-    return n == 0 || !mutual_chooser( IsOdd{ n: n - 1 } );
-}
-
-function _isOdd_isEven( choice: _Choice ): boolean
-{
-    return case choice
-        is IsOdd{ _ } => _isOdd( _isOdd_isEven, ...choice ),
-        is IsEven{ _ } => _isEven( _isOdd_isEven, ...choice ),
-        ;
-}
-
-// partial application
-const isOdd = _isOdd( _isOdd_isEven );
-const isEven = _isEven( _isOdd_isEven );
-```
-*/
-export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false) {
-    if (expectedFuncType) {
-        expectedFuncType = getUnaliased(expectedFuncType);
-        if (!(expectedFuncType instanceof TirFuncT))
-            return ctx.error(DiagnosticCode.While_compiling_function_expression_expected_type_was_not_a_function, expr.range);
-    }
-    else {
-        expectedFuncType = (isMethod ? undefined :
-            ctx.program.functions.get(expr.name.text)?.sig()) ?? getDataFuncSignature(ctx, expr.signature);
-        if (!(expectedFuncType instanceof TirFuncT))
-            return undefined;
-    }
-    const returnType = expectedFuncType.returnType;
-    const funcCtx = ctx.newFunctionChildScope(returnType, isMethod);
-    // if( _hasDuplicateTypeParams( ctx, expr.typeParams ) ) return undefined;
-    if (expr.typeParams.length > 0)
-        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
-    const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr);
-    if (!destructuredParamsResult)
-        return undefined;
-    const { blockInitStmts, params } = destructuredParamsResult;
-    const astBody = expr.body instanceof BlockStmt ? expr.body :
-        new BlockStmt([new ReturnStmt(expr.body, expr.body.range)], expr.body.range);
-    const compileResult = _compileBlockStmt(funcCtx, astBody);
-    if (!compileResult)
-        return undefined;
-    const body = compileResult[0];
-    body.stmts.unshift(...blockInitStmts);
-    const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
-    return funcExpr;
-}
-function _getDestructuredParamsAsVarDecls(funcCtx, expr) {
-    const blockInitStmts = [];
-    const params = [];
-    for (const astParam of expr.signature.params) {
-        const tirParam = _compileVarDecl(funcCtx, astParam, undefined);
-        if (!tirParam)
-            return undefined;
-        if (tirParam instanceof TirSimpleVarDecl) {
-            params.push(tirParam);
-            continue;
-        }
-        // else move destructuring in the body (uplc has only simple params)
-        const uniqueName = getUniqueInternalName(tirParam.type.toString().toLowerCase());
-        const isConst = tirParam.isConst;
-        // function param as simple var decl
-        const simpleParam = new TirSimpleVarDecl(uniqueName, tirParam.type, tirParam.initExpr, isConst, tirParam.range);
-        // tirParam destructures simpleParam added to the block init stmts
-        tirParam.initExpr = new TirVariableAccessExpr({
-            variableInfos: {
-                name: simpleParam.name,
-                type: simpleParam.type,
-                isConstant: true
-            },
-            isDefinedOutsideFuncScope: false,
-        }, tirParam.range);
-        params.push(simpleParam);
-        blockInitStmts.push(tirParam);
-    }
-    return { blockInitStmts, params };
-}
-/**
- * [NOTE: abmigous param encoding defaults to data]
- *
- * when we can encode a struct (or alias of struct) both as sop or data,
- * we default to data encoding
- *
- * this is because, not know much about what was the original encoding,
- * converting sop to data is usually cheaper
- * than data to sop, where we would need to decode all fields,
- * even if we don't use them.
- *
- * encoding is cheaper than decoding and can be done outside the function, before the call
- *
- * Optionals are sop, but the value is follows the rules above.
- *
- * TODO: in the future we should implement a "fully extracted form" (FEF)
- * so that we don't care about data or sop. (only exception is if the function calls `equalsData` builtin)
-    **/
-export function getDataFuncSignature(ctx, signature) {
-    const funcParams = signature.params;
-    const paramTypes = new Array(funcParams.length);
-    for (let i = 0; i < funcParams.length; i++) {
-        const param = funcParams[i];
-        if (!param.type)
-            return ctx.error(DiagnosticCode.Could_not_infer_function_signature_parameter_type_is_missing, param.range);
-        const type = _compileDataEncodedConcreteType(ctx, param.type, true);
-        if (!type)
-            return undefined;
-        paramTypes[i] = type;
-    }
-    if (!signature.returnType)
-        return ctx.error(DiagnosticCode.Could_not_infer_function_signature_return_type_is_missing, signature.range);
-    const returnType = signature.returnType instanceof AstFuncType ?
-        getDataFuncSignature(ctx, signature.returnType) :
-        _compileSopEncodedConcreteType(ctx, signature.returnType);
-    if (!returnType
-        || returnType instanceof TirTypeParam)
-        return undefined;
-    return new TirFuncT(paramTypes, returnType);
-}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,43 +0,0 @@
-export {};
-/*
-export function _compileIsExpr(
-    ctx: AstCompilationCtx,
-    expr: IsExpr,
-    _typeHint: TirType | undefined
-): TirIsExpr | undefined
-{
-    const bool_t = ctx.program.stdTypes.bool;
-    
-    const target = _compileExpr( ctx, expr.instanceExpr, undefined );
-    if( !target ) return undefined;
-
-    const structType = getStructType( target.type );
-    if( !structType ) return ctx.error(
-        DiagnosticCode.Cannot_use_is_operator_on_a_value_that_is_not_a_struct_type,
-        expr.instanceExpr.range
-    );
-
-    const targetCtorId = expr.ofType;
-    const targetCtorName = targetCtorId.text;
-
-    const structCtors = structType.constructors;
-    const targetCtor = structCtors.find( ctor => ctor.name === targetCtorName );
-    if( !targetCtor ) return ctx.error(
-        DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1,
-        expr.ofType.range, targetCtorName, structType.toString()
-    );
-
-    if( structCtors.length === 1 )
-    ctx.warning(
-        DiagnosticCode.This_check_is_redundant_Struct_0_has_only_one_possible_constructor,
-        expr.range, structType.toString()
-    );
-
-    return new TirIsExpr(
-        target,
-        expr.ofType,
-        bool_t,
-        expr.range
-    );
-}
-    //*/ 

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

@@ -1,19 +0,0 @@
-import { LitArrExpr } from "../../../../ast/nodes/expr/litteral/LitArrExpr.js";
-import { LitNamedObjExpr } from "../../../../ast/nodes/expr/litteral/LitNamedObjExpr.js";
-import { LitObjExpr } from "../../../../ast/nodes/expr/litteral/LitObjExpr.js";
-import { LitteralExpr } from "../../../../ast/nodes/expr/litteral/LitteralExpr.js";
-import { LitUndefExpr } from "../../../../ast/nodes/expr/litteral/LitUndefExpr.js";
-import { TirLitNamedObjExpr } from "../../../tir/expressions/litteral/TirLitNamedObjExpr.js";
-import { TirLitObjExpr } from "../../../tir/expressions/litteral/TirLitObjExpr.js";
-import { TirLitUndefExpr } from "../../../tir/expressions/litteral/TirLitUndefExpr.js";
-import { TirExpr } from "../../../tir/expressions/TirExpr.js";
-import { TirStructType } from "../../../tir/types/TirStructType.js";
-import { TirType } from "../../../tir/types/TirType.js";
-import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileLitteralExpr(ctx: AstCompilationCtx, expr: LitteralExpr, typeHint: TirType | undefined): TirExpr | undefined;
-export declare function _compileLitteralUndefExpr(ctx: AstCompilationCtx, expr: LitUndefExpr, typeHint: TirType | undefined): TirLitUndefExpr | undefined;
-export declare function _compileLitteralNamedObjExpr(ctx: AstCompilationCtx, expr: LitNamedObjExpr, typeHint: TirType | undefined): TirLitNamedObjExpr | undefined;
-export declare function _compileLitteralObjExpr(ctx: AstCompilationCtx, expr: LitObjExpr, typeHint: TirType | undefined): TirLitObjExpr | undefined;
-export declare function __commonCompileStructFieldValues(ctx: AstCompilationCtx, expr: LitObjExpr | LitNamedObjExpr, realType: TirType, // possibly aliased
-structType: TirStructType, constructorIndex: number): TirExpr[] | undefined;
-export declare function _compileLitteralArrayExpr(ctx: AstCompilationCtx, expr: LitArrExpr, typeHint: TirType | undefined): TirExpr | undefined;

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

@@ -1,202 +0,0 @@
-import { LitArrExpr } from "../../../../ast/nodes/expr/litteral/LitArrExpr.js";
-import { LitFalseExpr } from "../../../../ast/nodes/expr/litteral/LitFalseExpr.js";
-import { LitHexBytesExpr } from "../../../../ast/nodes/expr/litteral/LitHexBytesExpr.js";
-import { LitIntExpr } from "../../../../ast/nodes/expr/litteral/LitIntExpr.js";
-import { LitNamedObjExpr } from "../../../../ast/nodes/expr/litteral/LitNamedObjExpr.js";
-import { LitObjExpr } from "../../../../ast/nodes/expr/litteral/LitObjExpr.js";
-import { LitStrExpr } from "../../../../ast/nodes/expr/litteral/LitStrExpr.js";
-import { LitThisExpr } from "../../../../ast/nodes/expr/litteral/LitThisExpr.js";
-import { LitTrueExpr } from "../../../../ast/nodes/expr/litteral/LitTrueExpr.js";
-import { LitUndefExpr } from "../../../../ast/nodes/expr/litteral/LitUndefExpr.js";
-import { LitVoidExpr } from "../../../../ast/nodes/expr/litteral/LitVoidExpr.js";
-import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
-import { TirLitArrExpr } from "../../../tir/expressions/litteral/TirLitArrExpr.js";
-import { TirLitFalseExpr } from "../../../tir/expressions/litteral/TirLitFalseExpr.js";
-import { TirLitHexBytesExpr } from "../../../tir/expressions/litteral/TirLitHexBytesExpr.js";
-import { TirLitIntExpr } from "../../../tir/expressions/litteral/TirLitIntExpr.js";
-import { TirLitNamedObjExpr } from "../../../tir/expressions/litteral/TirLitNamedObjExpr.js";
-import { TirLitObjExpr } from "../../../tir/expressions/litteral/TirLitObjExpr.js";
-import { TirLitStrExpr } from "../../../tir/expressions/litteral/TirLitStrExpr.js";
-import { TirLitThisExpr } from "../../../tir/expressions/litteral/TirLitThisExpr.js";
-import { TirLitTrueExpr } from "../../../tir/expressions/litteral/TirLitTrueExpr.js";
-import { TirLitUndefExpr } from "../../../tir/expressions/litteral/TirLitUndefExpr.js";
-import { TirLitVoidExpr } from "../../../tir/expressions/litteral/TirLitVoidExpr.js";
-import { isTirExpr } from "../../../tir/expressions/TirExpr.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";
-import { TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
-import { isTirType } from "../../../tir/types/TirType.js";
-import { canAssignTo, isStructOrStructAlias, getStructType, canAssignToList } from "../../../tir/types/utils/canAssignTo.js";
-import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
-import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
-import { _compileExpr } from "./_compileExpr.js";
-export function _compileLitteralExpr(ctx, expr, typeHint) {
-    if (expr instanceof LitVoidExpr)
-        return new TirLitVoidExpr(expr.range);
-    if (expr instanceof LitUndefExpr)
-        return _compileLitteralUndefExpr(ctx, expr, typeHint);
-    if (expr instanceof LitTrueExpr)
-        return new TirLitTrueExpr(expr.range);
-    if (expr instanceof LitFalseExpr)
-        return new TirLitFalseExpr(expr.range);
-    if (expr instanceof LitStrExpr)
-        return new TirLitStrExpr(expr.string, expr.range);
-    if (expr instanceof LitIntExpr)
-        return new TirLitIntExpr(expr.integer, expr.range);
-    if (expr instanceof LitHexBytesExpr)
-        return new TirLitHexBytesExpr(expr.bytes, expr.range);
-    if (expr instanceof LitThisExpr) {
-        const this_tir_name = ctx.scope.resolveType("this")?.sopTirName;
-        if (!this_tir_name)
-            return ctx.error(DiagnosticCode._this_cannot_be_referenced_in_current_location, expr.range);
-        const this_t = ctx.program.types.get(this_tir_name);
-        if (!this_t)
-            return ctx.error(DiagnosticCode._this_cannot_be_referenced_in_current_location, expr.range);
-        return new TirLitThisExpr(this_t, expr.range);
-    }
-    if (expr instanceof LitArrExpr)
-        return _compileLitteralArrayExpr(ctx, expr, typeHint);
-    if (expr instanceof LitObjExpr)
-        return _compileLitteralObjExpr(ctx, expr, typeHint);
-    if (expr instanceof LitNamedObjExpr)
-        return _compileLitteralNamedObjExpr(ctx, expr, typeHint);
-    // never
-    // expr;
-    throw new Error("unreachable::AstCompiler::_compileLitteralExpr");
-}
-export function _compileLitteralUndefExpr(ctx, expr, typeHint) {
-    if (!isTirType(typeHint)) {
-        return ctx.error(DiagnosticCode.Litteral_value_undefined_must_be_explicitly_cast_to_an_Optional_type, expr.range);
-    }
-    typeHint = getUnaliased(typeHint);
-    if (!(typeHint instanceof TirSopOptT
-        || typeHint instanceof TirDataOptT)) {
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.range, "Optional<T>", typeHint.toString());
-    }
-    return new TirLitUndefExpr(typeHint, expr.range);
-}
-export function _compileLitteralNamedObjExpr(ctx, expr, typeHint) {
-    let structType = undefined;
-    if (isTirType(typeHint)) {
-        if (!isStructOrStructAlias(typeHint)) {
-            return ctx.error(DiagnosticCode.Named_object_litteral_is_not_assignable_to_0, expr.range, typeHint.toString());
-        }
-        structType = getStructType(typeHint);
-    }
-    else
-        typeHint = undefined;
-    const constructorName = expr.name.text;
-    const inferredStructType = getStructType(ctx.scope.inferStructTypeFromConstructorName(constructorName)?.structType);
-    if (!inferredStructType) {
-        return ctx.error(DiagnosticCode._0_is_not_defined, expr.name.range, constructorName);
-    }
-    if (typeHint) {
-        if (!canAssignTo(inferredStructType, typeHint)) {
-            return ctx.error(DiagnosticCode.Named_object_litteral_is_not_assignable_to_0, expr.range, typeHint.toString());
-        }
-    }
-    structType = inferredStructType;
-    if (!isTirType(typeHint))
-        typeHint = structType ?? inferredStructType;
-    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, structType?.constructors.findIndex(c => c.name === constructorName) ?? -1);
-    if (!Array.isArray(fieldValues))
-        return undefined;
-    typeHint = getUnaliased(typeHint);
-    // TirDataStructType | TirSoPStructType
-    if (!(typeHint instanceof TirDataStructType
-        || typeHint instanceof TirSoPStructType)) {
-        return ctx.error(DiagnosticCode.Named_object_litteral_is_not_assignable_to_0, expr.range, typeHint.toString());
-    }
-    return new TirLitNamedObjExpr(expr.name, expr.fieldNames, fieldValues, typeHint, expr.range);
-}
-export function _compileLitteralObjExpr(ctx, expr, typeHint) {
-    if (!isTirType(typeHint)) {
-        return ctx.error(DiagnosticCode.Unnamed_object_litteral_must_be_explicitly_cast_to_a_type, expr.range);
-    }
-    if (!isStructOrStructAlias(typeHint)) {
-        return ctx.error(DiagnosticCode.Unnamed_object_litteral_is_not_assignable_to_0, expr.range, typeHint.toString());
-    }
-    const structType = getStructType(typeHint);
-    if (structType.constructors.length !== 1) {
-        return ctx.error(DiagnosticCode.Unnamed_object_litteral_is_not_assignable_to_0_An_explicit_constrctor_must_be_used, expr.range, typeHint.toString());
-    }
-    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, 0);
-    if (!Array.isArray(fieldValues))
-        return undefined;
-    typeHint = getUnaliased(typeHint);
-    // TirDataStructType | TirSoPStructType
-    if (!(typeHint instanceof TirDataStructType
-        || typeHint instanceof TirSoPStructType)) {
-        return ctx.error(DiagnosticCode.Named_object_litteral_is_not_assignable_to_0, expr.range, typeHint.toString());
-    }
-    return new TirLitObjExpr(expr.fieldNames, fieldValues, typeHint, expr.range);
-}
-export function __commonCompileStructFieldValues(ctx, expr, realType, // possibly aliased
-structType, constructorIndex) {
-    if (constructorIndex < 0 || constructorIndex >= structType.constructors.length)
-        throw new Error("unreachable::__commonCompileStructFieldValues");
-    const constructorDef = structType.constructors[constructorIndex];
-    for (const exprField of expr.fieldNames) {
-        if (!constructorDef.fields.some(realField => realField.name === exprField.text)) {
-            return ctx.error(DiagnosticCode.Field_0_is_not_part_of_the_1_constructor_for_2_struct, exprField.range, exprField.text, constructorDef.name, structType);
-        }
-    }
-    if (expr.fieldNames.length !== constructorDef.fields.length) {
-        return ctx.error(DiagnosticCode.Unnamed_object_litteral_is_not_assignable_to_0_The_fields_do_not_match_the_the_type_definition, expr.range, realType.toString());
-    }
-    const fieldValues = new Array(constructorDef.fields.length);
-    for (let i = 0; i < constructorDef.fields.length; i++) {
-        const fieldDef = constructorDef.fields[i];
-        const initAstExprIdx = expr.fieldNames.findIndex(name => name.text === fieldDef.name);
-        if (initAstExprIdx === -1) {
-            return ctx.error(DiagnosticCode.Field_0_is_missing_but_required_by_the_1_constructor_of_the_2_struct, expr.range, fieldDef.name, constructorDef.name, structType);
-        }
-        const initExpr = _compileExpr(ctx, expr.values[initAstExprIdx], fieldDef.type);
-        if (!initExpr)
-            return undefined;
-        if (!canAssignTo(initExpr.type, fieldDef.type)) {
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.values[initAstExprIdx].range, initExpr.type, fieldDef.type);
-        }
-        fieldValues[i] = initExpr;
-    }
-    return fieldValues;
-}
-export function _compileLitteralArrayExpr(ctx, expr, typeHint) {
-    let listType = typeHint;
-    let elemsType = undefined;
-    if (listType) {
-        if (!canAssignToList(listType))
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.range, "List<T>", listType.toString());
-        else
-            elemsType = getListTypeArg(listType);
-    }
-    if (expr.elems.length === 0) {
-        if (!listType)
-            return ctx.error(DiagnosticCode.Empty_array_litteral_must_be_explicitly_cast_to_a_type, expr.range);
-        return new TirLitArrExpr([], listType, expr.range);
-    }
-    const fstCompiledExpr = _compileExpr(ctx, expr.elems[0], elemsType);
-    if (!fstCompiledExpr)
-        return undefined;
-    if (!elemsType)
-        elemsType = fstCompiledExpr.type;
-    else if (!canAssignTo(fstCompiledExpr.type, elemsType)) {
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.elems[0].range, fstCompiledExpr.type, elemsType);
-    }
-    if (!listType)
-        listType = new TirListT(elemsType);
-    const restElems = expr.elems.slice(1);
-    const compiledRestElems = restElems.map(elem => {
-        const compiled = _compileExpr(ctx, elem, elemsType);
-        if (!compiled)
-            return undefined;
-        if (!canAssignTo(compiled.type, elemsType)) {
-            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, elem.range, compiled.type, elemsType);
-        }
-        return compiled;
-    });
-    if (compiledRestElems.some(x => !isTirExpr(x)))
-        return undefined;
-    return new TirLitArrExpr([fstCompiledExpr, ...compiledRestElems], listType, expr.range);
-}

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

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