Template string expression statement leading with object literal gives incorrect emit

[DanielRosenwasser]

Something like

`${ { hello: 10; world: 20 } }HELLO`

will get emitted as

{ hello: 10; world: 20 } + "HELLO"

As an expresssion statement, the former evaluates to "[object Object]HELLO" while the latter evaluates to NaN.

This is because the former gets parsed as:

// block body
{
    hello: 10;
    world: 20;
};
"HELLO";

[DanielRosenwasser]

Note this also applies to arrow functions, function expressions, and class expressions.

[weswigham]

Interestingly, we also output extra parenthesis when doing a destructuring assignment within a template expression:

let x,y;
`${ {x,y} = {x: 2, y: 3} }HELLO`

emits as:

var x, y;
((_a = { x: 2, y: 3 }, x = _a.x, y = _a.y, _a)) + "HELLO";
var _a;

Additionally, the declaration of the temporary variable is placed after the expression - there's nothing expressly wrong with that, but it seems like bad form.

[DanielRosenwasser]

I might have a fix for this, so let's leave it assigned to me for now.

[anirudhrb]

Is this still open? If yes, I would like to attempt a fix. :)

[kitsonk]

It doesn't appear to be.

`${{ hello: 10, world: 20 }}HELLO`;

...emits...

({ hello: 10, world: 20 } + "HELLO");

Both result in the same string of:

[object Object]HELLO

So ultimately this issue should be closed as the ES6+ behaviour matches the down-emit behaviour.

[j-oliveras]

@DanielRosenwasser This can be closed, is solved since minimum September 2017.

`${{ hello: 10, world: 20 }}HELLO`;

`${() => 0}HELLO`;

`${function () { }}HELLO`;

`${class a { }}HELLO`;

is compiled to (comments are the result running it on firefox console):

({ hello: 10, world: 20 } + "HELLO"); // [object Object]HELLO

(function () { return 0; } + "HELLO"); // function () { return 0; }HELLO

(function () { } + "HELLO"); // function () { }HELLO

/** @class */ (function () {
    function a() {
    }
    return a;
}()) + "HELLO"; /* function a() {
    }HELLO */