@harmoniclabs/pebble 0.1.0-dev0

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

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

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

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

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

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

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

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

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

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

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

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

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

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