fulmine.js 5.19.2 → 5.19.4

package/src/declarative.js

@@ -19,12 +19,14 @@ limitations under the License.
 
 const acorn = require("acorn");
 const { stringify, withDefaultCharset, withUtf8Charset, contentTypeFor } = require("./utils.js");
-// H3App, DeclarativeResponse and _cfg all exist at runtime but are missing from the
-// declaration file the package ships, so the module is read through a loose alias
+// H3App, DeclarativeResponse and _cfg exist at runtime but are missing from the .d.ts the
+// package ships, so the module is read through a loose alias
 const uWS = require("uWebSockets.js");
 const uWSAny = /** @type {any} */ (uWS);
 const statuses = require("statuses");
 
+/** @typedef {import("./application.js").Application} Application */
+
 const parser = acorn.Parser;
 
 const allowedResMethods = [
@@ -43,31 +45,27 @@ const allowedResMethods = [
 
 const allowedIdentifiers = ["query", "params", ...allowedResMethods];
 
-/** What res.type(x) sets the content type to, which is a lookup on a literal. */
+/** What res.type(x) sets the content type to. A lookup on a literal. */
 const typeValueOf = (type) => (type.indexOf("/") === -1 ? contentTypeFor(type) : type);
 
 // what one instruction of a declarative response can carry, since uWS writes its length as a u16
 const MAX_INSTRUCTION_LENGTH = 65535;
 
-// the three that write a body, of which only one may appear
-// The headers a conditional request is answered from. A compiled response cannot read the request,
-// so it cannot honour one, and a handler that sets one has to stay on the ordinary path.
+// Headers used to answer a conditional request. A compiled response cannot read the request, so a
+// handler that sets one has to stay on the ordinary path.
 const VALIDATOR_HEADERS = new Set(["etag", "last-modified"]);
 
-// The statuses whose message carries no content. 205 is here for node's reason rather than
-// express's: express strips the body for 204 and 304, and node answers a 205 with a lone
-// Content-Length of zero, so all three come out of the ordinary path with no body at all.
+// Statuses that carry no body. Express strips it for 204 and 304, node answers a 205 with
+// Content-Length: 0. All three come out of the ordinary path with no body.
 const BODILESS_STATUSES = new Set([204, 205, 304]);
 
+// the three that write a body, only one of them may appear
 const bodyMethods = new Set(["send", "json", "end"]);
-// and the four that finish the response, after which nothing a handler does is observable
+// the four that finish the response, nothing a handler does after them is observable
 const terminalMethods = new Set(["send", "json", "end", "sendStatus"]);
 
-// Every node type the walk in filterNodes knows how to step through. A type that is missing here
-// is not rejected for being dangerous, it is rejected because the walk would step over it without
-// saying so: a sequence expression hid its calls completely, and `res.append("x", "1"), res.send("k")`
-// compiled into a 200 with no body and no headers at all. Anything unfamiliar falls back to
-// ordinary routing, which is always correct if slower.
+// Node types filterNodes can walk. A missing one is refused because the walk would skip it in
+// silence: `res.append("x", "1"), res.send("k")` compiled to a 200 with no body and no headers.
 const understoodNodeTypes = new Set([
     "ArrowFunctionExpression",
     "FunctionDeclaration",
@@ -90,10 +88,11 @@ const understoodNodeTypes = new Set([
 ]);
 
 /**
- * Every node type in the tree, found by walking whatever is there rather than by following named
- * edges, so that the answer does not depend on the walk being complete.
+ * Every node type in the tree. Walks all the keys instead of named edges, so the answer does not
+ * depend on the walk being complete.
  *
- * @param {any} node
+ * @param {any} node an acorn node, or an array or a scalar under one: walked by key, so no shape
+ *   is assumed
  * @param {Set<string>} types
  */
 function collectNodeTypes(node, types) {
@@ -114,10 +113,9 @@ function collectNodeTypes(node, types) {
 }
 
 /**
- * The key a property writes, when it is one this can read: a plain name or a literal, never
- * computed and never a getter or a spread.
+ * The key a property writes. Only a plain name or a literal, never computed, a getter or a spread.
  *
- * @param {any} property
+ * @param {import("acorn").AnyNode} property an acorn node, a Property when it is one this reads
  * @returns {string|null} null when the shape is not one of those
  */
 function literalKeyOf(property) {
@@ -131,15 +129,11 @@ function literalKeyOf(property) {
 }
 
 /**
- * The value a literal expression denotes, for the shapes whose value is known at registration
- * time. Anything else throws, which the catch around the whole compiler turns into ordinary
- * routing: a response written once cannot contain something only a request could produce.
- *
- * This replaced reading the value back out of the source text, which could not see through a
- * nested object or an array and needed a regular expression to re-quote the keys.
+ * The value of a literal expression, for the shapes known at registration time. Anything else
+ * throws, and the catch around the compiler turns it into ordinary routing.
  *
- * @param {any} node
- * @returns {any}
+ * @param {import("acorn").AnyNode} node
+ * @returns {unknown} whatever the literal denotes
  */
 function literalValue(node) {
     switch (node.type) {
@@ -192,533 +186,620 @@ function literalValue(node) {
 }
 
 // generates a declarative response from a callback
-// uWS allows creating such responses and they are extremely fast
-// since you don't even have to call into Node.js at all
-// declarative response will only be created if callback is 'simple enough'
-// simple enough means:
-// - doesnt call external functions
-// - doesnt create variables
-// - only uses req.query and req.params
-// basically, its only simple, static responses
-module.exports = function compileDeclarative(cb, app) {
-    try {
-        let code = cb.toString();
-        // convert anonymous functions to named ones to make it valid code
-        if (code.startsWith("function") || code.startsWith("async function")) {
-            code = code.replace(/function *\(/, "function __cb(");
-        }
-
-        // Everything below runs inside the try above, and any shape this does not understand falls
-        // out as `return false`, which is the fallback to ordinary routing. That is the design, and
-        // it is why the tree is walked loosely: acorn types every shape JavaScript can take, and
-        // enumerating them here would be a second, worse copy of that catch.
-        //
-        // The list below looks like the thing to widen, and it is not. Counted over the 1113
-        // handlers in this repository's tests, demo and benchmark scenarios: 42.6% call something
-        // that is not res, which no syntax admitted here can reach, and admitting `const` would
-        // unlock 7 handlers, 0.6%, one conditional a further 0.1%. On the demo and the benchmark
-        // alone, where the handlers look more like an application's, the share that calls something
-        // rises to 59% and the two would unlock nothing at all. What keeps a route off this path is
-        // that its answer is not knowable until the request arrives, and a variable is only another
-        // way to spell an answer that already was.
-        /** @type {any[]} */
-        const tokens = [...acorn.tokenizer(code, { ecmaVersion: "latest" })];
-
-        if (
-            tokens.some((token) =>
-                [
-                    "throw",
-                    "new",
-                    "await",
-                    "try",
-                    "catch",
-                    "finally",
-                    "if",
-                    "else",
-                    "switch",
-                    "case",
-                    "default",
-                    "for",
-                    "while",
-                    "do",
-                    "var",
-                    "let",
-                    "const"
-                ].includes(token.value)
-            )
-        ) {
-            return false;
-        }
-
-        /** @type {any[]} */
-        const parsed = parser.parse(code, { ecmaVersion: "latest" }).body;
-        let fn = parsed[0];
-
-        if (fn.type === "ExpressionStatement") {
-            fn = fn.expression;
-        }
-
-        // check if it is a function
-        if (fn.type !== "FunctionDeclaration" && fn.type !== "ArrowFunctionExpression") {
-            return false;
-        }
-
-        // before anything is read out of the tree, since reading it is only meaningful for the
-        // shapes the walk can see through
-        const nodeTypes = new Set();
-        collectNodeTypes(fn, nodeTypes);
-        for (const type of nodeTypes) {
-            if (!understoodNodeTypes.has(type)) {
-                return false;
-            }
-        }
-
-        const args = fn.params.map((param) => param.name);
-
-        if (args.length < 2) {
-            // invalid function? doesn't have (req, res) args
-            return false;
-        }
-
-        // `return res.send(...)` describes the same response as `res.send(...)` and is written far
-        // more often, so it is worth reading. It only describes the same response when nothing
-        // follows it: every call in the body is read, whether or not it can be reached, so a return
-        // in the middle would compile statements that never run. A return inside a nested function
-        // fails the same test, not being the last statement of this one.
-        const returns = filterNodes(fn, (node) => node.type === "ReturnStatement");
-        if (returns.length) {
-            const statements = fn.body.type === "BlockStatement" ? fn.body.body : null;
-            if (!statements || returns.length > 1 || returns[0] !== statements[statements.length - 1]) {
-                return false;
+/**
+ * The status and the headers the calls set, in the order they were first written. null when one
+ * of them is not a literal this can read.
+ *
+ * @param {any[]} callExprs the res calls, in run order, each carrying what readResCalls read off
+ *   its callee as `obj`; loose because the arguments are taken as whatever literal they hold
+ * @param {[string, string][]} headers written to, so the caller keeps the array the body reader also uses
+ * @returns {{statusCode: number, sendStatusUsed: boolean}|null}
+ */
+function readStatusAndHeaders(callExprs, headers) {
+    let statusCode = 200;
+    // sendStatus and a bare send() both leave the body empty, but sendStatus sends the status
+    // message and send() sends nothing
+    let sendStatusUsed = false;
+    // get statusCode
+    for (const call of callExprs) {
+        if (call.obj.propertyName === "status") {
+            if (call.arguments[0].type !== "Literal") {
+                return null;
             }
+            statusCode = call.arguments[0].value;
         }
+    }
 
-        const [req, res] = args;
-        let queryName, paramsName;
-        const queries = [],
-            params = [];
-
-        if (fn.params[0].type === "ObjectPattern") {
-            const query = fn.params[0].properties.find((prop) => prop.key.name === "query");
-            const param = fn.params[0].properties.find((prop) => prop.key.name === "params");
-
-            if (query?.value?.type === "Identifier") {
-                queryName = query.value.name;
-            } else if (query?.value?.type === "ObjectPattern") {
-                for (const prop of query.value.properties) {
-                    if (prop.value.type !== "Identifier") {
-                        return false;
-                    }
-                    queries.push(prop.value.name);
+    // get headers
+    for (const call of callExprs) {
+        const isType = call.obj.propertyName === "type" || call.obj.propertyName === "contentType";
+        if (
+            call.obj.propertyName === "header" ||
+            call.obj.propertyName === "setHeader" ||
+            call.obj.propertyName === "set" ||
+            isType
+        ) {
+            // type() is set("content-type", ...) after a media type lookup. set() also takes a
+            // whole object, one pair per set(). setHeader is node's and takes only strings.
+            let pairs;
+            if (isType) {
+                if (call.arguments[0].type !== "Literal") {
+                    return null;
                 }
-            } else {
-                return false;
-            }
-
-            if (param?.value?.type === "Identifier") {
-                paramsName = param.value.name;
-            } else if (param?.value?.type === "ObjectPattern") {
-                for (const prop of param.value.properties) {
-                    if (prop.value.type !== "Identifier") {
-                        return false;
+                pairs = [["content-type", typeValueOf(String(call.arguments[0].value))]];
+            } else if (call.arguments.length === 1 && call.obj.propertyName !== "setHeader") {
+                if (call.arguments[0].type !== "ObjectExpression") {
+                    return null;
+                }
+                pairs = [];
+                for (const property of call.arguments[0].properties) {
+                    const key = literalKeyOf(property);
+                    if (key === null || property.value.type !== "Literal") {
+                        return null;
                     }
-                    params.push(prop.value.name);
+                    pairs.push([key, String(property.value.value)]);
                 }
             } else {
-                return false;
-            }
-        }
-
-        // check if it calls any other function other than the one in `res`
-        const callExprs = filterNodes(fn, (node) => node.type === "CallExpression");
-        const resCalls = [];
-        for (const expr of callExprs) {
-            let calleeName, propertyName;
-
-            // get propertyName
-            if (expr.type === "MemberExpression") {
-                propertyName = expr.property.name;
-            } else if (expr.type === "CallExpression") {
-                propertyName = expr.callee?.property?.name ?? expr.callee?.name;
+                if (call.arguments[0].type !== "Literal" || call.arguments[1]?.type !== "Literal") {
+                    return null;
+                }
+                // String() here: a numeric literal would reach uWS writeHeader as a number,
+                // and uWS refuses anything that is not a string
+                pairs = [[call.arguments[0].value, String(call.arguments[1].value)]];
             }
 
-            // get calleeName
-            switch (expr.callee.type) {
-                case "Identifier":
-                    calleeName = expr.callee.name;
-                    break;
-                case "MemberExpression":
-                    if (expr.callee.object.type === "Identifier") {
-                        calleeName = expr.callee.object.name;
-                    } else if (expr.callee.object.type === "CallExpression") {
-                        // function call chaining
-                        let callee = expr.callee;
-                        while (callee.object.callee) {
-                            callee = callee.object.callee;
-                        }
-                        if (callee.object.type !== "Identifier") {
-                            return false;
+            for (let [header, value] of pairs) {
+                const name = String(header).toLowerCase();
+                // res.set adds a charset to a content-type, res.setHeader does not: setHeader
+                // is node's and node does not know what a media type is
+                if (call.obj.propertyName !== "setHeader" && name === "content-type") {
+                    value = withDefaultCharset(value);
+                }
+                const index = headers.findIndex((entry) => String(entry[0]).toLowerCase() === name);
+                if (index === -1) {
+                    headers.push([header, value]);
+                } else {
+                    // in place, so the header keeps the position it was first given
+                    headers[index][1] = value;
+                    // set replaces the header, so values appended after it go too. Replacing
+                    // only the first left the response carrying both.
+                    for (let i = headers.length - 1; i > index; i--) {
+                        if (String(headers[i][0]).toLowerCase() === name) {
+                            headers.splice(i, 1);
                         }
-                        calleeName = callee.object.name;
                     }
-                    break;
-                default:
-                    return false;
+                }
             }
-            // check if calleeName is res
-            if (calleeName !== res) {
-                return false;
+        } else if (call.obj.propertyName === "append") {
+            if (call.arguments[0].type !== "Literal" || call.arguments[1].type !== "Literal") {
+                return null;
             }
-
-            const obj = { calleeName, propertyName };
-            expr.obj = obj;
-            resCalls.push(obj);
-        }
-
-        // check if res property being called are
-        // - set, header, setHeader
-        // - status
-        // - send
-        // - end
-        for (const call of resCalls) {
-            if (!allowedResMethods.includes(call.propertyName)) {
-                return false;
+            headers.push([call.arguments[0].value, String(call.arguments[1].value)]);
+        } else if (call.obj.propertyName === "sendStatus") {
+            if (call.arguments[0].type !== "Literal") {
+                return null;
             }
+            statusCode = call.arguments[0].value;
+            sendStatusUsed = true;
         }
+    }
+    return { statusCode, sendStatusUsed };
+}
 
-        // In the order the calls run, which for a chain is not the order the tree is walked in:
-        // res.status(201) is a node inside res.status(201).send("k"), so the walk reaches the outer
-        // call first and read res.status(201).status(202) backwards. Ending position orders a chain
-        // and separate statements alike.
-        callExprs.sort((a, b) => a.end - b.end);
-
-        // Nothing after the call that writes the body has any effect, since by then the response
-        // has gone out: res.sendStatus(404) followed by res.set("x-a", "1") sends no x-a on
-        // Express, and res.send("k") followed by res.status(201) is still a 200. Two calls that
-        // each write a body is a mistake rather than a shape worth compiling, and falls back.
-        const terminalIndex = callExprs.findIndex((call) => terminalMethods.has(call.obj.propertyName));
-        if (terminalIndex !== -1) {
-            for (let i = terminalIndex + 1; i < callExprs.length; i++) {
-                if (terminalMethods.has(callExprs[i].obj.propertyName)) {
-                    return false;
-                }
+/**
+ * The body parts the calls write, pushed into `body`, with the content-type decisions they imply
+ * pushed into `headers`. null when one of the calls writes something this cannot read.
+ *
+ * @param {any[]} callExprs the res calls, in run order, as readStatusAndHeaders takes them
+ * @param {[string, string][]} headers the headers read so far, written to
+ * @param {any[]} body the body parts, written to; loose because a literal's value is kept as it is
+ * @param {Application} app the application, for the json settings
+ * @param {string[]} queries names bound by a destructured req.query
+ * @param {string[]} params names bound by a destructured req.params
+ * @returns {{sendUsed: boolean, bodyFromSend: boolean}|null}
+ */
+function readBody(callExprs, headers, body, app, queries, params) {
+    // get body
+    let sendUsed = false;
+    // only send() gets an ETag. end() is node's and never computes one, and the ordinary path
+    // does the same.
+    let bodyFromSend = false;
+    for (const call of callExprs) {
+        if (bodyMethods.has(call.obj.propertyName)) {
+            if (sendUsed) {
+                return null;
             }
-            callExprs.length = terminalIndex + 1;
-        }
-
-        // check if all identifiers are allowed
-        const identifiers = filterNodes(fn, (node) => node.type === "Identifier")
-            .slice(args.length)
-            .map((id) => id.name);
-        if (identifiers[identifiers.length - 1] === "__cb") {
-            identifiers.pop();
-        }
-        if (
-            !identifiers.every(
-                (id, i) =>
-                    allowedIdentifiers.includes(id) ||
-                    id === req ||
-                    id === res ||
-                    (identifiers[i - 2] === req && identifiers[i - 1] === "params") ||
-                    (identifiers[i - 2] === req && identifiers[i - 1] === "query") ||
-                    id === queryName ||
-                    id === paramsName ||
-                    queries.includes(id) ||
-                    params.includes(id)
-            )
-        ) {
-            return false;
-        }
-
-        let statusCode = 200;
-        // sendStatus and a bare send() both leave the body empty, and they mean different things:
-        // one sends the status message, the other sends nothing
-        let sendStatusUsed = false;
-        const headers = [];
-        const body = [];
+            // send() with no argument gets no content-type, same as Express and as the ordinary
+            // path. It was given one here anyway, so the two paths disagreed on `res.send()`.
+            if (call.obj.propertyName !== "end") {
+                bodyFromSend = true;
+            }
+            // one argument at most: res.end(data, encoding) and res.end(data, cb) are shapes a
+            // compiled response cannot stand for, and stood for them as if the extra were not there
+            if (call.arguments.length > 1) {
+                return null;
+            }
+            const arg = call.arguments[0];
 
-        // get statusCode
-        for (const call of callExprs) {
-            if (call.obj.propertyName === "status") {
-                if (call.arguments[0].type !== "Literal") {
-                    return false;
+            if (call.obj.propertyName === "json") {
+                // res.json() with no argument sends no body and no length, a shape left to the
+                // ordinary path
+                if (!arg) {
+                    return null;
                 }
-                statusCode = call.arguments[0].value;
+                // a replacer runs per response on the ordinary path, so a body computed once
+                // could not honour it
+                const replacer = app.get("json replacer");
+                if (typeof replacer !== "undefined" && typeof replacer !== "string") {
+                    return null;
+                }
+                // json sets a type only when none was chosen, then hands a string to send,
+                // which adds the charset to whatever type is there
+                const existing = headers.find((header) => header[0].toLowerCase() === "content-type");
+                if (existing) {
+                    existing[1] = withUtf8Charset(String(existing[1]));
+                } else {
+                    headers.push(["content-type", "application/json; charset=utf-8"]);
+                }
+                body.push({
+                    type: "text",
+                    value: stringify(literalValue(arg), replacer, app.get("json spaces"), app.get("json escape"))
+                });
+                sendUsed = true;
+                continue;
             }
-        }
 
-        // get headers
-        for (const call of callExprs) {
-            const isType = call.obj.propertyName === "type" || call.obj.propertyName === "contentType";
-            if (
-                call.obj.propertyName === "header" ||
-                call.obj.propertyName === "setHeader" ||
-                call.obj.propertyName === "set" ||
-                isType
-            ) {
-                // type() is set("content-type", ...) with the media type looked up first, and
-                // set() takes a whole object as well, which is one set() per pair. setHeader is
-                // node's and throws on anything but a string, so it is not offered the object.
-                let pairs;
-                if (isType) {
-                    if (call.arguments[0].type !== "Literal") {
-                        return false;
+            if (call.obj.propertyName === "send" && arg) {
+                // The body decides the content-type, so this runs before the body is read.
+                // Doing it after made res.set("content-type", "text/plain") + res.send({})
+                // answer application/json, where Express answers text/plain.
+                const isJsonBody =
+                    arg.type === "ObjectExpression" || (arg.type === "Literal" && typeof arg.value === "boolean");
+                const isNullBody = arg.type === "Literal" && arg.value === null;
+                const existing = headers.find((header) => header[0].toLowerCase() === "content-type");
+                if (!existing) {
+                    if (isJsonBody) {
+                        headers.push(["content-type", "application/json; charset=utf-8"]);
+                    } else if (!isNullBody) {
+                        // send(null) sends an empty string and chooses no type, the same as
+                        // the ordinary path
+                        headers.push(["content-type", "text/html; charset=utf-8"]);
                     }
-                    pairs = [["content-type", typeValueOf(String(call.arguments[0].value))]];
-                } else if (call.arguments.length === 1 && call.obj.propertyName !== "setHeader") {
-                    if (call.arguments[0].type !== "ObjectExpression") {
-                        return false;
+                } else {
+                    existing[1] = withUtf8Charset(String(existing[1]));
+                }
+            }
+            if (arg) {
+                if (arg.type === "Literal") {
+                    if (typeof arg.value === "number") {
+                        // status code
+                        return null;
                     }
-                    pairs = [];
-                    for (const property of call.arguments[0].properties) {
-                        const key = literalKeyOf(property);
-                        if (key === null || property.value.type !== "Literal") {
-                            return false;
+                    // the content-type was decided above, from what this argument is
+                    const val = arg.value === null ? "" : arg.value;
+                    body.push({ type: "text", value: val });
+                } else if (arg.type === "TemplateLiteral") {
+                    const exprs = [...arg.quasis, ...arg.expressions].sort((a, b) => a.start - b.start);
+                    for (const expr of exprs) {
+                        if (expr.type === "TemplateElement") {
+                            body.push({ type: "text", value: expr.value.cooked });
+                        } else if (expr.type === "MemberExpression") {
+                            const obj = expr.object;
+                            let type;
+                            if (obj.type === "MemberExpression") {
+                                if (obj.property.type !== "Identifier") {
+                                    return null;
+                                }
+                                type = obj.property.name;
+                            } else if (obj.type === "Identifier") {
+                                type = obj.name;
+                            } else {
+                                return null;
+                            }
+                            if (type !== "params" && type !== "query") {
+                                return null;
+                            }
+                            body.push({ type, value: expr.property.name });
+                        } else if (expr.type === "Identifier") {
+                            if (queries.includes(expr.name)) {
+                                body.push({ type: "query", value: expr.name });
+                            } else if (params.includes(expr.name)) {
+                                body.push({ type: "params", value: expr.name });
+                            } else {
+                                return null;
+                            }
+                        } else {
+                            return null;
                         }
-                        pairs.push([key, String(property.value.value)]);
                     }
-                } else {
-                    if (call.arguments[0].type !== "Literal" || call.arguments[1]?.type !== "Literal") {
-                        return false;
+                } else if (arg.type === "MemberExpression") {
+                    if (!arg.object.property) {
+                        return null;
                     }
-                    // String() at capture: a numeric literal would reach uWS's writeHeader as
-                    // itself, and uWS refuses anything that is not a string
-                    pairs = [[call.arguments[0].value, String(call.arguments[1].value)]];
-                }
-
-                for (let [header, value] of pairs) {
-                    const name = String(header).toLowerCase();
-                    // res.set charsets a content-type and res.setHeader does not, since the second
-                    // is node's and node does not know what a media type is
-                    if (call.obj.propertyName !== "setHeader" && name === "content-type") {
-                        value = withDefaultCharset(value);
+                    if (
+                        arg.object.property.type !== "Identifier" ||
+                        (arg.object.property.name !== "query" && arg.object.property.name !== "params")
+                    ) {
+                        return null;
                     }
-                    const index = headers.findIndex((entry) => String(entry[0]).toLowerCase() === name);
-                    if (index === -1) {
-                        headers.push([header, value]);
-                    } else {
-                        // in place, so the header keeps the position it was first given
-                        headers[index][1] = value;
-                        // set replaces the header outright, so any further value append left there
-                        // goes with it. Replacing only the first left the response carrying both.
-                        for (let i = headers.length - 1; i > index; i--) {
-                            if (String(headers[i][0]).toLowerCase() === name) {
-                                headers.splice(i, 1);
-                            }
+                    body.push({ type: arg.object.property.name, value: arg.property.name });
+                } else if (arg.type === "BinaryExpression") {
+                    const stuff = [];
+                    /**
+                     * Reads a chain of string concatenations right to left. Each side must be a literal or a
+                     * param or query value, anything else makes the whole handler fall back.
+                     *
+                     * @param {any} node a BinaryExpression, read loosely: the literal on either
+                     *   side is kept as it is
+                     * @returns {boolean}
+                     */
+                    function check(node) {
+                        // only "+" concatenates, any other operator computes a value the parts
+                        // cannot hold, so the handler falls back
+                        if (node.operator !== "+") {
+                            return false;
                         }
+                        if (node.right.type === "Literal") {
+                            stuff.push({ type: "text", value: node.right.value });
+                        } else if (node.right.type === "MemberExpression") {
+                            stuff.push({ type: node.right.object.property.name, value: node.right.property.name });
+                        } else return false;
+                        if (node.left.type === "Literal") {
+                            stuff.push({ type: "text", value: node.left.value });
+                        } else if (node.left.type === "MemberExpression") {
+                            stuff.push({ type: node.left.object.property.name, value: node.left.property.name });
+                        } else if (node.left.type === "BinaryExpression") {
+                            return check(node.left);
+                        } else return false;
+
+                        return true;
                     }
-                }
-            } else if (call.obj.propertyName === "append") {
-                if (call.arguments[0].type !== "Literal" || call.arguments[1].type !== "Literal") {
-                    return false;
-                }
-                headers.push([call.arguments[0].value, String(call.arguments[1].value)]);
-            } else if (call.obj.propertyName === "sendStatus") {
-                if (call.arguments[0].type !== "Literal") {
-                    return false;
-                }
-                statusCode = call.arguments[0].value;
-                sendStatusUsed = true;
-            }
-        }
-
-        // get body
-        let sendUsed = false;
-        // only send() earns an ETag. end() is node's, which never computes one, and the ordinary
-        // path here follows that too, so the compiled path has to as well.
-        let bodyFromSend = false;
-        for (const call of callExprs) {
-            if (bodyMethods.has(call.obj.propertyName)) {
-                if (sendUsed) {
-                    return false;
-                }
-                // send() with nothing to send gets no content-type, the same as on the ordinary
-                // path and the same as Express. It was being given one here regardless, so the
-                // two paths disagreed about a route as simple as `res.send()`.
-                if (call.obj.propertyName !== "end") {
-                    bodyFromSend = true;
-                }
-                const arg = call.arguments[0];
-
-                if (call.obj.propertyName === "json") {
-                    // res.json() with nothing to serialise sends no body and no length, which is a
-                    // shape worth leaving to the ordinary path rather than reproducing here
-                    if (!arg) {
-                        return false;
+                    if (!check(arg)) {
+                        return null;
                     }
-                    // a replacer runs per response on the ordinary path, so a body computed once
-                    // could not honour it
+                    body.push(...stuff.reverse());
+                } else if (arg.type === "ObjectExpression") {
+                    if (call.obj.propertyName === "end") {
+                        return null;
+                    }
+                    // a replacer runs per response on the ordinary path, so a body computed
+                    // once could not honour it
                     const replacer = app.get("json replacer");
                     if (typeof replacer !== "undefined" && typeof replacer !== "string") {
-                        return false;
-                    }
-                    // json reaches for a type only when none was chosen, then hands a string to
-                    // send, which is what charsets whatever type is there
-                    const existing = headers.find((header) => header[0].toLowerCase() === "content-type");
-                    if (existing) {
-                        existing[1] = withUtf8Charset(String(existing[1]));
-                    } else {
-                        headers.push(["content-type", "application/json; charset=utf-8"]);
+                        return null;
                     }
+
+                    // the content-type was decided above, from what this argument is
                     body.push({
                         type: "text",
                         value: stringify(literalValue(arg), replacer, app.get("json spaces"), app.get("json escape"))
                     });
-                    sendUsed = true;
-                    continue;
+                } else {
+                    return null;
                 }
+            }
+            sendUsed = true;
+        }
+    }
+    return { sendUsed, bodyFromSend };
+}
+/**
+ * The handler's AST and its parameter names, when it is a shape this compiler can read at all.
+ * null for anything it cannot: a keyword it does not admit, a node type the walk cannot see
+ * through, too few parameters, or a return that is not the last statement.
+ *
+ * @param {Function} cb
+ * @returns {{fn: import("acorn").FunctionDeclaration|import("acorn").ArrowFunctionExpression, args: string[]}|null}
+ */
+function readHandler(cb) {
+    let code = cb.toString();
+    // convert anonymous functions to named ones to make it valid code
+    if (code.startsWith("function") || code.startsWith("async function")) {
+        code = code.replace(/function *\(/, "function __cb(");
+    }
 
-                if (call.obj.propertyName === "send" && arg) {
-                    // What the body is decides which content-type it would be given, so this comes
-                    // before the body is read rather than after. Setting one and then overwriting
-                    // it, which is what happened here, meant res.set("content-type", "text/plain")
-                    // followed by res.send({}) answered application/json where Express answers
-                    // text/plain: send only reaches for a type when none was chosen.
-                    const isJsonBody =
-                        arg.type === "ObjectExpression" || (arg.type === "Literal" && typeof arg.value === "boolean");
-                    const isNullBody = arg.type === "Literal" && arg.value === null;
-                    const existing = headers.find((header) => header[0].toLowerCase() === "content-type");
-                    if (!existing) {
-                        if (isJsonBody) {
-                            headers.push(["content-type", "application/json; charset=utf-8"]);
-                        } else if (!isNullBody) {
-                            // send(null) sends an empty string without choosing a type, the same
-                            // as it does on the ordinary path
-                            headers.push(["content-type", "text/html; charset=utf-8"]);
-                        }
-                    } else {
-                        existing[1] = withUtf8Charset(String(existing[1]));
-                    }
+    // Anything not understood returns false and falls back to ordinary routing. Widening the
+    // list below is not worth it: over the 1113 handlers in tests, demo and benchmark, 42.6%
+    // call something that is not res, `const` would unlock 7 (0.6%), a conditional 0.1% more.
+    /** @type {any[]} the tokens, loose because acorn's Token type leaves out value */
+    const tokens = [...acorn.tokenizer(code, { ecmaVersion: "latest" })];
+
+    if (
+        tokens.some((token) =>
+            [
+                "throw",
+                "new",
+                "await",
+                "try",
+                "catch",
+                "finally",
+                "if",
+                "else",
+                "switch",
+                "case",
+                "default",
+                "for",
+                "while",
+                "do",
+                "var",
+                "let",
+                "const"
+            ].includes(token.value)
+        )
+    ) {
+        return null;
+    }
+
+    /** @type {any[]} the statements, read loosely: what a parameter may be is checked by hand in readParamNames */
+    const parsed = parser.parse(code, { ecmaVersion: "latest" }).body;
+    let fn = parsed[0];
+
+    if (fn.type === "ExpressionStatement") {
+        fn = fn.expression;
+    }
+
+    // check if it is a function
+    if (fn.type !== "FunctionDeclaration" && fn.type !== "ArrowFunctionExpression") {
+        return null;
+    }
+
+    // before reading the tree, because reading is only valid for the shapes the walk can see
+    // through
+    const nodeTypes = new Set();
+    collectNodeTypes(fn, nodeTypes);
+    for (const type of nodeTypes) {
+        if (!understoodNodeTypes.has(type)) {
+            return null;
+        }
+    }
+
+    const args = fn.params.map((param) => param.name);
+
+    if (args.length < 2) {
+        // invalid function? doesn't have (req, res) args
+        return null;
+    }
+
+    // `return res.send(...)` is the same response as `res.send(...)`, but only as the last
+    // statement: every call is read, so a return in the middle would compile dead ones.
+    const returns = filterNodes(fn, (node) => node.type === "ReturnStatement");
+    if (returns.length) {
+        const statements = fn.body.type === "BlockStatement" ? fn.body.body : null;
+        if (!statements || returns.length > 1 || returns[0] !== statements[statements.length - 1]) {
+            return null;
+        }
+    }
+
+    return { fn, args };
+}
+
+/**
+ * What readParamNames found: the two parameter names, and what a destructured req bound.
+ * @typedef {object} ParamNames
+ * @property {string} req
+ * @property {string} res
+ * @property {string|undefined} queryName
+ * @property {string|undefined} paramsName
+ * @property {string[]} queries
+ * @property {string[]} params
+ */
+
+/**
+ * The names a destructured `req` binds for query and params, so the body reader can tell one of
+ * them from an identifier it must refuse. null when the pattern is one this cannot read.
+ *
+ * @param {any} fn the handler's AST, read loosely: a destructured parameter is checked shape by
+ *   shape, and anything else throws into the fallback
+ * @param {string[]} args its parameter names
+ * @returns {ParamNames|null}
+ */
+function readParamNames(fn, args) {
+    const [req, res] = args;
+    let queryName, paramsName;
+    const queries = [],
+        params = [];
+
+    if (fn.params[0].type === "ObjectPattern") {
+        const query = fn.params[0].properties.find((prop) => prop.key.name === "query");
+        const param = fn.params[0].properties.find((prop) => prop.key.name === "params");
+
+        if (query?.value?.type === "Identifier") {
+            queryName = query.value.name;
+        } else if (query?.value?.type === "ObjectPattern") {
+            for (const prop of query.value.properties) {
+                if (prop.value.type !== "Identifier") {
+                    return null;
                 }
-                if (arg) {
-                    if (arg.type === "Literal") {
-                        if (typeof arg.value === "number") {
-                            // status code
-                            return false;
-                        }
-                        // the content-type was decided above, from what this argument is
-                        const val = arg.value === null ? "" : arg.value;
-                        body.push({ type: "text", value: val });
-                    } else if (arg.type === "TemplateLiteral") {
-                        const exprs = [...arg.quasis, ...arg.expressions].sort((a, b) => a.start - b.start);
-                        for (const expr of exprs) {
-                            if (expr.type === "TemplateElement") {
-                                body.push({ type: "text", value: expr.value.cooked });
-                            } else if (expr.type === "MemberExpression") {
-                                const obj = expr.object;
-                                let type;
-                                if (obj.type === "MemberExpression") {
-                                    if (obj.property.type !== "Identifier") {
-                                        return false;
-                                    }
-                                    type = obj.property.name;
-                                } else if (obj.type === "Identifier") {
-                                    type = obj.name;
-                                } else {
-                                    return false;
-                                }
-                                if (type !== "params" && type !== "query") {
-                                    return false;
-                                }
-                                body.push({ type, value: expr.property.name });
-                            } else if (expr.type === "Identifier") {
-                                if (queries.includes(expr.name)) {
-                                    body.push({ type: "query", value: expr.name });
-                                } else if (params.includes(expr.name)) {
-                                    body.push({ type: "params", value: expr.name });
-                                } else {
-                                    return false;
-                                }
-                            } else {
-                                return false;
-                            }
-                        }
-                    } else if (arg.type === "MemberExpression") {
-                        if (!arg.object.property) {
-                            return false;
-                        }
-                        if (
-                            arg.object.property.type !== "Identifier" ||
-                            (arg.object.property.name !== "query" && arg.object.property.name !== "params")
-                        ) {
-                            return false;
-                        }
-                        body.push({ type: arg.object.property.name, value: arg.property.name });
-                    } else if (arg.type === "BinaryExpression") {
-                        const stuff = [];
-                        /**
-                         * Reads a chain of string concatenations right to left, collecting each side as either a
-                         * literal or a param or query value. Returns false for anything else, which is what makes
-                         * the whole handler fall back.
-                         *
-                         * @param {any} node a BinaryExpression
-                         * @returns {boolean}
-                         */
-                        function check(node) {
-                            // only "+" concatenates; any other operator computes a value the
-                            // parts cannot represent, so the handler falls back
-                            if (node.operator !== "+") {
-                                return false;
-                            }
-                            if (node.right.type === "Literal") {
-                                stuff.push({ type: "text", value: node.right.value });
-                            } else if (node.right.type === "MemberExpression") {
-                                stuff.push({ type: node.right.object.property.name, value: node.right.property.name });
-                            } else return false;
-                            if (node.left.type === "Literal") {
-                                stuff.push({ type: "text", value: node.left.value });
-                            } else if (node.left.type === "MemberExpression") {
-                                stuff.push({ type: node.left.object.property.name, value: node.left.property.name });
-                            } else if (node.left.type === "BinaryExpression") {
-                                return check(node.left);
-                            } else return false;
-
-                            return true;
-                        }
-                        if (!check(arg)) {
-                            return false;
-                        }
-                        body.push(...stuff.reverse());
-                    } else if (arg.type === "ObjectExpression") {
-                        if (call.obj.propertyName === "end") {
-                            return false;
-                        }
-                        // a replacer runs per response on the ordinary path, so a body computed
-                        // once could not honour it
-                        const replacer = app.get("json replacer");
-                        if (typeof replacer !== "undefined" && typeof replacer !== "string") {
-                            return false;
-                        }
+                queries.push(prop.value.name);
+            }
+        } else {
+            return null;
+        }
+
+        if (param?.value?.type === "Identifier") {
+            paramsName = param.value.name;
+        } else if (param?.value?.type === "ObjectPattern") {
+            for (const prop of param.value.properties) {
+                if (prop.value.type !== "Identifier") {
+                    return null;
+                }
+                params.push(prop.value.name);
+            }
+        } else {
+            return null;
+        }
+    }
+    return { req, res, queryName, paramsName, queries, params };
+}
 
-                        // the content-type was decided above, from what this argument is
-                        body.push({
-                            type: "text",
-                            value: stringify(
-                                literalValue(arg),
-                                replacer,
-                                app.get("json spaces"),
-                                app.get("json escape")
-                            )
-                        });
-                    } else {
-                        return false;
+/**
+ * Every call the handler makes, in the order they run, cut after the one that writes the body.
+ * null when it calls anything but `res`, or a method a compiled response cannot stand for.
+ *
+ * @param {import("acorn").FunctionDeclaration|import("acorn").ArrowFunctionExpression} fn the handler's AST
+ * @param {string} res the name its second parameter was given
+ * @returns {any[]|null} the call nodes, each carrying what was read off its callee as `obj`; loose
+ *   because the readers take their arguments as whatever literal they hold
+ */
+function readResCalls(fn, res) {
+    // check if it calls any other function other than the one in `res`
+    const callExprs = filterNodes(fn, (node) => node.type === "CallExpression");
+    const resCalls = [];
+    for (const expr of callExprs) {
+        let calleeName, propertyName;
+
+        // get propertyName
+        if (expr.type === "MemberExpression") {
+            propertyName = expr.property.name;
+        } else if (expr.type === "CallExpression") {
+            propertyName = expr.callee?.property?.name ?? expr.callee?.name;
+        }
+
+        // get calleeName
+        switch (expr.callee.type) {
+            case "Identifier":
+                calleeName = expr.callee.name;
+                break;
+            case "MemberExpression":
+                if (expr.callee.object.type === "Identifier") {
+                    calleeName = expr.callee.object.name;
+                } else if (expr.callee.object.type === "CallExpression") {
+                    // function call chaining
+                    let callee = expr.callee;
+                    while (callee.object.callee) {
+                        callee = callee.object.callee;
+                    }
+                    if (callee.object.type !== "Identifier") {
+                        return null;
                     }
+                    calleeName = callee.object.name;
                 }
-                sendUsed = true;
+                break;
+            default:
+                return null;
+        }
+        // check if calleeName is res
+        if (calleeName !== res) {
+            return null;
+        }
+
+        const obj = { calleeName, propertyName };
+        expr.obj = obj;
+        resCalls.push(obj);
+    }
+
+    // check if res property being called are
+    // - set, header, setHeader
+    // - status
+    // - send
+    // - end
+    for (const call of resCalls) {
+        if (!allowedResMethods.includes(call.propertyName)) {
+            return null;
+        }
+    }
+
+    // Sorted in run order. In a chain the walk reaches the outer call first, so
+    // res.status(201).status(202) was read backwards. End position orders both cases.
+    callExprs.sort((a, b) => a.end - b.end);
+
+    // Nothing after the body call has any effect: on Express res.send("k") then
+    // res.status(201) is still a 200. Two calls that both write a body fall back.
+    const terminalIndex = callExprs.findIndex((call) => terminalMethods.has(call.obj.propertyName));
+    if (terminalIndex !== -1) {
+        for (let i = terminalIndex + 1; i < callExprs.length; i++) {
+            if (terminalMethods.has(callExprs[i].obj.propertyName)) {
+                return null;
             }
         }
+        callExprs.length = terminalIndex + 1;
+    }
+    return callExprs;
+}
+
+/**
+ * Whether every identifier in the handler is one a compiled response can stand for.
+ *
+ * @param {import("acorn").FunctionDeclaration|import("acorn").ArrowFunctionExpression} fn the handler's AST
+ * @param {string[]} args its parameter names
+ * @param {ParamNames} names what a destructured req bound, from readParamNames
+ * @returns {boolean}
+ */
+function identifiersAllowed(fn, args, names) {
+    const { req, res, queryName, paramsName, queries, params } = names;
+    const identifiers = filterNodes(fn, (node) => node.type === "Identifier")
+        .slice(args.length)
+        .map((id) => id.name);
+    if (identifiers[identifiers.length - 1] === "__cb") {
+        identifiers.pop();
+    }
+    return identifiers.every(
+        (id, i) =>
+            allowedIdentifiers.includes(id) ||
+            id === req ||
+            id === res ||
+            (identifiers[i - 2] === req && identifiers[i - 1] === "params") ||
+            (identifiers[i - 2] === req && identifiers[i - 1] === "query") ||
+            id === queryName ||
+            id === paramsName ||
+            queries.includes(id) ||
+            params.includes(id)
+    );
+}
+// uWS allows creating such responses and they are extremely fast
+// since you don't even have to call into Node.js at all
+// declarative response will only be created if callback is 'simple enough'
+// simple enough means:
+// - doesnt call external functions
+// - doesnt create variables
+// - only uses req.query and req.params
+// basically, its only simple, static responses
+module.exports = function compileDeclarative(cb, app) {
+    try {
+        const handler = readHandler(cb);
+        if (handler === null) {
+            return false;
+        }
+        const { fn, args } = handler;
+
+        const names = readParamNames(fn, args);
+        if (names === null) {
+            return false;
+        }
+        const { res, queries, params } = names;
+
+        const callExprs = readResCalls(fn, res);
+        if (callExprs === null) {
+            return false;
+        }
+
+        if (!identifiersAllowed(fn, args, names)) {
+            return false;
+        }
+
+        const headers = [];
+        const body = [];
+
+        const status = readStatusAndHeaders(callExprs, headers);
+        if (status === null) {
+            return false;
+        }
+        const { statusCode, sendStatusUsed } = status;
+
+        const read = readBody(callExprs, headers, body, app, queries, params);
+        if (read === null) {
+            return false;
+        }
+        const { sendUsed, bodyFromSend } = read;
 
-        // a handler that never sends is not a response: Express leaves the request waiting, so
-        // compiling the empty shape would answer a bare 200 where the ordinary path answers
-        // nothing at all. It has to fall back instead.
+        // a handler that never sends is not a response: Express leaves the request waiting, so this
+        // has to fall back instead of answering a bare 200
         if (!sendUsed && !sendStatusUsed) {
             return false;
         }
 
-        // A status that carries no content. Compiled, the body went out with it, and a client
-        // frames these as bodiless whatever the headers say, so those bytes were read as the start
-        // of the next answer on the connection. The ordinary path already writes all three the way
-        // express does.
+        // A status that carries no content. Compiled, the body went out anyway, and a client frames
+        // these as bodiless, so those bytes were read as the start of the next answer.
         if (BODILESS_STATUSES.has(statusCode) || statusCode < 200) {
             return false;
         }
@@ -729,22 +810,21 @@ module.exports = function compileDeclarative(cb, app) {
             const statusMessage = statuses.message[statusCode] ?? "unknown";
             decRes = decRes.writeStatus(`${statusCode} ${statusMessage}`);
         }
-        // only sendStatus types its body: it goes through res.type("txt") on the ordinary path,
-        // while status(n).end() sends no Content-Type at all, in Express and here alike
+        // only sendStatus types its body, through res.type("txt"). status(n).end() sends no
+        // Content-Type at all, in Express and here
         if (sendStatusUsed && !headers.some((header) => header[0].toLowerCase() === "content-type")) {
             decRes = decRes.writeHeader("content-type", "text/plain; charset=utf-8");
         }
 
         // the same two the ordinary path seeds every response with. Without them a route answered
-        // different headers depending only on whether it happened to be compilable, which is worse
-        // than either choice on its own, and a client had no idle timeout to go on.
+        // different headers only because it was compilable, and a client had no idle timeout.
         const advertise = app.get("connection headers") !== false;
         const connection = headers.find((header) => header[0].toLowerCase() === "connection");
         if (!connection && advertise) {
             decRes = decRes.writeHeader("connection", "keep-alive");
         }
-        // not on a connection the handler is closing: Keep-Alive describes one that is staying
-        // open, and the ordinary path leaves it out for the same reason
+        // not when the handler is closing: Keep-Alive describes a connection that stays open, and
+        // the ordinary path leaves it out for the same reason
         const closing = typeof connection?.[1] === "string" && connection[1].toLowerCase() === "close";
         if (advertise && !closing && !headers.some((header) => header[0].toLowerCase() === "keep-alive")) {
             decRes = decRes.writeHeader("keep-alive", "timeout=10");
@@ -755,42 +835,35 @@ module.exports = function compileDeclarative(cb, app) {
             if (name === "content-length") {
                 return false;
             }
-            // lowercased as the ordinary path stores every name, so the two paths answer the
-            // same bytes whatever casing the handler wrote, see issue #7
+            // lowercased like the ordinary path stores them, so both paths answer the same bytes
+            // whatever casing the handler wrote, see issue #7
             decRes = decRes.writeHeader(name, header[1]);
         }
 
-        // sendStatus sends the status message as its body. It has to join `body` here, before the
-        // ETag is computed, and not at write time: computing the ETag over an empty body gave every
-        // sendStatus response the same one, so a cache could not tell a 404 from a 500 and a
-        // conditional request could be answered 304 with the wrong body entirely.
+        // sendStatus sends the status message as body, and it has to join `body` before the ETag:
+        // over an empty body every sendStatus response got the same ETag.
         if (sendStatusUsed && !body.length) {
             body.push({ type: "text", value: statuses.message[statusCode] || String(statusCode) });
         }
 
-        // A response that would carry a validator is not compiled at all: µWS answers it without
-        // reading the request, so it could never turn a conditional GET into the 304 the validator
-        // invites. Dropping the ETag instead would leave the simplest routes of an application
-        // without one, so `etag` false is how a route stays compiled.
+        // A response carrying a validator is not compiled: uWS answers without reading the request,
+        // so it could never turn a conditional GET into a 304. Use `etag` false to stay compiled.
         if (headers.some((header) => VALIDATOR_HEADERS.has(header[0].toLowerCase()))) {
             return false;
         }
-        // an empty body gets no ETag, in Express and on the ordinary path here, so it has nothing
-        // to lose by being compiled
+        // an empty body gets no ETag in Express either, so it loses nothing by being compiled
         if (body.length && (bodyFromSend || sendStatusUsed) && app.get("etag")) {
             return false;
         }
 
-        // No Content-Length header here: uWS writes the framing itself, and a response carrying
-        // both is invalid. Which framing it writes is decided at the end of this function.
+        // No Content-Length here: uWS writes the framing itself and a response with both is
+        // invalid. Which framing it writes is decided at the end of this function.
         if (app.get("x-powered-by")) {
             decRes = decRes.writeHeader("x-powered-by", "Fulmine");
         }
 
-        // A body that is literal all the way through goes out as one end(), which is what makes
-        // uWS frame it with a Content-Length, as Express does. A part interpolated from the
-        // request has no length until the request arrives, so those stay a write each and uWS
-        // chunks them.
+        // A fully literal body goes out as one end(), so uWS frames it with a Content-Length like
+        // Express. A part taken from the request has no length yet, so those are chunked writes.
         const literal = body.every((part) => part.type === "text")
             ? body.map((part) => String(part.value)).join("")
             : null;
@@ -815,14 +888,13 @@ module.exports = function compileDeclarative(cb, app) {
 };
 
 /**
- * Every node in the tree matching the predicate, in the order the named edges below are followed.
- * The edges are written out rather than discovered, which is why compileDeclarative first refuses
- * any node type that is not on the understood list: a shape this walk cannot see through would
- * otherwise be compiled as though it were empty.
+ * Every node matching the predicate, in the order of the named edges below. The edges are written
+ * by hand, which is why compileDeclarative first refuses any node type not on the understood list.
  *
- * @param {any} node
- * @param {(node: any) => boolean} fn
- * @returns {any[]}
+ * @param {any} node an acorn node, walked along the named edges below, so nothing is assumed
+ *   about its shape
+ * @param {(node: import("acorn").AnyNode) => boolean} fn
+ * @returns {any[]} the matching nodes, as loose as the input
  */
 function filterNodes(node, fn) {
     const filtered = [];
@@ -887,9 +959,8 @@ function filterNodes(node, fn) {
         }
     }
 
-    // singular, and not the list above: it is what a return statement returns, and what a unary
-    // operator applies to. Without it `return res.send("x")` looked like a body with no calls in
-    // it at all, which would have compiled into an empty response.
+    // singular, not the list above: what a return statement returns and what a unary operator
+    // applies to. Without it `return res.send("x")` looked like a body with no calls in it.
     if (node.argument) {
         filtered.push(...filterNodes(node.argument, fn));
     }