Yes, because those don't capture any lexicals, so they're hoisted as usual.

My solution would only stop hoisting closures that capture lexicals, with the idea that capturing a lexical means that the closure's identity is now tied to that lexical environment anyway so it's kind of bizarre to hoist it out to where part of its identity is missing.

But you were giving a simplified example, so I want to be sure I'm not dismissing your concern unfairly. This would not work:

    function f() {
        return g(); // ReferenceError
    }
    let x = 4;
    function g() {
        return x + f();
    }

Hm... you raise a good point, though. Should this work?:

    let x = 4;
    function f() {
        return x + g(); // ReferenceError? Unfortunate if so...
    }
    function g() {
        return x - f();
    }

perhaps the proposal needs to be modified: instead of not hoisting lexical closures (functions that close over lexicals) at all, hoist them to the nearest lexical scope containing everything they close over. So the above would work, but this would still be an error:

    let x = f(); // ReferenceError
    let y = 2;
    function f() {
        return y;
    }

Not that I'm proposing anything at all, this is all wishful thinking. Though I've wondered if there could be a way to opt-in to this somehow, something like:

    let x = 4;
    let function f() {
        return x + g();
    }
    let function g() {
        return x - f();
    }

(or `const function`, I suppose, but I don't know if there's a useful distinction.) Then these lexical functions would never need to consider the case where they capture uninitialized bindings. But that's kind of weird, in that `let f = () => { ... };` looks similar to `let function f() { ... }` but the former would still have to hoist. Bleagh. Oh well.