Broken codegen of class with decorated method when using jsc.module.lazy

[paul-soporan]

Describe the bug

Edit: I've used module as an example of an external module below, but I've now realized that it might be confused with the module Node builtin. The issue exists no matter what name the external module has.

Codegen breaks when all of the conditions below are met:

• jsc.module.type has to be set to commonjs.
• jsc.module.lazy has to be set to true.
• A base class has to be imported from an external module.
• Another class has to extend the base class.
• The subclass has to have a decorated method, decorated with a decorator that is a static property on the base class.

Input code

import { Class } from 'module';

class MyClass extends Class {
  @Class.Decorator()
  async method() {}
}

Config

{
  "jsc": {
    "parser": {
      "syntax": "typescript",
      "decorators": true
    },
    "target": "es2020",
    "transform": {
      "legacyDecorator": true
    }
  },
  "module": {
    "type": "commonjs",
    "lazy": true
  }
}

Emitted code

"use strict";
var _module = require("module");
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
    var desc = {
    };
    Object.keys(descriptor).forEach(function(key) {
        desc[key] = descriptor[key];
    });
    desc.enumerable = !!desc.enumerable;
    desc.configurable = !!desc.configurable;
    if ("value" in desc || desc.initializer) {
        desc.writable = true;
    }
    desc = decorators.slice().reverse().reduce(function(desc, decorator) {
        return decorator(target, property, desc) || desc;
    }, desc);
    if (context && desc.initializer !== void 0) {
        desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
        desc.initializer = undefined;
    }
    if (desc.initializer === void 0) {
        Object.defineProperty(target, property, desc);
        desc = null;
    }
    return desc;
}
var _class, _dec;
let MyClass = ((_class = function() {
    class MyClass extends _module().Class {
        async method() {
        }
    }
    return MyClass;
}()) || _class, _dec = _module.Class.Decorator(), _applyDecoratedDescriptor(_class.prototype, "method", [
    _dec
], Object.getOwnPropertyDescriptor(_class.prototype, "method"), _class.prototype), _class);

Expected behavior

The emitted code includes class MyClass extends _module().Class. Note the _module() call, which shouldn't happen, as _module is assigned the required module which isn't callable. This leads to a runtime error (TypeError: _module is not a function).

Version
The version of @swc/core: 1.2.35

Additional context

This issue doesn't exist when jsc.module.lazy is set to false.

[kdy1]

As you used Class unconditionally, I think it should be

class MyClass extends _module.Class {
    async method() {
    }
}

[paul-soporan]

Yep, that's how it should be. It's correctly emitted as _module.Class when jsc.module.lazy is set to false (the default), but it becomes _module().Class when jsc.module.lazy is set to true.

That also happens to be the only difference between the outputs (diff lazy.js non-lazy.js):

29c29
<     class MyClass extends _module().Class {
---
>     class MyClass extends _module.Class {

[swc-bot]

This closed issue has been automatically locked because it had no new activity for a month. If you are running into a similar issue, please create a new issue with the steps to reproduce. Thank you.