Normative: Re-resolve unresolvable references on the global in PutValue.

[syg]

Currently, JSC, V8, SM, and XS all do not throw on the following code,
contra spec:

"use strict";
undeclared = (this.undeclared = 42);

This has been a bug in implementations for a decade
(https://bugzilla.mozilla.org/show_bug.cgi?id=605515), and is arguably
implementation reality not only for the web but for most
implementations.

This changes the spec to match the implemented re-resolution behavior.

Also see

• Reference type and implementation reality #467
• Add a test for "undeclared = (this.undeclared = 5);" in global scope test262#1964

[ExE-Boss]

I’d prefer if this were Annex B‑only, since the this binding is module.exports in CommonJS and undefined in ES Modules.

[devsnek]

Would it make you feel better if the example code was x = (globalThis.x = 42)

[Jack-Works]

I’d prefer if this were Annex B‑only, since the this binding is module.exports in CommonJS and undefined in ES Modules.

I agree but we have eval

[syg]

This needs more investigation.

@erights brought up in plenary that we should prefer late resolution over re-resolution, even if the observability point is [[HasProperty]], which I agree with. Further, we should endeavor to have consistent late resolution behavior across with scopes, global objects, and global lexical scopes, since in all three cases we are able to inject a binding in the RHS.

For with, something like this:

foo = "global";
let scopeObj = { };
with (scopeObj) {
  foo = (scopeObj.foo = "with1", "with2");
}
print(scopeObj.foo);
print(globalThis.foo);

Currently engines disagree:

#### jsc
with1
with2

#### sm
with1
with2

#### v8
with2
global

[syg]

For the global lexical environment, I haven't crafted this yet but it should be possible to do so by injecting a <script> via document.write that introduces the new global lexical binding, then awaiting a Promise that doesn't get resolved until the injected script finishes executing.

[rkirsling]

It seems like the with case might just be a V8 bug, but is this what you were envisioning for the global lexical environment one?

foo = 1;

var resolve;
new Promise((r) => { resolve = r }).then(() => {
  foo = (globalThis.foo = 3, 4);
  console.log(foo, globalThis.foo);
});

document.write(`<script>let foo = 2; resolve();</script>`);

Safari, Chrome, and FF all print 4 and 3 here.

[bathos]

@rkirsling I’m not 100% sure but I thought @syg was describing a scenario where a lexical binding can become declared during RHS eval where the LHS was unresolvable (not a global object env binding interaction) — i.e. ScriptEvaluation being entered in the RHS via document.write.

[nicolo-ribaudo]

A test for global lexical bindings (i.e. converting @bathos's words to code):

let foo2 = foo = (document.write(`<script>let foo = 2</script>`), 4);
console.log(foo, foo2) 

Firefox and Safari log 2, 4, Chrome logs 4, 4.

[syg]

let foo2 = foo = (document.write(`<script>let foo = 2</script>`), 4);

Quel cursed!

[syg]

So there is indeed a spec compliance bug in V8 for the with scope case, for which I filed this issue. That might be the same root cause as #2205 (comment), but I'm not sure yet.