What should occur where the code is


```

const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be
"y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be
"y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)),
...doStuff()]); // should x be "y" here?

const y = 1;

```


?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```

const x = nameof y

const y = 1;

```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simple because ```nameof```
is used?

On Sat, Jun 15, 2019 at 11:16 PM Ron Buckton <Ron.Buckton at microsoft.com>
wrote:

> ```
>
> const x = nameof y
>
> const y = 1;
>
> ```
>
>
>
> `x` would have the value “y”. It would not matter if `y` were initialized
> or had yet been reached during execution. It does not deviate from the
> purpose of `let` or `const`, because you are not accessing the *value* of
> the identifier.
>
>
>
> Also consider that this is legal ECMAScript in a module:
>
>
>
> ```
>
> export { y }
>
> const y = 1;
>
> ```
>
>
>
> The binding for `y` exists within the same block scope, it just has not
> yet been initialized. Exporting it via `export { y }`, closing over it via
> `() => y`, or accessing it via `nameof y` would all be the same. In all
> three cases you are accessing the **binding** of `y`, not the **value**
> of `y`. Even in the `() => y` case, you don’t access the **value** of `y`
> until you execute the function.
>
>
>
> *From:* guest271314 <guest271314 at gmail.com>
> *Sent:* Saturday, June 15, 2019 3:57 PM
> *To:* Ron Buckton <Ron.Buckton at microsoft.com>
> *Cc:* es-discuss at mozilla.org
> *Subject:* Re: Re: What do you think about a C# 6 like nameof()
> expression for
>
>
>
> > Sorry, I meant to say “not entirely correct”.
>
>
>
> You have not yet confirmed if in fact the expected output is referencing a
> variable declared using ```const``` on the current line _before_
> initialization _on the next line_.
>
>
>
> That example appears to deviate from the purpose and usage of ```const```,
> beyond the scope of ```nameof```, and if were implemented, a
> ```ReferenceError``` should _not_ be thrown when a ```const``` variable
> that has yet to be initialized _on the next line_ is referred to _on the
> current line_?
>
>
>
> Aside from that example, the code which essentially already implements
> ```nameof``` should be able to be found in the code which implements
> ```ReferenceError``` relevant to ```const```.
>
>
>
> On Sat, Jun 15, 2019 at 10:47 PM Ron Buckton <Ron.Buckton at microsoft.com>
> wrote:
>
> Sorry, I meant to say “not entirely correct”.
>
>
>
> *From:* Ron Buckton
> *Sent:* Saturday, June 15, 2019 3:03 PM
> *To:* guest271314 <guest271314 at gmail.com>
> *Cc:* es-discuss at mozilla.org
> *Subject:* RE: Re: What do you think about a C# 6 like nameof()
> expression for
>
>
>
> > At that point in the example code the identifer ```y``` does not exist.
>
>
>
> That is not entirely incorrect. The identifier `y` exists, but its binding
> has not been initialized, otherwise you couldn’t refer to y in this case:
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190615/e0035a13/attachment.html>

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and line where y is initialized is not reached?
do {
  await stuff()
} while (1);

const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling to check if ```y``` is initialized or not using ```try..catch``` and ```ReferenceError```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to indicaate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and line where y is initialized is not reached?
do {
  await stuff()
} while (1);

const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling (e.g., using `requestAnimationFrame`) if ```y``` was initialized or not using ```try..catch``` and ```ReferenceError```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to indicaate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?

do {
  await stuff()
} while (1);

const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling (e.g., using `requestAnimationFrame`) if ```y``` was initialized or not using ```try..catch``` and ```ReferenceError```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to indicaate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?
const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling (e.g., using `requestAnimationFrame`) if ```y``` was initialized or not using ```try..catch``` and ```ReferenceError```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to indicaate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?
const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling (e.g., using `requestAnimationFrame`) if ```y``` was initialized or not using ```try..catch``` and ```ReferenceError```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?
const y = 1;
```


?

In the above example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling (e.g., using `requestAnimationFrame`) if ```y``` was initialized or not using ```try..catch```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?
const y = 1;
```


?

In the abbove example code, if ```y``` is declared as a JavaScript plain object, could not the _value_ of ```y``` be (arbitrarily) mutated by the above code initiated _before_ the actual initialization by polling if ```y``` was initialized or not using ```try..catch```?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

// what happens where errors are thrown in the code above and the next line is not reached?

const y = 1;
```


?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

const y = 1;
```


?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simply because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?

What should occur where the code is


```
const x = nameof y

await new Promise(resolve => setTimeout(resolve, 100000)); // should x be "y" here?

await new Promise(resolve => setTimeout(resolve, 200000)); // should x be "y" here?

await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)), ...doStuff()]); // should x be "y" here?

const y = 1;
```


?


The immediately invoked arrow function example (where a
```RefeferenceError``` is thrown) appears to demonstrate that to output the
expected result of ```nameof``` within the context of the code example


```
const x = nameof y

const y = 1;
```


is a proposal for _more_ than only getting the _name_ of an _declared_ and
_initialized_ variable?


Should a ```RefefenceError``` _not_ be thrown simple because ```nameof```
is used in this case 

```
const f = (() => nameof y)(); // ReferenceError: can't access lexical declaration `y' before initialization
let y = 1;
```

?