Repository navigation
Conversation
Why:
The built-in PPX checks `await` against an async context that each
`Pexp_fun` sets to whether its function is async. A functor is a
`Pmod_functor` module expression, which left the context as it was, so
its body took the context around it: true at the top level of a file,
where `await` is allowed, and in an async function. A functor compiles
to a JavaScript function that is not async, so the output had `await`
in a plain function. A functor body is now not an async context, and
the context around the functor is restored after it. In a structure,
`module M = await List` was not checked at all, so it passed in a
functor body or a module nested in a plain function; it is now checked
as in an expression.
Diagnostic added (await in a functor body):
Example:
module type S = {
let p: promise<int>
}
module F = (X: S) => {
let v = await X.p
}
Before (js): a SyntaxError when the module loads
function F(X) {
let v = await X.p;
return {
v: v
};
}
After (diagnostic):
A.res:5:11-19
Await on expression not in an async context
Diagnostic added (dynamic import in a module in a plain function):
Example:
let f = values => {
module M = {
module L = await List
let n = L.length(values)
}
M.n
}
Before (js): a SyntaxError when the module loads
function f(values) {
let L = await import("@rescript/runtime/lib/es6/Stdlib_List.mjs");
let n = L.length(values);
return n;
}
After (diagnostic):
A.res:3:16-25
Await on expression not in an async context
Diagnostic added (functor applied where it is defined):
Example:
module type S = {
let p: promise<int>
}
let f = async p => {
module F = (X: S) => {
let v = await X.p
}
module M = F({
let p = p
})
M.v
}
Before (js): valid, since the optimizer inlines the application
async function f(p) {
let v = await p;
return v;
}
After (diagnostic):
A.res:6:13-21
Await on expression not in an async context
Review: Does a working program stop compiling? Yes, where the optimizer
inlined every application of the functor and dropped the functor: a
functor defined and applied in an async function, as above, a
top-level functor that an interface or a signature hides, and a
functor applied where it is written. That depends on the optimization:
after `module G = F`, `G({...})` is not inlined and `F` stays a
function with `await` in it. Also rejected are `module M = await (List:
{...})`, which imports nothing dynamically, in a functor body or a
module in a plain function, as in an expression already, and `await`
in a functor under `module type of`. Programs that still compile give
the same JavaScript.
Signed-off-by: mununki <woonki.moon@gmail.com>
Changelog🐛 Bug fix
Semantic Diff1 commit · Full page Reject await in a functor bodyd8b70ba · mununki · Nov 04, 2026, 09:38 UTC
Diagnostic added (await in a functor body) module type S = {
let p: promise<int>
}
module F = (X: S) => {
let v = await X.p
}
function F(X) {
let v = await X.p;
return {
v: v
};
}
Diagnostic added (dynamic import in a module in a plain function) let f = values => {
module M = {
module L = await List
let n = L.length(values)
}
M.n
}
function f(values) {
let L = await import("@rescript/runtime/lib/es6/Stdlib_List.mjs");
let n = L.length(values);
return n;
}
Diagnostic added (functor applied where it is defined) module type S = {
let p: promise<int>
}
let f = async p => {
module F = (X: S) => {
let v = await X.p
}
module M = F({
let p = p
})
M.v
}
async function f(p) {
let v = await p;
return v;
}
Review
|
Codecov Report✅ All modified and coverable lines are covered by tests. Additional details and impacted files@@ Coverage Diff @@
## master #9220 +/- ##
=======================================
Coverage 81.75% 81.76%
=======================================
Files 457 457
Lines 65332 65341 +9
=======================================
+ Hits 53413 53425 +12
+ Misses 11919 11916 -3
🚀 New features to boost your workflow:
|
rescript
@rescript/belt
@rescript/darwin-arm64
@rescript/linux-arm64
@rescript/linux-x64
@rescript/runtime
@rescript/win32-x64
commit: |
|
Developer playground preview: https://rescript-lang.github.io/rescript/dev-playground/?version=pr-9220 |
|
@codex review |
Codex Review SummaryThis comment shows the latest Codex review activity on this pull request.
ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings. |
|
Codex Review: Didn't find any major issues. Can't wait for the next one! Reviewed commit: ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
If Codex has suggestions, it will comment; otherwise it will react with 👍. Codex can also answer questions or update the PR. Try commenting "@codex address that feedback". |
Fixes: #9219
awaitin a functor body passed the await check and compiled toawaitin the plain JavaScript function the functor becomes:module Make = (Source: Source) => { let value = await Source.value }compiled tofunction Make(Source) { let value = await Source.value; ... }, which fails to load with a SyntaxError. This happened at the top level of a file, where top-level await is allowed, and in an async function, for example for a first-class functor that an async function returns.for awaitandmodule M = await Listin a functor body behaved the same, and so didmodule M = await Listin a module nested in a plain function. #9169 made a function's body an async context exactly when the function is async; a functor is the module-level function it did not cover.The check is in
compiler/frontend/bs_builtin_ppx.ml.expr_mappersets the async context at eachPexp_fun, butmodule_expr_mapperleft it unchanged at aPmod_functor, so the body took the context around the functor.module_expr_mappernow maps a functor's body with the context set to false and restores the context afterwards. The parameter's module type is not evaluated, so it keeps the outer context.structure_mapperrewrotemodule M = await Listin a structure without checking the context, whichexpr_mapperchecks for the same form in an expression. It now checks it under the same condition, through acheck_awaitthat both use.await,for awaitandmodule M = await Listin a functor body are rejected withAwait on expression not in an async context, wherever the functor is: at the top level, in an async function, packed as a first-class module, with several parameters, generative, or in another functor's body.module M = await Listin a module nested in a plain function is rejected with the same error.module M = ((X: S) => {...})({...})). The inlining (is_a_functorinlam_pass_remove_alias.ml) is an optimization. Aftermodule G = F,G({...})is not inlined andFstays a function withawaitin it. An application in a plain function inside the async function moves theawaitinto that plain function. The changelog fragment is afix, as for Reject await in a function that an async function returns directly #9169; reviewers may preferbreaking.module M = await (List: {...}), which imports nothing dynamically, in a functor body or in a module in a plain function, as the same form in an expression already was. Alsoawaitin a functor undermodule type of, as in amodule type ofin a plain function.%%privatearound such a functor was already an error and now reports theawaitfirst.awaitat the top level of a module outside functors, including in the argument of a functor application and in a parameter's module type. Also unchanged:await,for awaitand dynamic imports in an async function inside a functor body, andawaitafter a functor in an async function. Functor types in signatures are not affected. Programs that still compile give the same JavaScript, and no checked-in output changes apart from the new test.Tests: super_errors fixtures for
awaitin a functor body at the top level, with two parameters, in another functor's body, in an async function (the inlined case) and packed in an async function; forfor awaitandmodule L = await Listin a functor body; and formodule L = await Listin a module in a plain function. Mocha tests coverawaitand a dynamic import in async functions in a functor body, a functor applied in an async function,awaitafter a functor in an async function, and top-levelawait.Checklist
changes/README.md), or no release notes are needed and a maintainer should applychangelog:skip.CONTRIBUTING.md).git commit -s).