@harmoniclabs/pebble 0.1.3-dev8 → 0.1.3

package/dist/IR/IRNodes/IRHoisted.d.ts

@@ -24,6 +24,7 @@ export interface IRHoistedMeta {
 export interface IRHoistedMetadata extends IRMetadata {
     meta: IRHoistedMeta;
 }
+export declare function __unsafe_clear_hoisted_hash_to_symbol(): void;
 export declare class IRHoisted implements IIRTerm, Cloneable<IRHoisted>, IIRParent, ToJson, IRHoistedMetadata {
     readonly meta: IRHoistedMeta;
     get name(): symbol;

package/dist/IR/IRNodes/IRHoisted.js

@@ -19,6 +19,9 @@ const defaultHoistedMeta = freezeAll({
     forceHoist: false
 });
 const _hoisted_hash_to_symbol = new Map();
+export function __unsafe_clear_hoisted_hash_to_symbol() {
+    _hoisted_hash_to_symbol.clear();
+}
 export class IRHoisted {
     meta;
     get name() {

package/dist/IR/IRNodes/IRLetted.d.ts

@@ -34,6 +34,7 @@ export interface IRLettedMeta extends BaseIRMetadata {
 export interface IRLettedMetadata extends IRMetadata {
     meta: IRLettedMeta;
 }
+export declare function __unsafe_clear_letted_hash_to_symbol(): void;
 export declare class IRLetted implements IIRTerm, Cloneable<IRLetted>, IIRParent, ToJson, IRLettedMetadata {
     private _name;
     readonly meta: IRLettedMeta;

package/dist/IR/IRNodes/IRLetted.js

@@ -26,6 +26,9 @@ const defaultLettedMeta = freezeAll({
     isClosed: false
 });
 const _letted_hash_to_symbol = new Map();
+export function __unsafe_clear_letted_hash_to_symbol() {
+    _letted_hash_to_symbol.clear();
+}
 export class IRLetted {
     _name;
     meta;

package/dist/IR/IRNodes/utils/hashVarSym.d.ts

@@ -1 +1,2 @@
+export declare function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION(): void;
 export declare function hashVarSym(s: symbol): Uint8Array;

package/dist/IR/IRNodes/utils/hashVarSym.js

@@ -19,6 +19,11 @@ function _collectUnusedHashes() {
         }
     }
 }
+export function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION() {
+    _hash_to_sym.clear();
+    unusedHashes.length = 0;
+    _next_hash = MIN_SAFE_INTEGER;
+}
 export function hashVarSym(s) {
     const limitReached = _next_hash >= MAX_SAFE_INTEGER;
     if (_next_hash % 0xffff === 0

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.d.ts

@@ -1,2 +1,3 @@
 import { IRTerm } from "../../IRTerm.js";
+export declare function __unsafe_clear_hoisted_cache(): void;
 export declare function replaceHoistedWithLetted(term: IRTerm): void;

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.js

@@ -2,6 +2,9 @@ import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 const _hoisted_cache = new Map();
+export function __unsafe_clear_hoisted_cache() {
+    _hoisted_cache.clear();
+}
 export function replaceHoistedWithLetted(term) {
     // children first
     const children = term.children();

package/dist/compiler/AstCompiler/AstCompilationCtx.d.ts

@@ -11,6 +11,9 @@ export interface AstCompilationCtxFuncInfo {
     **/
     parentFunctionCtx: AstCompilationCtxFuncInfo | undefined;
     returnType: TirType;
+    /** when true, skip the return type assignability check
+     * and infer the return type from the returned expression */
+    inferReturnType?: boolean;
 }
 export interface IAstCompilationCtx {
     scope: AstScope;

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

@@ -5,8 +5,10 @@ import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.gener
 import { getUniqueInternalName } from "../../../internalVar.js";
 import { TirFuncExpr } from "../../../tir/expressions/TirFuncExpr.js";
 import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
+import { TirReturnStmt } from "../../../tir/statements/TirReturnStmt.js";
 import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
+import { void_t } from "../../../tir/program/stdScope/stdScope.js";
 import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
 import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileBlockStmt } from "../statements/_compileBlockStmt.js";
@@ -68,9 +70,17 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     }
     else {
         expectedFuncType = (isMethod ? undefined :
-            ctx.program.functions.get(expr.name.text)?.sig()) ?? getDataFuncSignature(ctx, expr.signature);
-        if (!(expectedFuncType instanceof TirFuncT))
-            return undefined;
+            ctx.program.functions.get(expr.name.text)?.sig());
+        if (!(expectedFuncType instanceof TirFuncT)) {
+            // if the return type annotation is missing,
+            // infer it from the body instead of erroring
+            if (!expr.signature.returnType) {
+                return _compileFuncExprInferReturnType(ctx, expr, isMethod);
+            }
+            expectedFuncType = getDataFuncSignature(ctx, expr.signature);
+            if (!(expectedFuncType instanceof TirFuncT))
+                return undefined;
+        }
     }
     const returnType = expectedFuncType.returnType;
     const funcCtx = ctx.newFunctionChildScope(returnType, isMethod);
@@ -97,6 +107,65 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
     return funcExpr;
 }
+/**
+ * compiles a function expression whose return type annotation is missing,
+ * inferring the return type from the body's return expressions.
+ *
+ * uses `inferReturnType` flag on the function context so that
+ * `_compileReturnStmt` skips the return type assignability check.
+ */
+function _compileFuncExprInferReturnType(ctx, expr, isMethod) {
+    // compile param types (reuse getDataFuncSignature logic for params only)
+    const funcParams = expr.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;
+    }
+    // use void as a temporary return type; the real type will be inferred
+    // from the body's return expressions after compilation
+    const tempReturnType = void_t;
+    const tempFuncType = new TirFuncT(paramTypes, tempReturnType);
+    const funcCtx = ctx.newFunctionChildScope(tempReturnType, isMethod);
+    // mark the context as inferring so _compileReturnStmt
+    // skips the return type assignability check
+    funcCtx.functionCtx.inferReturnType = true;
+    funcCtx.scope.defineValue({
+        name: expr.name.text,
+        type: tempFuncType,
+        isConstant: true,
+    });
+    if (expr.typeParams.length > 0)
+        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
+    const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr, tempFuncType);
+    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);
+    // infer return type from the first return statement in the body
+    const returnType = _inferReturnType(body.stmts) ?? tempReturnType;
+    const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
+    return funcExpr;
+}
+function _inferReturnType(stmts) {
+    for (const stmt of stmts) {
+        if (stmt instanceof TirReturnStmt && stmt.value) {
+            return stmt.value.type;
+        }
+    }
+    return undefined;
+}
 function _getDestructuredParamsAsVarDecls(funcCtx, expr, expectedFuncType) {
     const blockInitStmts = [];
     const params = [];

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

@@ -7,11 +7,12 @@ export function _compileReturnStmt(ctx, stmt) {
     if (!ctx.functionCtx)
         return ctx.error(DiagnosticCode.A_return_statement_can_only_be_used_within_a_function_body, stmt.range);
     const hintReturn = ctx.functionCtx.returnType;
+    const inferring = ctx.functionCtx.inferReturnType === true;
     const expr = stmt.value ?
-        _compileExpr(ctx, stmt.value, hintReturn) : new TirLitVoidExpr(stmt.range);
+        _compileExpr(ctx, stmt.value, inferring ? undefined : hintReturn) : new TirLitVoidExpr(stmt.range);
     if (!expr)
         return undefined;
-    if (!canAssignTo(expr.type, hintReturn))
+    if (!inferring && !canAssignTo(expr.type, hintReturn))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.value?.range ?? stmt.range, expr.type.toString(), hintReturn.toString());
     return [new TirReturnStmt(expr, stmt.range)];
 }

package/dist/compiler/Compiler.js

@@ -6,6 +6,11 @@ import { AstCompiler } from "./AstCompiler/AstCompiler.js";
 import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
 import { __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRHash.js";
+import { __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRNodes/utils/hashVarSym.js";
+import { __unsafe_clear_hoisted_hash_to_symbol } from "../IR/IRNodes/IRHoisted.js";
+import { __unsafe_clear_letted_hash_to_symbol } from "../IR/IRNodes/IRLetted.js";
+import { __unsafe_clear_hoisted_cache } from "../IR/toUPLC/subRoutines/replaceHoistedWithLetted.js";
+import { __unsafe_clear_mapToType_cache } from "./TirCompiler/expressify/expressifyVars.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
 export { SourceTypeMap } from "./SourceTypeMap.js";
 export class Compiler extends DiagnosticEmitter {
@@ -127,6 +132,11 @@ export class Compiler extends DiagnosticEmitter {
         this.io.writeFile(outPath, serialized, cfg.root);
         this.io.stdout.write(`compiled program written to ${outPath}\n`);
         __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
+        __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
+        __unsafe_clear_hoisted_hash_to_symbol();
+        __unsafe_clear_letted_hash_to_symbol();
+        __unsafe_clear_hoisted_cache();
+        __unsafe_clear_mapToType_cache();
         return serialized;
     }
 }

package/dist/compiler/TirCompiler/expressify/expressifyVars.d.ts

@@ -8,3 +8,4 @@ import { ExpressifyCtx } from "./ExpressifyCtx.js";
  * @returns a the modified expression
 **/
 export declare function expressifyVars(ctx: ExpressifyCtx, expr: TirExpr): TirExpr;
+export declare function __unsafe_clear_mapToType_cache(): void;

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -484,3 +484,6 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
     */
 }
 const _base_mapToType_cache = new Map();
+export function __unsafe_clear_mapToType_cache() {
+    _base_mapToType_cache.clear();
+}

package/dist/compiler/tir/expressions/TirTraceExpr.js

@@ -1,4 +1,6 @@
 import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { hoisted_intToUtf8Bytes } from "../../../IR/tree_utils/intToUtf8Bytes.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
@@ -46,8 +48,11 @@ export class TirTraceExpr {
             // assume bytes
             bytesIR = this.traceExpr.toIR(ctx);
         }
-        return _ir_apps(IRNative.trace, 
-        // bytes -> string via decodeUtf8
-        _ir_apps(IRNative.decodeUtf8, bytesIR), this.continuation.toIR(ctx));
+        // Force(trace(msg, Delay(continuation)))
+        // Delay prevents the continuation from being evaluated
+        // as a trace argument; Force evaluates it after the
+        // trace call has logged the message.
+        // This gives correct trace order in loops and nested traces.
+        return new IRForced(_ir_apps(IRNative.trace, _ir_apps(IRNative.decodeUtf8, bytesIR), new IRDelayed(this.continuation.toIR(ctx))));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.3-dev8",
+  "version": "0.1.3",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",