combining static and #private member and super() with target esnext and bundling leads to broken output

[fwienber]

Trying to bundle a class containing a static member, a #private member and a super() call in the constructor using target esnext generates code that causes a run-time error, as it tries to use this before the super() call, which is not allowed in ECMAScript.

This very simple example class

export class Foo extends Object {
    static FOO;

    constructor() {
        super();
    }
    #foo;
}

generates code that contains the following constructor:

constructor() {
    __privateAdd(this, _foo, void 0);
    super();
  }

Live demo of the bug

The first thing to notice is that the ESNext syntax is lowered, although target is esnext. This only happens when bundling and may be the same issue as #1480.

When setting target to es2020, the code is still lowered, but now the order of super() and initializing the private field is correct:

  constructor() {
    super();
    __privateAdd(this, _foo, void 0);
  }

Live demo with target es2020

Since our code base uses this combination of features frequently, it is quite a show-stopper for us for switching from WebPack to esbuild.

[evanw]

Thanks for the report. This case doesn't appear to have test coverage yet. I can reproduce the issue, and I have found the cause. I will fix this in the next release.

[bakura10]

Hi @evanw .

I tried on the latest version but esbuild still seems to lower the syntax when a private static is used:

// Not lowered:
class Foo {
  #test;
}

// #test is lowered:
class Foo {
  static #bar;
  #test;
}

Was this PR supposed to cover this? :)

[bakura10]

Actually, after testing again, the fix of 0.14.34 seems to not longer work even with non private static method.

This:

export class Test {
  #foo = 5;
}

is transformed to:

// js/foo.js
var Test = class {
  #foo = 5;
};
export {
  Test
};

While this:

export class Test {
  static bar = 1;
  #foo = 5;
}

Is transformed to:

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};
var __privateAdd = (obj, member, value) => {
  if (member.has(obj))
    throw TypeError("Cannot add the same private member more than once");
  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};

// js/foo.js
var _foo;
var Test = class {
  constructor() {
    __privateAdd(this, _foo, 5);
  }
};
_foo = new WeakMap();
__publicField(Test, "bar", 1);
export {
  Test
};

Should I re-open a new issue for that @evanw ?