@harmoniclabs/pebble 0.3.0 → 0.3.1

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

@@ -1,3 +1,4 @@
+import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
@@ -48,15 +49,62 @@ export function _compileCallExpr(ctx, expr, typeHint) {
             }
             // 2) Compile arguments. We need them anyway, and they're used for
             //    inference when no explicit args were given.
-            const tirArgs = expr.args.map((arg, i) => {
-                const expected = explicitArgs
-                    ? substituteTypeParams(funcType.argTypes[i], new Map(template.typeParams.map((tp, idx) => [tp.symbol, explicitArgs[idx]])))
-                    : undefined;
-                return _compileExpr(ctx, arg, expected);
-            });
-            for (const a of tirArgs)
-                if (!a)
-                    return undefined;
+            //
+            // For inferred-type-args calls, lambda arguments cannot be compiled
+            // without an expected function type (their param types would be
+            // unannotated). So we compile non-lambda args first, build an
+            // inference environment from them, then compile lambda args with
+            // the substituted expected type from `funcType.argTypes[i]`.
+            const tirArgs = new Array(expr.args.length);
+            const usable = Math.min(expr.args.length, funcType.argTypes.length);
+            if (explicitArgs) {
+                const explicitSubst = new Map(template.typeParams.map((tp, idx) => [tp.symbol, explicitArgs[idx]]));
+                for (let i = 0; i < expr.args.length; i++) {
+                    const expected = i < funcType.argTypes.length
+                        ? substituteTypeParams(funcType.argTypes[i], explicitSubst)
+                        : undefined;
+                    const compiled = _compileExpr(ctx, expr.args[i], expected);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                }
+            }
+            else {
+                const env = new Map();
+                // Pass 1: compile non-FuncExpr args (no type hint needed) and
+                // populate `env` from each arg's resolved type.
+                for (let i = 0; i < expr.args.length; i++) {
+                    if (expr.args[i] instanceof FuncExpr)
+                        continue;
+                    const compiled = _compileExpr(ctx, expr.args[i], undefined);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                    if (i < usable) {
+                        if (!inferTypeArgs(funcType.argTypes[i], compiled.type, env))
+                            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, compiled.type.toString(), funcType.argTypes[i].toString());
+                    }
+                }
+                // Pass 2: compile FuncExpr args with the substituted expected
+                // type so lambda param types can be inferred from context.
+                for (let i = 0; i < expr.args.length; i++) {
+                    if (!(expr.args[i] instanceof FuncExpr))
+                        continue;
+                    const expected = i < funcType.argTypes.length
+                        ? substituteTypeParams(funcType.argTypes[i], env)
+                        : undefined;
+                    const compiled = _compileExpr(ctx, expr.args[i], expected);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                    if (i < usable) {
+                        // re-run to capture type params bound only via the
+                        // lambda's return type (e.g. `map<T, A>(f: (T) -> A, ...)`)
+                        if (!inferTypeArgs(funcType.argTypes[i], compiled.type, env))
+                            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, compiled.type.toString(), funcType.argTypes[i].toString());
+                    }
+                }
+            }
             // 3) Determine final type arguments
             let resolvedArgs;
             if (explicitArgs) {
@@ -64,7 +112,6 @@ export function _compileCallExpr(ctx, expr, typeHint) {
             }
             else {
                 const env = new Map();
-                const usable = Math.min(tirArgs.length, funcType.argTypes.length);
                 for (let i = 0; i < usable; i++) {
                     if (!inferTypeArgs(funcType.argTypes[i], tirArgs[i].type, env)) {
                         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, tirArgs[i].type.toString(), funcType.argTypes[i].toString());

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.3.0";
+export declare const COMPILER_VERSION = "0.3.1";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.3.0";
+export const COMPILER_VERSION = "0.3.1";

package/package.json

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