@elaraai/east 1.0.30 → 1.0.32

package/dist/src/expr/block.js

@@ -22,7 +22,7 @@ import { StructExpr } from "./struct.js";
 import { VariantExpr } from "./variant.js";
 import { RecursiveExpr } from "./recursive.js";
 import { createFunctionExpr, FunctionExpr } from "./function.js";
-import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
+import { astUnderCurrentSourceMap, valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
 import { toEastTypeValue } from "../type_of_type.js";
 import { isVariant } from "../containers/variant.js";
 import { RefExpr } from "./ref.js";
@@ -135,167 +135,181 @@ export function from(value, type) {
         if (typeof value !== "function") {
             throw new Error(`Expected function but got ${typeof value}`);
         }
-        const { inputs, output } = type;
-        const input_variables = inputs.map(i => ({
-            ast_type: "Variable",
-            type: i,
-            loc_id: get_location_id(),
-            mutable: false,
-        }));
-        const $ = BlockBuilder(output);
-        const input_exprs = input_variables.map(fromAst);
-        const ret = value($, ...input_exprs);
-        const statements = $.statements;
-        if (ret !== undefined) {
-            if (ret instanceof Expr) {
-                // It is possible this expression is already the last statement.
-                // Input of the form `$ => $.xxx()` or `$ => { ...; return $.xxx(); }` will cause this
-                // So we filter out this case to avoid unintended repeated statements (and if users write an identical expression twice, they won't be `===`)
-                if (statements.length === 0 || statements[statements.length - 1] !== ret[AstSymbol]) {
-                    statements.push(Expr.ast(ret));
+        // Build under a source map (inheriting any ambient one) and stamp the
+        // map on the result so a later embed can re-intern the locations —
+        // otherwise a top-level East.value(lambda, FunctionType) loses its
+        // pointer to user code (issue #204).
+        return ensure_source_map(() => {
+            const { inputs, output } = type;
+            const input_variables = inputs.map(i => ({
+                ast_type: "Variable",
+                type: i,
+                loc_id: get_location_id(),
+                mutable: false,
+            }));
+            const $ = BlockBuilder(output);
+            const input_exprs = input_variables.map(fromAst);
+            const ret = value($, ...input_exprs);
+            const statements = $.statements;
+            if (ret !== undefined) {
+                if (ret instanceof Expr) {
+                    // It is possible this expression is already the last statement.
+                    // Input of the form `$ => $.xxx()` or `$ => { ...; return $.xxx(); }` will cause this
+                    // So we filter out this case to avoid unintended repeated statements (and if users write an identical expression twice, they won't be `===`)
+                    if (statements.length === 0 || statements[statements.length - 1] !== ret[AstSymbol]) {
+                        statements.push(Expr.ast(ret));
+                    }
                 }
-            }
-            else {
-                const retAst = valueOrExprToAstTyped(ret, output);
-                statements.push(retAst);
-            }
-        }
-        let body_ast;
-        if (isTypeEqual(output, NullType)) {
-            if (statements.length === 0) {
-                body_ast = { ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null };
-            }
-            else if (statements.length === 1 && isSubtype(statements[0].type, NullType)) {
-                body_ast = statements[0];
-            }
-            else {
-                if (!isSubtype(statements[statements.length - 1].type, NullType)) {
-                    statements.push({ ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null });
+                else {
+                    const retAst = valueOrExprToAstTyped(ret, output);
+                    statements.push(retAst);
                 }
-                body_ast = {
-                    ast_type: "Block",
-                    type: statements[statements.length - 1].type,
-                    loc_id: get_location_id(),
-                    statements: statements,
-                };
             }
-        }
-        else {
-            if (statements.length === 0) {
-                throw new Error(`Function expected output of type ${printType(output)}, but no function body or statements were provided`);
-            }
-            else if (statements.length === 1) {
-                if (!isSubtype(statements[0].type, output)) {
-                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[0].type)}`);
+            let body_ast;
+            if (isTypeEqual(output, NullType)) {
+                if (statements.length === 0) {
+                    body_ast = { ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null };
+                }
+                else if (statements.length === 1 && isSubtype(statements[0].type, NullType)) {
+                    body_ast = statements[0];
+                }
+                else {
+                    if (!isSubtype(statements[statements.length - 1].type, NullType)) {
+                        statements.push({ ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null });
+                    }
+                    body_ast = {
+                        ast_type: "Block",
+                        type: statements[statements.length - 1].type,
+                        loc_id: get_location_id(),
+                        statements: statements,
+                    };
                 }
-                body_ast = statements[0];
             }
             else {
-                if (!isSubtype(statements[statements.length - 1].type, output)) {
-                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[statements.length - 1].type)}`);
+                if (statements.length === 0) {
+                    throw new Error(`Function expected output of type ${printType(output)}, but no function body or statements were provided`);
+                }
+                else if (statements.length === 1) {
+                    if (!isSubtype(statements[0].type, output)) {
+                        throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[0].type)}`);
+                    }
+                    body_ast = statements[0];
+                }
+                else {
+                    if (!isSubtype(statements[statements.length - 1].type, output)) {
+                        throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[statements.length - 1].type)}`);
+                    }
+                    body_ast = {
+                        ast_type: "Block",
+                        type: statements[statements.length - 1].type,
+                        loc_id: get_location_id(),
+                        statements: statements,
+                    };
                 }
-                body_ast = {
-                    ast_type: "Block",
-                    type: statements[statements.length - 1].type,
-                    loc_id: get_location_id(),
-                    statements: statements,
-                };
             }
-        }
-        if (!isSubtype(body_ast.type, output)) {
-            throw new Error(`Expected function definition to return type ${printType(output)}, got ${printType(body_ast.type)}`);
-        }
-        const ast = {
-            ast_type: "Function",
-            type: FunctionType(inputs, output),
-            loc_id: get_location_id(),
-            parameters: input_variables,
-            body: body_ast,
-        };
-        return fromAst(ast);
+            if (!isSubtype(body_ast.type, output)) {
+                throw new Error(`Expected function definition to return type ${printType(output)}, got ${printType(body_ast.type)}`);
+            }
+            const ast = {
+                ast_type: "Function",
+                type: FunctionType(inputs, output),
+                loc_id: get_location_id(),
+                parameters: input_variables,
+                body: body_ast,
+            };
+            const expr = fromAst(ast);
+            Object.defineProperty(expr, SourceMapSymbol, { enumerable: false, value: get_current_source_map() });
+            Object.defineProperty(ast, SourceMapSymbol, { enumerable: false, value: get_current_source_map() });
+            return expr;
+        }); // ensure_source_map
     }
     else if (type && type.type === "AsyncFunction") {
         if (typeof value !== "function") {
             throw new Error(`Expected function but got ${typeof value}`);
         }
-        const { inputs, output } = type;
-        const input_variables = inputs.map(i => ({
-            ast_type: "Variable",
-            type: i,
-            loc_id: get_location_id(),
-            mutable: false,
-        }));
-        const $ = BlockBuilder(output);
-        const input_exprs = input_variables.map(fromAst);
-        const ret = value($, ...input_exprs);
-        const statements = $.statements;
-        if (ret !== undefined) {
-            if (ret instanceof Expr) {
-                // It is possible this expression is already the last statement.
-                // Input of the form `$ => $.xxx()` or `$ => { ...; return $.xxx(); }` will cause this
-                // So we filter out this case to avoid unintended repeated statements (and if users write an identical expression twice, they won't be `===`)
-                if (statements.length === 0 || statements[statements.length - 1] !== ret[AstSymbol]) {
-                    statements.push(Expr.ast(ret));
+        return ensure_source_map(() => {
+            const { inputs, output } = type;
+            const input_variables = inputs.map(i => ({
+                ast_type: "Variable",
+                type: i,
+                loc_id: get_location_id(),
+                mutable: false,
+            }));
+            const $ = BlockBuilder(output);
+            const input_exprs = input_variables.map(fromAst);
+            const ret = value($, ...input_exprs);
+            const statements = $.statements;
+            if (ret !== undefined) {
+                if (ret instanceof Expr) {
+                    // It is possible this expression is already the last statement.
+                    // Input of the form `$ => $.xxx()` or `$ => { ...; return $.xxx(); }` will cause this
+                    // So we filter out this case to avoid unintended repeated statements (and if users write an identical expression twice, they won't be `===`)
+                    if (statements.length === 0 || statements[statements.length - 1] !== ret[AstSymbol]) {
+                        statements.push(Expr.ast(ret));
+                    }
                 }
-            }
-            else {
-                const retAst = valueOrExprToAstTyped(ret, output);
-                statements.push(retAst);
-            }
-        }
-        let body_ast;
-        if (isTypeEqual(output, NullType)) {
-            if (statements.length === 0) {
-                body_ast = { ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null };
-            }
-            else if (statements.length === 1 && isSubtype(statements[0].type, NullType)) {
-                body_ast = statements[0];
-            }
-            else {
-                if (!isSubtype(statements[statements.length - 1].type, NullType)) {
-                    statements.push({ ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null });
+                else {
+                    const retAst = valueOrExprToAstTyped(ret, output);
+                    statements.push(retAst);
                 }
-                body_ast = {
-                    ast_type: "Block",
-                    type: statements[statements.length - 1].type,
-                    loc_id: get_location_id(),
-                    statements: statements,
-                };
             }
-        }
-        else {
-            if (statements.length === 0) {
-                throw new Error(`Function expected output of type ${printType(output)}, but no function body or statements were provided`);
-            }
-            else if (statements.length === 1) {
-                if (!isSubtype(statements[0].type, output)) {
-                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[0].type)}`);
+            let body_ast;
+            if (isTypeEqual(output, NullType)) {
+                if (statements.length === 0) {
+                    body_ast = { ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null };
+                }
+                else if (statements.length === 1 && isSubtype(statements[0].type, NullType)) {
+                    body_ast = statements[0];
+                }
+                else {
+                    if (!isSubtype(statements[statements.length - 1].type, NullType)) {
+                        statements.push({ ast_type: "Value", type: NullType, loc_id: get_location_id(), value: null });
+                    }
+                    body_ast = {
+                        ast_type: "Block",
+                        type: statements[statements.length - 1].type,
+                        loc_id: get_location_id(),
+                        statements: statements,
+                    };
                 }
-                body_ast = statements[0];
             }
             else {
-                if (!isSubtype(statements[statements.length - 1].type, output)) {
-                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[statements.length - 1].type)}`);
+                if (statements.length === 0) {
+                    throw new Error(`Function expected output of type ${printType(output)}, but no function body or statements were provided`);
+                }
+                else if (statements.length === 1) {
+                    if (!isSubtype(statements[0].type, output)) {
+                        throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[0].type)}`);
+                    }
+                    body_ast = statements[0];
+                }
+                else {
+                    if (!isSubtype(statements[statements.length - 1].type, output)) {
+                        throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[statements.length - 1].type)}`);
+                    }
+                    body_ast = {
+                        ast_type: "Block",
+                        type: statements[statements.length - 1].type,
+                        loc_id: get_location_id(),
+                        statements: statements,
+                    };
                 }
-                body_ast = {
-                    ast_type: "Block",
-                    type: statements[statements.length - 1].type,
-                    loc_id: get_location_id(),
-                    statements: statements,
-                };
             }
-        }
-        if (!isSubtype(body_ast.type, output)) {
-            throw new Error(`Expected function definition to return type ${printType(output)}, got ${printType(body_ast.type)}`);
-        }
-        const ast = {
-            ast_type: "AsyncFunction",
-            type: FunctionType(inputs, output),
-            loc_id: get_location_id(),
-            parameters: input_variables,
-            body: body_ast,
-        };
-        return fromAst(ast);
+            if (!isSubtype(body_ast.type, output)) {
+                throw new Error(`Expected function definition to return type ${printType(output)}, got ${printType(body_ast.type)}`);
+            }
+            const ast = {
+                ast_type: "AsyncFunction",
+                type: FunctionType(inputs, output),
+                loc_id: get_location_id(),
+                parameters: input_variables,
+                body: body_ast,
+            };
+            const expr = fromAst(ast);
+            Object.defineProperty(expr, SourceMapSymbol, { enumerable: false, value: get_current_source_map() });
+            Object.defineProperty(ast, SourceMapSymbol, { enumerable: false, value: get_current_source_map() });
+            return expr;
+        }); // ensure_source_map
     }
     const ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);
     return fromAst(ast);
@@ -1549,7 +1563,7 @@ export const BlockBuilder = (return_type) => {
             if (type && !isSubtype(Expr.type(value), type)) {
                 throw typeMismatchError(Expr.type(value), type, { loc_id: get_location_id() });
             }
-            ast = Expr.ast(value);
+            ast = astUnderCurrentSourceMap(value);
         }
         else {
             ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);
@@ -1578,7 +1592,7 @@ export const BlockBuilder = (return_type) => {
             if (type && !isSubtype(Expr.type(value), type)) {
                 throw typeMismatchError(Expr.type(value), type, { loc_id: get_location_id() });
             }
-            ast = Expr.ast(value);
+            ast = astUnderCurrentSourceMap(value);
         }
         else {
             ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);