From 454874a42d9997771545233b957b72bbc92ae328 Mon Sep 17 00:00:00 2001
From: Radu Baston <65868820+radu2147@users.noreply.github.com>
Date: Thu, 10 Oct 2024 22:17:29 +0300
Subject: [PATCH 01/24] feat(linter): Implement `react/iframe-missing-sandbox`
 (#6383)

https://github.com/oxc-project/oxc/issues/1022

---------

Co-authored-by: Don Isaac <donald.isaac@gmail.com>
---
 crates/oxc_linter/src/rules.rs                |   2 +
 .../src/rules/react/iframe_missing_sandbox.rs | 233 ++++++++++++++++++
 .../src/snapshots/iframe_missing_sandbox.snap |  93 +++++++
 3 files changed, 328 insertions(+)
 create mode 100644 crates/oxc_linter/src/rules/react/iframe_missing_sandbox.rs
 create mode 100644 crates/oxc_linter/src/snapshots/iframe_missing_sandbox.snap

diff --git a/crates/oxc_linter/src/rules.rs b/crates/oxc_linter/src/rules.rs
index a347787b1b0d1..ffe855e5f884f 100644
--- a/crates/oxc_linter/src/rules.rs
+++ b/crates/oxc_linter/src/rules.rs
@@ -234,6 +234,7 @@ mod jest {
 mod react {
     pub mod button_has_type;
     pub mod checked_requires_onchange_or_readonly;
+    pub mod iframe_missing_sandbox;
     pub mod jsx_boolean_value;
     pub mod jsx_curly_brace_presence;
     pub mod jsx_key;
@@ -771,6 +772,7 @@ oxc_macros::declare_all_lint_rules! {
     promise::valid_params,
     react::button_has_type,
     react::checked_requires_onchange_or_readonly,
+    react::iframe_missing_sandbox,
     react::jsx_boolean_value,
     react::jsx_curly_brace_presence,
     react::jsx_key,
diff --git a/crates/oxc_linter/src/rules/react/iframe_missing_sandbox.rs b/crates/oxc_linter/src/rules/react/iframe_missing_sandbox.rs
new file mode 100644
index 0000000000000..0fcd3f4300beb
--- /dev/null
+++ b/crates/oxc_linter/src/rules/react/iframe_missing_sandbox.rs
@@ -0,0 +1,233 @@
+use oxc_ast::ast::{
+    Argument, Expression, JSXAttributeItem, JSXAttributeValue, JSXElementName, ObjectProperty,
+    ObjectPropertyKind, StringLiteral,
+};
+use oxc_ast::AstKind;
+use oxc_diagnostics::OxcDiagnostic;
+use oxc_macros::declare_oxc_lint;
+use oxc_span::Span;
+use phf::{phf_set, Set};
+
+use crate::utils::{get_prop_value, has_jsx_prop_ignore_case, is_create_element_call};
+use crate::{context::LintContext, rule::Rule, AstNode};
+
+fn missing_sandbox_prop(span: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warn("An iframe element is missing a sandbox attribute")
+        .with_help("Add a `sandbox` attribute to the `iframe` element.")
+        .with_label(span)
+}
+
+fn invalid_sandbox_prop(span: Span, value: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warn(format!("An iframe element defines a sandbox attribute with invalid value: {value}"))
+        .with_help("Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.")
+        .with_label(span)
+}
+
+fn invalid_sandbox_combination_prop(span: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warn("An `iframe` element defines a sandbox attribute with both allow-scripts and allow-same-origin which is invalid")
+        .with_help("Remove `allow-scripts` or `allow-same-origin`.")
+        .with_label(span)
+}
+
+const ALLOWED_VALUES: Set<&'static str> = phf_set! {
+    "",
+    "allow-downloads-without-user-activation",
+    "allow-downloads",
+    "allow-forms",
+    "allow-modals",
+    "allow-orientation-lock",
+    "allow-pointer-lock",
+    "allow-popups",
+    "allow-popups-to-escape-sandbox",
+    "allow-presentation",
+    "allow-same-origin",
+    "allow-scripts",
+    "allow-storage-access-by-user-activation",
+    "allow-top-navigation",
+    "allow-top-navigation-by-user-activation"
+};
+
+#[derive(Debug, Default, Clone)]
+pub struct IframeMissingSandbox;
+
+declare_oxc_lint!(
+    /// ### What it does
+    ///
+    /// Enforce sandbox attribute on iframe elements
+    ///
+    /// ### Why is this bad?
+    ///
+    /// The sandbox attribute enables an extra set of restrictions for the content in the iframe. Using sandbox attribute is considered a good security practice.
+    /// To learn more about sandboxing, see [MDN's documentation on the `sandbox` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox).
+
+    ///
+    /// This rule checks all React `<iframe>` elements and verifies that there is `sandbox` attribute and that it's value is valid. In addition to that it also reports cases where attribute contains `allow-scripts` and `allow-same-origin` at the same time as this combination allows the embedded document to remove the sandbox attribute and bypass the restrictions.
+
+    /// ### Examples
+    ///
+    /// Examples of **incorrect** code for this rule:
+    /// ```jsx
+    /// <iframe/>;
+    /// <iframe sandbox="invalid-value" />;
+    /// <iframe sandbox="allow-same-origin allow-scripts"/>;
+    /// ```
+    ///
+    /// Examples of **correct** code for this rule:
+    /// ```jsx
+    /// <iframe sandbox="" />;
+    /// <iframe sandbox="allow-origin" />;
+    /// ```
+    IframeMissingSandbox,
+    correctness,
+    pending
+);
+
+impl Rule for IframeMissingSandbox {
+    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+        match node.kind() {
+            AstKind::JSXOpeningElement(jsx_el) => {
+                let JSXElementName::Identifier(identifier) = &jsx_el.name else {
+                    return;
+                };
+
+                if identifier.name != "iframe" {
+                    return;
+                }
+
+                has_jsx_prop_ignore_case(jsx_el, "sandbox").map_or_else(
+                    || {
+                        ctx.diagnostic(missing_sandbox_prop(identifier.span));
+                    },
+                    |sandbox_prop| {
+                        validate_sandbox_attribute(sandbox_prop, ctx);
+                    },
+                );
+            }
+            AstKind::CallExpression(call_expr) => {
+                if is_create_element_call(call_expr) {
+                    let Some(Argument::StringLiteral(str)) = call_expr.arguments.first() else {
+                        return;
+                    };
+
+                    if str.value != "iframe" {
+                        return;
+                    }
+
+                    if let Some(Argument::ObjectExpression(obj_expr)) = call_expr.arguments.get(1) {
+                        obj_expr
+                            .properties
+                            .iter()
+                            .find_map(|prop| {
+                                if let ObjectPropertyKind::ObjectProperty(prop) = prop {
+                                    if prop.key.is_specific_static_name("sandbox") {
+                                        return Some(prop);
+                                    }
+                                }
+
+                                None
+                            })
+                            .map_or_else(
+                                || {
+                                    ctx.diagnostic(missing_sandbox_prop(obj_expr.span));
+                                },
+                                |sandbox_prop| {
+                                    validate_sandbox_property(sandbox_prop, ctx);
+                                },
+                            );
+                    } else {
+                        ctx.diagnostic(missing_sandbox_prop(call_expr.span));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+}
+fn validate_sandbox_value(literal: &StringLiteral, ctx: &LintContext) {
+    let attrs = literal.value.split(' ');
+    let mut has_allow_same_origin = false;
+    let mut has_allow_scripts = false;
+    for trimmed_atr in attrs.into_iter().map(str::trim) {
+        if !ALLOWED_VALUES.contains(trimmed_atr) {
+            ctx.diagnostic(invalid_sandbox_prop(literal.span, trimmed_atr));
+        }
+        if trimmed_atr == "allow-scripts" {
+            has_allow_scripts = true;
+        }
+        if trimmed_atr == "allow-same-origin" {
+            has_allow_same_origin = true;
+        }
+    }
+    if has_allow_scripts && has_allow_same_origin {
+        ctx.diagnostic(invalid_sandbox_combination_prop(literal.span));
+    }
+}
+
+fn validate_sandbox_property(object_property: &ObjectProperty, ctx: &LintContext) {
+    if let Expression::StringLiteral(str) = object_property.value.without_parentheses() {
+        validate_sandbox_value(str, ctx);
+    }
+}
+fn validate_sandbox_attribute(jsx_el: &JSXAttributeItem, ctx: &LintContext) {
+    if let Some(JSXAttributeValue::StringLiteral(str)) = get_prop_value(jsx_el) {
+        validate_sandbox_value(str, ctx);
+    }
+}
+
+#[test]
+fn test() {
+    use crate::tester::Tester;
+
+    let pass = vec![
+        r#"<div sandbox="__unknown__" />;"#,
+        r#"<iframe sandbox="" />;"#,
+        r#"<iframe sandbox={""} />"#,
+        r#"React.createElement("iframe", { sandbox: "" });"#,
+        r#"<iframe src="foo.htm" sandbox></iframe>"#,
+        r#"React.createElement("iframe", { src: "foo.htm", sandbox: true })"#,
+        r#"<iframe src="foo.htm" sandbox sandbox></iframe>"#,
+        r#"<iframe sandbox="allow-forms"></iframe>"#,
+        r#"<iframe sandbox="allow-modals"></iframe>"#,
+        r#"<iframe sandbox="allow-orientation-lock"></iframe>"#,
+        r#"<iframe sandbox="allow-pointer-lock"></iframe>"#,
+        r#"<iframe sandbox="allow-popups"></iframe>"#,
+        r#"<iframe sandbox="allow-popups-to-escape-sandbox"></iframe>"#,
+        r#"<iframe sandbox="allow-presentation"></iframe>"#,
+        r#"<iframe sandbox="allow-same-origin"></iframe>"#,
+        r#"<iframe sandbox="allow-scripts"></iframe>"#,
+        r#"<iframe sandbox="allow-top-navigation"></iframe>"#,
+        r#"<iframe sandbox="allow-top-navigation-by-user-activation"></iframe>"#,
+        r#"<iframe sandbox="allow-forms allow-modals"></iframe>"#,
+        r#"<iframe sandbox="allow-popups allow-popups-to-escape-sandbox allow-pointer-lock allow-same-origin allow-top-navigation"></iframe>"#,
+        r#"React.createElement("iframe", { sandbox: "allow-forms" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-modals" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-orientation-lock" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-pointer-lock" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-popups" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-popups-to-escape-sandbox" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-presentation" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-same-origin" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-scripts" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-top-navigation" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-top-navigation-by-user-activation" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-forms allow-modals" })"#,
+        r#"React.createElement("iframe", { sandbox: "allow-popups allow-popups-to-escape-sandbox allow-pointer-lock allow-same-origin allow-top-navigation" })"#,
+    ];
+
+    let fail = vec![
+        "<iframe></iframe>;",
+        "<iframe/>;",
+        r#"React.createElement("iframe");"#,
+        r#"React.createElement("iframe", {});"#,
+        r#"React.createElement("iframe", null);"#,
+        r#"<iframe sandbox="__unknown__"></iframe>"#,
+        r#"React.createElement("iframe", { sandbox: "__unknown__" })"#,
+        r#"<iframe sandbox="allow-popups __unknown__"/>"#,
+        r#"<iframe sandbox="__unknown__ allow-popups"/>"#,
+        r#"<iframe sandbox=" allow-forms __unknown__ allow-popups __unknown__  "/>"#,
+        r#"<iframe sandbox="allow-scripts allow-same-origin"></iframe>;"#,
+        r#"<iframe sandbox="allow-same-origin allow-scripts"/>;"#,
+    ];
+
+    Tester::new(IframeMissingSandbox::NAME, pass, fail).test_and_snapshot();
+}
diff --git a/crates/oxc_linter/src/snapshots/iframe_missing_sandbox.snap b/crates/oxc_linter/src/snapshots/iframe_missing_sandbox.snap
new file mode 100644
index 0000000000000..5020fd10abae0
--- /dev/null
+++ b/crates/oxc_linter/src/snapshots/iframe_missing_sandbox.snap
@@ -0,0 +1,93 @@
+---
+source: crates/oxc_linter/src/tester.rs
+---
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element is missing a sandbox attribute
+   ╭─[iframe_missing_sandbox.tsx:1:2]
+ 1 │ <iframe></iframe>;
+   ·  ──────
+   ╰────
+  help: Add a `sandbox` attribute to the `iframe` element.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element is missing a sandbox attribute
+   ╭─[iframe_missing_sandbox.tsx:1:2]
+ 1 │ <iframe/>;
+   ·  ──────
+   ╰────
+  help: Add a `sandbox` attribute to the `iframe` element.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element is missing a sandbox attribute
+   ╭─[iframe_missing_sandbox.tsx:1:1]
+ 1 │ React.createElement("iframe");
+   · ─────────────────────────────
+   ╰────
+  help: Add a `sandbox` attribute to the `iframe` element.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element is missing a sandbox attribute
+   ╭─[iframe_missing_sandbox.tsx:1:31]
+ 1 │ React.createElement("iframe", {});
+   ·                               ──
+   ╰────
+  help: Add a `sandbox` attribute to the `iframe` element.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element is missing a sandbox attribute
+   ╭─[iframe_missing_sandbox.tsx:1:1]
+ 1 │ React.createElement("iframe", null);
+   · ───────────────────────────────────
+   ╰────
+  help: Add a `sandbox` attribute to the `iframe` element.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox="__unknown__"></iframe>
+   ·                 ─────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:42]
+ 1 │ React.createElement("iframe", { sandbox: "__unknown__" })
+   ·                                          ─────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox="allow-popups __unknown__"/>
+   ·                 ──────────────────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox="__unknown__ allow-popups"/>
+   ·                 ──────────────────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox=" allow-forms __unknown__ allow-popups __unknown__  "/>
+   ·                 ─────────────────────────────────────────────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An iframe element defines a sandbox attribute with invalid value: __unknown__
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox=" allow-forms __unknown__ allow-popups __unknown__  "/>
+   ·                 ─────────────────────────────────────────────────────
+   ╰────
+  help: Check this link for the valid values of `sandbox` attribute: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An `iframe` element defines a sandbox attribute with both allow-scripts and allow-same-origin which is invalid
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox="allow-scripts allow-same-origin"></iframe>;
+   ·                 ─────────────────────────────────
+   ╰────
+  help: Remove `allow-scripts` or `allow-same-origin`.
+
+  ⚠ eslint-plugin-react(iframe-missing-sandbox): An `iframe` element defines a sandbox attribute with both allow-scripts and allow-same-origin which is invalid
+   ╭─[iframe_missing_sandbox.tsx:1:17]
+ 1 │ <iframe sandbox="allow-same-origin allow-scripts"/>;
+   ·                 ─────────────────────────────────
+   ╰────
+  help: Remove `allow-scripts` or `allow-same-origin`.

From 80266d85c9e192ebf91ef0e2c687b6f769d0b8b2 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Thu, 10 Oct 2024 19:21:50 +0000
Subject: [PATCH 02/24] feat(linter)!: support plugins in oxlint config files
 (#6088)

> Closes #5046
This PR migrates the linter crate and oxlint app to use the new `LinterBuilder` API. This PR has the following effects:

1. `plugins` in oxlint config files are now supported
2. irons out weirdness when using CLI args and config files together. CLI args are now always applied on top of config file settings, overriding them.

# Breaking Changes
Before, config files would override rules set in CLI arguments. For example, running this command:
```sh
oxlint -A correctness -c oxlintrc.json
```
With this config file
```jsonc
// oxlintrc.json
{
  "rules": {
    "no-const-assign": "error"
  }
}
```
Would result in a single rule, `no-const-assign` being turned on at an error level with all other rules disabled (i.e. set to "allow").

Now, **CLI arguments will override config files**. That same command with the same config file will result with **all rules being disabled**.

## Details

For a more in-depth explanation, assume we are running the below command using the `oxlintrc.json` file above:
```sh
oxlint -A all -W correctness -A all -W suspicious -c oxlintrc.json
```

### Before
> Note: GitHub doesn't seem to like deeply nested lists. Apologies for the formatting.

Here was the config resolution process _before_ this PR:
<details><summary>Before Steps</summary>

1. Start with a default set of filters (["correctness", "warn"]) if no filters were passed to the CLI. Since some were, the filter list starts out empty.
2. Apply each filter taken from the CLI from left to right. When a filter allows a rule or category, it clears the configured set of rules. So applying those filters looks like this
  a. start with an empty list `[]`
  b. `("all", "allow")` -> `[]`
  c. `("correctness", "warn")` -> `[ <correctness rules> ]`
  d. `("all", "allow")` -> `[]`
  e. `("suspicious", "warn")` -> `[ <suspicious rules> ]`. This is the final rule set for this step
3. Apply overrides from `oxlintrc.json`. This is where things get a little funky, as mentioned in point 2 of what this PR does. At this point, all rules in the rules list are only from the CLI.
  a. If a rule is only set in the CLI and is not present in the config file, there's no effect
  b. If a rule is in the config file but not the CLI, it gets inserted into the list.
  c. If a rule is already in the list and in the config file
    i. If the rule is only present once (e.g. `"no-loss-of-precision": "error"`), unconditionally override whatever was in the CLI with what was set in the config file
    ii. If the rule is present twice (e.g. `"no-loss-of-precision": "off", "@typescript-eslint/no-loss-of-precision": "error"`),
      a. if all rules in the config file are set to `allow`, then turn the rule off
      b. If one of them is `warn` or `deny`, then update the currently-set rule's config object, but _leave its severity alone_.

  So, for our example, the final rule set would be `[<all suspicious rules: "warn">, no-const-assign: "error"]`

</details>

### After
Rule filters were completely re-worked in a previous PR. Now, lint filters aren't kept on hand-only the rule list is.

<details><summary>After Steps</summary>

1. Start with the default rule set, which is all correctness rules for all enabled plugins (`[<all correctness rules: "warn">]`)
2. Apply configuration from `oxlintrc.json` _first_.
  a. If the rule is warn/deny exists in the list already, update its severity and config object. If it's not in the list, add it.
  b. If the rule is set to allow, remove it from the list.

  The list is now `[<all correctness rules except no-const-assign: "warn">, no-const-assign: "error"]`.

3. Apply each filter taken from the CLI from left to right. This works the same way as before. So, after they're applied, the list is now `[<suspicous rules: "warn">]`

</details>
---
 apps/oxlint/fixtures/import/.oxlintrc.json    |   7 +
 apps/oxlint/fixtures/import/test.js           |   9 +
 .../fixtures/typescript_eslint/eslintrc.json  |   2 +
 apps/oxlint/src/command/lint.rs               | 199 +++++++++++++++---
 apps/oxlint/src/lint/mod.rs                   |  64 +++---
 crates/oxc_linter/src/config/env.rs           |   1 +
 crates/oxc_linter/src/config/oxlintrc.rs      |  45 ++++
 crates/oxc_linter/src/config/rules.rs         |   2 +
 .../oxc_linter/src/config/settings/jsdoc.rs   |   2 +
 .../src/config/settings/jsx_a11y.rs           |   1 +
 crates/oxc_linter/src/config/settings/mod.rs  |   1 +
 crates/oxc_linter/src/config/settings/next.rs |   1 +
 .../oxc_linter/src/config/settings/react.rs   |   2 +
 crates/oxc_linter/src/lib.rs                  |   4 +-
 crates/oxc_linter/src/options/plugins.rs      |  39 +++-
 tasks/benchmark/benches/linter.rs             |  19 +-
 16 files changed, 317 insertions(+), 81 deletions(-)
 create mode 100644 apps/oxlint/fixtures/import/.oxlintrc.json
 create mode 100644 apps/oxlint/fixtures/import/test.js

diff --git a/apps/oxlint/fixtures/import/.oxlintrc.json b/apps/oxlint/fixtures/import/.oxlintrc.json
new file mode 100644
index 0000000000000..fc645f90991be
--- /dev/null
+++ b/apps/oxlint/fixtures/import/.oxlintrc.json
@@ -0,0 +1,7 @@
+{
+    "plugins": ["import"],
+    "rules": {
+        "import/no-default-export": "error",
+        "import/namespace": "allow"
+    }
+}
diff --git a/apps/oxlint/fixtures/import/test.js b/apps/oxlint/fixtures/import/test.js
new file mode 100644
index 0000000000000..68f0e20a25e7e
--- /dev/null
+++ b/apps/oxlint/fixtures/import/test.js
@@ -0,0 +1,9 @@
+import * as foo from './foo';
+// ^ import/namespace
+
+console.log(foo);
+
+// import/no-default-export
+export default function foo() {}
+
+
diff --git a/apps/oxlint/fixtures/typescript_eslint/eslintrc.json b/apps/oxlint/fixtures/typescript_eslint/eslintrc.json
index c7773313f7cd0..2920935a9110c 100644
--- a/apps/oxlint/fixtures/typescript_eslint/eslintrc.json
+++ b/apps/oxlint/fixtures/typescript_eslint/eslintrc.json
@@ -1,4 +1,6 @@
 {
+  // NOTE: enabled by default
+  "plugins": ["@typescript-eslint"],
   "rules": {
     "no-loss-of-precision": "off",
     "@typescript-eslint/no-loss-of-precision": "error",
diff --git a/apps/oxlint/src/command/lint.rs b/apps/oxlint/src/command/lint.rs
index b4e7bfcf4981b..f404714428505 100644
--- a/apps/oxlint/src/command/lint.rs
+++ b/apps/oxlint/src/command/lint.rs
@@ -1,7 +1,7 @@
 use std::{path::PathBuf, str::FromStr};
 
 use bpaf::Bpaf;
-use oxc_linter::{AllowWarnDeny, FixKind};
+use oxc_linter::{AllowWarnDeny, FixKind, LintPlugins};
 
 use super::{
     expand_glob,
@@ -211,64 +211,203 @@ impl FromStr for OutputFormat {
 
 /// Enable Plugins
 #[allow(clippy::struct_field_names)]
-#[derive(Debug, Clone, Bpaf)]
+#[derive(Debug, Default, Clone, Bpaf)]
 pub struct EnablePlugins {
     /// Disable react plugin, which is turned on by default
-    #[bpaf(long("disable-react-plugin"), flag(false, true), hide_usage)]
-    pub react_plugin: bool,
+    #[bpaf(
+        long("disable-react-plugin"),
+        flag(OverrideToggle::Disable, OverrideToggle::NotSet),
+        hide_usage
+    )]
+    pub react_plugin: OverrideToggle,
 
     /// Disable unicorn plugin, which is turned on by default
-    #[bpaf(long("disable-unicorn-plugin"), flag(false, true), hide_usage)]
-    pub unicorn_plugin: bool,
+    #[bpaf(
+        long("disable-unicorn-plugin"),
+        flag(OverrideToggle::Disable, OverrideToggle::NotSet),
+        hide_usage
+    )]
+    pub unicorn_plugin: OverrideToggle,
 
     /// Disable oxc unique rules, which is turned on by default
-    #[bpaf(long("disable-oxc-plugin"), flag(false, true), hide_usage)]
-    pub oxc_plugin: bool,
+    #[bpaf(
+        long("disable-oxc-plugin"),
+        flag(OverrideToggle::Disable, OverrideToggle::NotSet),
+        hide_usage
+    )]
+    pub oxc_plugin: OverrideToggle,
 
     /// Disable TypeScript plugin, which is turned on by default
-    #[bpaf(long("disable-typescript-plugin"), flag(false, true), hide_usage)]
-    pub typescript_plugin: bool,
+    #[bpaf(
+        long("disable-typescript-plugin"),
+        flag(OverrideToggle::Disable, OverrideToggle::NotSet),
+        hide_usage
+    )]
+    pub typescript_plugin: OverrideToggle,
 
     /// Enable the experimental import plugin and detect ESM problems.
     /// It is recommended to use along side with the `--tsconfig` option.
-    #[bpaf(switch, hide_usage)]
-    pub import_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub import_plugin: OverrideToggle,
 
     /// Enable the experimental jsdoc plugin and detect JSDoc problems
-    #[bpaf(switch, hide_usage)]
-    pub jsdoc_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub jsdoc_plugin: OverrideToggle,
 
     /// Enable the Jest plugin and detect test problems
-    #[bpaf(switch, hide_usage)]
-    pub jest_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub jest_plugin: OverrideToggle,
 
     /// Enable the Vitest plugin and detect test problems
-    #[bpaf(switch, hide_usage)]
-    pub vitest_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub vitest_plugin: OverrideToggle,
 
     /// Enable the JSX-a11y plugin and detect accessibility problems
-    #[bpaf(switch, hide_usage)]
-    pub jsx_a11y_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub jsx_a11y_plugin: OverrideToggle,
 
     /// Enable the Next.js plugin and detect Next.js problems
-    #[bpaf(switch, hide_usage)]
-    pub nextjs_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub nextjs_plugin: OverrideToggle,
 
     /// Enable the React performance plugin and detect rendering performance problems
-    #[bpaf(switch, hide_usage)]
-    pub react_perf_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub react_perf_plugin: OverrideToggle,
 
     /// Enable the promise plugin and detect promise usage problems
-    #[bpaf(switch, hide_usage)]
-    pub promise_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub promise_plugin: OverrideToggle,
 
     /// Enable the node plugin and detect node usage problems
-    #[bpaf(switch, hide_usage)]
-    pub node_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub node_plugin: OverrideToggle,
 
     /// Enable the security plugin and detect security problems
-    #[bpaf(switch, hide_usage)]
-    pub security_plugin: bool,
+    #[bpaf(flag(OverrideToggle::Enable, OverrideToggle::NotSet), hide_usage)]
+    pub security_plugin: OverrideToggle,
+}
+
+/// Enables or disables a boolean option, or leaves it unset.
+///
+/// We want CLI flags to modify whatever's set in the user's config file, but we don't want them
+/// changing default behavior if they're not explicitly passed by the user. This scheme is a bit
+/// convoluted, but needed due to architectural constraints imposed by `bpaf`.
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+#[allow(clippy::enum_variant_names)]
+pub enum OverrideToggle {
+    /// Override the option to enabled
+    Enable,
+    /// Override the option to disabled
+    Disable,
+    /// Do not override.
+    #[default]
+    NotSet,
+}
+
+impl From<Option<bool>> for OverrideToggle {
+    fn from(value: Option<bool>) -> Self {
+        match value {
+            Some(true) => Self::Enable,
+            Some(false) => Self::Disable,
+            None => Self::NotSet,
+        }
+    }
+}
+
+impl From<OverrideToggle> for Option<bool> {
+    fn from(value: OverrideToggle) -> Self {
+        match value {
+            OverrideToggle::Enable => Some(true),
+            OverrideToggle::Disable => Some(false),
+            OverrideToggle::NotSet => None,
+        }
+    }
+}
+
+impl OverrideToggle {
+    #[inline]
+    pub fn is_enabled(self) -> bool {
+        matches!(self, Self::Enable)
+    }
+
+    #[inline]
+    pub fn is_not_set(self) -> bool {
+        matches!(self, Self::NotSet)
+    }
+
+    pub fn inspect<F>(self, f: F)
+    where
+        F: FnOnce(bool),
+    {
+        if let Some(v) = self.into() {
+            f(v);
+        }
+    }
+}
+
+impl EnablePlugins {
+    pub fn apply_overrides(&self, plugins: &mut LintPlugins) {
+        self.react_plugin.inspect(|yes| plugins.set(LintPlugins::REACT, yes));
+        self.unicorn_plugin.inspect(|yes| plugins.set(LintPlugins::UNICORN, yes));
+        self.oxc_plugin.inspect(|yes| plugins.set(LintPlugins::OXC, yes));
+        self.typescript_plugin.inspect(|yes| plugins.set(LintPlugins::TYPESCRIPT, yes));
+        self.import_plugin.inspect(|yes| plugins.set(LintPlugins::IMPORT, yes));
+        self.jsdoc_plugin.inspect(|yes| plugins.set(LintPlugins::JSDOC, yes));
+        self.jest_plugin.inspect(|yes| plugins.set(LintPlugins::JEST, yes));
+        self.vitest_plugin.inspect(|yes| plugins.set(LintPlugins::VITEST, yes));
+        self.jsx_a11y_plugin.inspect(|yes| plugins.set(LintPlugins::JSX_A11Y, yes));
+        self.nextjs_plugin.inspect(|yes| plugins.set(LintPlugins::NEXTJS, yes));
+        self.react_perf_plugin.inspect(|yes| plugins.set(LintPlugins::REACT_PERF, yes));
+        self.promise_plugin.inspect(|yes| plugins.set(LintPlugins::PROMISE, yes));
+        self.node_plugin.inspect(|yes| plugins.set(LintPlugins::NODE, yes));
+        self.security_plugin.inspect(|yes| plugins.set(LintPlugins::SECURITY, yes));
+
+        // Without this, jest plugins adapted to vitest will not be enabled.
+        if self.vitest_plugin.is_enabled() && self.jest_plugin.is_not_set() {
+            plugins.set(LintPlugins::JEST, true);
+        }
+    }
+}
+
+#[cfg(test)]
+mod plugins {
+    use super::{EnablePlugins, OverrideToggle};
+    use oxc_linter::LintPlugins;
+
+    #[test]
+    fn test_override_default() {
+        let mut plugins = LintPlugins::default();
+        let enable = EnablePlugins::default();
+
+        enable.apply_overrides(&mut plugins);
+        assert_eq!(plugins, LintPlugins::default());
+    }
+
+    #[test]
+    fn test_overrides() {
+        let mut plugins = LintPlugins::default();
+        let enable = EnablePlugins {
+            react_plugin: OverrideToggle::Enable,
+            unicorn_plugin: OverrideToggle::Disable,
+            ..EnablePlugins::default()
+        };
+        let expected =
+            LintPlugins::default().union(LintPlugins::REACT).difference(LintPlugins::UNICORN);
+
+        enable.apply_overrides(&mut plugins);
+        assert_eq!(plugins, expected);
+    }
+
+    #[test]
+    fn test_override_vitest() {
+        let mut plugins = LintPlugins::default();
+        let enable =
+            EnablePlugins { vitest_plugin: OverrideToggle::Enable, ..EnablePlugins::default() };
+        let expected = LintPlugins::default() | LintPlugins::VITEST | LintPlugins::JEST;
+
+        enable.apply_overrides(&mut plugins);
+        assert_eq!(plugins, expected);
+    }
 }
 
 #[cfg(test)]
diff --git a/apps/oxlint/src/lint/mod.rs b/apps/oxlint/src/lint/mod.rs
index abbd0ed9a73ad..918b6c806f22a 100644
--- a/apps/oxlint/src/lint/mod.rs
+++ b/apps/oxlint/src/lint/mod.rs
@@ -4,7 +4,7 @@ use ignore::gitignore::Gitignore;
 use oxc_diagnostics::{DiagnosticService, GraphicalReportHandler};
 use oxc_linter::{
     loader::LINT_PARTIAL_LOADER_EXT, AllowWarnDeny, InvalidFilterKind, LintFilter, LintService,
-    LintServiceOptions, Linter, OxlintOptions,
+    LintServiceOptions, Linter, LinterBuilder, Oxlintrc,
 };
 use oxc_span::VALID_EXTENSIONS;
 
@@ -98,39 +98,32 @@ impl Runner for LintRunner {
         let number_of_files = paths.len();
 
         let cwd = std::env::current_dir().unwrap();
-        let mut options =
-            LintServiceOptions::new(cwd, paths).with_cross_module(enable_plugins.import_plugin);
-        let lint_options = OxlintOptions::default()
-            .with_filter(filter)
-            .with_config_path(basic_options.config)
-            .with_fix(fix_options.fix_kind())
-            .with_react_plugin(enable_plugins.react_plugin)
-            .with_unicorn_plugin(enable_plugins.unicorn_plugin)
-            .with_typescript_plugin(enable_plugins.typescript_plugin)
-            .with_oxc_plugin(enable_plugins.oxc_plugin)
-            .with_import_plugin(enable_plugins.import_plugin)
-            .with_jsdoc_plugin(enable_plugins.jsdoc_plugin)
-            .with_jest_plugin(enable_plugins.jest_plugin)
-            .with_vitest_plugin(enable_plugins.vitest_plugin)
-            .with_jsx_a11y_plugin(enable_plugins.jsx_a11y_plugin)
-            .with_nextjs_plugin(enable_plugins.nextjs_plugin)
-            .with_react_perf_plugin(enable_plugins.react_perf_plugin)
-            .with_promise_plugin(enable_plugins.promise_plugin)
-            .with_node_plugin(enable_plugins.node_plugin)
-            .with_security_plugin(enable_plugins.security_plugin);
-
-        let linter = match Linter::from_options(lint_options) {
-            Ok(lint_service) => lint_service,
-            Err(diagnostic) => {
-                let handler = GraphicalReportHandler::new();
-                let mut err = String::new();
-                handler.render_report(&mut err, diagnostic.as_ref()).unwrap();
-                return CliRunResult::InvalidOptions {
-                    message: format!("Failed to parse configuration file.\n{err}"),
-                };
+
+        let mut oxlintrc = if let Some(config_path) = basic_options.config.as_ref() {
+            match Oxlintrc::from_file(config_path) {
+                Ok(config) => config,
+                Err(diagnostic) => {
+                    let handler = GraphicalReportHandler::new();
+                    let mut err = String::new();
+                    handler.render_report(&mut err, &diagnostic).unwrap();
+                    return CliRunResult::InvalidOptions {
+                        message: format!("Failed to parse configuration file.\n{err}"),
+                    };
+                }
             }
+        } else {
+            Oxlintrc::default()
         };
 
+        enable_plugins.apply_overrides(&mut oxlintrc.plugins);
+        let builder = LinterBuilder::from_oxlintrc(false, oxlintrc)
+            .with_filters(filter)
+            .with_fix(fix_options.fix_kind());
+
+        let mut options =
+            LintServiceOptions::new(cwd, paths).with_cross_module(builder.plugins().has_import());
+        let linter = builder.build();
+
         let tsconfig = basic_options.tsconfig;
         if let Some(path) = tsconfig.as_ref() {
             if path.is_file() {
@@ -562,4 +555,13 @@ mod test {
         assert_eq!(result.number_of_files, 1);
         assert_eq!(result.number_of_errors, 1);
     }
+
+    #[test]
+    fn test_import_plugin_enabled_in_config() {
+        let args = &["-c", "fixtures/import/.oxlintrc.json", "fixtures/import/test.js"];
+        let result = test(args);
+        assert_eq!(result.number_of_files, 1);
+        assert_eq!(result.number_of_warnings, 0);
+        assert_eq!(result.number_of_errors, 1);
+    }
 }
diff --git a/crates/oxc_linter/src/config/env.rs b/crates/oxc_linter/src/config/env.rs
index 8649a01590fa8..9f11447315421 100644
--- a/crates/oxc_linter/src/config/env.rs
+++ b/crates/oxc_linter/src/config/env.rs
@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 /// environments](https://eslint.org/docs/v8.x/use/configure/language-options#specifying-environments)
 /// for what environments are available and what each one provides.
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OxlintEnv(FxHashMap<String, bool>);
 
 impl OxlintEnv {
diff --git a/crates/oxc_linter/src/config/oxlintrc.rs b/crates/oxc_linter/src/config/oxlintrc.rs
index 437ca80fb3497..e9754cebcd7d3 100644
--- a/crates/oxc_linter/src/config/oxlintrc.rs
+++ b/crates/oxc_linter/src/config/oxlintrc.rs
@@ -94,3 +94,48 @@ impl Oxlintrc {
         Ok(config)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_oxlintrc_de_empty() {
+        let config: Oxlintrc = serde_json::from_value(json!({})).unwrap();
+        assert_eq!(config.plugins, LintPlugins::default());
+        assert_eq!(config.rules, OxlintRules::default());
+        assert!(config.rules.is_empty());
+        assert_eq!(config.settings, OxlintSettings::default());
+        assert_eq!(config.env, OxlintEnv::default());
+    }
+
+    #[test]
+    fn test_oxlintrc_de_plugins_empty_array() {
+        let config: Oxlintrc = serde_json::from_value(json!({ "plugins": [] })).unwrap();
+        assert_eq!(config.plugins, LintPlugins::default());
+    }
+
+    #[test]
+    fn test_oxlintrc_de_plugins_enabled_by_default() {
+        // NOTE(@DonIsaac): creating a Value with `json!` then deserializing it with serde_json::from_value
+        // Errs with "invalid type: string \"eslint\", expected a borrowed string" and I can't
+        // figure out why. This seems to work. Why???
+        let configs = [
+            r#"{ "plugins": ["eslint"] }"#,
+            r#"{ "plugins": ["oxc"] }"#,
+            r#"{ "plugins": ["deepscan"] }"#, // alias for oxc
+        ];
+        // ^ these plugins are enabled by default already
+        for oxlintrc in configs {
+            let config: Oxlintrc = serde_json::from_str(oxlintrc).unwrap();
+            assert_eq!(config.plugins, LintPlugins::default());
+        }
+    }
+
+    #[test]
+    fn test_oxlintrc_de_plugins_new() {
+        let config: Oxlintrc = serde_json::from_str(r#"{ "plugins": ["import"] }"#).unwrap();
+        assert_eq!(config.plugins, LintPlugins::default().union(LintPlugins::IMPORT));
+    }
+}
diff --git a/crates/oxc_linter/src/config/rules.rs b/crates/oxc_linter/src/config/rules.rs
index a53792f3fd435..3c17880247879 100644
--- a/crates/oxc_linter/src/config/rules.rs
+++ b/crates/oxc_linter/src/config/rules.rs
@@ -23,9 +23,11 @@ type RuleSet = FxHashSet<RuleWithSeverity>;
 // <https://github.com/eslint/eslint/blob/ce838adc3b673e52a151f36da0eedf5876977514/lib/shared/types.js#L12>
 // Note: when update document comment, also update `DummyRuleMap`'s description in this file.
 #[derive(Debug, Clone, Default)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OxlintRules(Vec<ESLintRule>);
 
 #[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct ESLintRule {
     pub plugin_name: String,
     pub rule_name: String,
diff --git a/crates/oxc_linter/src/config/settings/jsdoc.rs b/crates/oxc_linter/src/config/settings/jsdoc.rs
index 2f581897cb409..e7bf9d284f742 100644
--- a/crates/oxc_linter/src/config/settings/jsdoc.rs
+++ b/crates/oxc_linter/src/config/settings/jsdoc.rs
@@ -8,6 +8,7 @@ use crate::utils::default_true;
 
 // <https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/settings.md>
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct JSDocPluginSettings {
     /// For all rules but NOT apply to `check-access` and `empty-tags` rule
     #[serde(default, rename = "ignorePrivate")]
@@ -181,6 +182,7 @@ impl JSDocPluginSettings {
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(untagged)]
 enum TagNamePreference {
     TagNameOnly(String),
diff --git a/crates/oxc_linter/src/config/settings/jsx_a11y.rs b/crates/oxc_linter/src/config/settings/jsx_a11y.rs
index e6c73f7e3f686..11b823ee38957 100644
--- a/crates/oxc_linter/src/config/settings/jsx_a11y.rs
+++ b/crates/oxc_linter/src/config/settings/jsx_a11y.rs
@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 
 // <https://github.com/jsx-eslint/eslint-plugin-jsx-a11y#configurations>
 #[derive(Debug, Deserialize, Default, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct JSXA11yPluginSettings {
     #[serde(rename = "polymorphicPropName")]
     pub polymorphic_prop_name: Option<CompactStr>,
diff --git a/crates/oxc_linter/src/config/settings/mod.rs b/crates/oxc_linter/src/config/settings/mod.rs
index 10bfc1d8fd8eb..4a496bc9b554c 100644
--- a/crates/oxc_linter/src/config/settings/mod.rs
+++ b/crates/oxc_linter/src/config/settings/mod.rs
@@ -13,6 +13,7 @@ use self::{
 
 /// Shared settings for plugins
 #[derive(Debug, Deserialize, Serialize, Default, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OxlintSettings {
     #[serde(default)]
     #[serde(rename = "jsx-a11y")]
diff --git a/crates/oxc_linter/src/config/settings/next.rs b/crates/oxc_linter/src/config/settings/next.rs
index 8246e3fc14503..4f289641531af 100644
--- a/crates/oxc_linter/src/config/settings/next.rs
+++ b/crates/oxc_linter/src/config/settings/next.rs
@@ -4,6 +4,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize, Serializer};
 
 #[derive(Debug, Deserialize, Default, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct NextPluginSettings {
     #[serde(default)]
     #[serde(rename = "rootDir")]
diff --git a/crates/oxc_linter/src/config/settings/react.rs b/crates/oxc_linter/src/config/settings/react.rs
index 40b0219bd43e3..9cd913dea0fcf 100644
--- a/crates/oxc_linter/src/config/settings/react.rs
+++ b/crates/oxc_linter/src/config/settings/react.rs
@@ -6,6 +6,7 @@ use serde::{Deserialize, Serialize};
 
 // <https://github.com/jsx-eslint/eslint-plugin-react#configuration-legacy-eslintrc->
 #[derive(Debug, Deserialize, Default, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct ReactPluginSettings {
     #[serde(default)]
     #[serde(rename = "formComponents")]
@@ -31,6 +32,7 @@ impl ReactPluginSettings {
 // Deserialize helper types
 
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(untagged)]
 enum CustomComponent {
     NameOnly(CompactStr),
diff --git a/crates/oxc_linter/src/lib.rs b/crates/oxc_linter/src/lib.rs
index b75e629d59ba2..fec6cb9de306a 100644
--- a/crates/oxc_linter/src/lib.rs
+++ b/crates/oxc_linter/src/lib.rs
@@ -35,7 +35,9 @@ pub use crate::{
     context::LintContext,
     fixer::FixKind,
     frameworks::FrameworkFlags,
-    options::{AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind, OxlintOptions},
+    options::{
+        AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind, LintPlugins, OxlintOptions,
+    },
     rule::{RuleCategory, RuleFixMeta, RuleMeta, RuleWithSeverity},
     service::{LintService, LintServiceOptions},
 };
diff --git a/crates/oxc_linter/src/options/plugins.rs b/crates/oxc_linter/src/options/plugins.rs
index d991a9f50e8f0..f06d9e4e86a3f 100644
--- a/crates/oxc_linter/src/options/plugins.rs
+++ b/crates/oxc_linter/src/options/plugins.rs
@@ -1,6 +1,10 @@
 use bitflags::bitflags;
 use schemars::{gen::SchemaGenerator, schema::Schema, JsonSchema};
-use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
+use serde::{
+    de::{self, Deserializer},
+    ser::Serializer,
+    Deserialize, Serialize,
+};
 
 bitflags! {
     // NOTE: may be increased to a u32 if needed
@@ -151,7 +155,38 @@ impl<S: AsRef<str>> FromIterator<S> for LintPlugins {
 
 impl<'de> Deserialize<'de> for LintPlugins {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        Vec::<&str>::deserialize(deserializer).map(|vec| vec.into_iter().collect())
+        struct LintPluginsVisitor;
+        impl<'de> de::Visitor<'de> for LintPluginsVisitor {
+            type Value = LintPlugins;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a list of plugin names")
+            }
+
+            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
+                Ok(LintPlugins::from(value))
+            }
+
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(LintPlugins::from(v.as_str()))
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                let mut plugins = LintPlugins::default();
+                while let Some(plugin) = seq.next_element::<&str>()? {
+                    plugins |= plugin.into();
+                }
+                Ok(plugins)
+            }
+        }
+
+        deserializer.deserialize_any(LintPluginsVisitor)
     }
 }
 
diff --git a/tasks/benchmark/benches/linter.rs b/tasks/benchmark/benches/linter.rs
index 8cb9709474e74..19089074e7aa1 100644
--- a/tasks/benchmark/benches/linter.rs
+++ b/tasks/benchmark/benches/linter.rs
@@ -2,7 +2,7 @@ use std::{env, path::Path, rc::Rc};
 
 use oxc_allocator::Allocator;
 use oxc_benchmark::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use oxc_linter::{AllowWarnDeny, FixKind, LintFilter, Linter, OxlintOptions};
+use oxc_linter::{FixKind, LinterBuilder};
 use oxc_parser::Parser;
 use oxc_semantic::SemanticBuilder;
 use oxc_span::SourceType;
@@ -34,22 +34,7 @@ fn bench_linter(criterion: &mut Criterion) {
                     .with_cfg(true)
                     .build_module_record(Path::new(""), program)
                     .build(program);
-                let filter = vec![
-                    LintFilter::new(AllowWarnDeny::Deny, "all").unwrap(),
-                    LintFilter::new(AllowWarnDeny::Deny, "nursery").unwrap(),
-                ];
-                let lint_options = OxlintOptions::default()
-                    .with_filter(filter)
-                    .with_fix(FixKind::All)
-                    .with_import_plugin(true)
-                    .with_jsdoc_plugin(true)
-                    .with_jest_plugin(true)
-                    .with_jsx_a11y_plugin(true)
-                    .with_nextjs_plugin(true)
-                    .with_react_perf_plugin(true)
-                    .with_vitest_plugin(true)
-                    .with_node_plugin(true);
-                let linter = Linter::from_options(lint_options).unwrap();
+                let linter = LinterBuilder::all().with_fix(FixKind::All).build();
                 let semantic = Rc::new(semantic_ret.semantic);
                 b.iter(|| linter.run(Path::new(std::ffi::OsStr::new("")), Rc::clone(&semantic)));
             },

From 7458089e3c347e5955ed46ab8ff8ce668d8d8bb6 Mon Sep 17 00:00:00 2001
From: Don Isaac <donald.isaac@gmail.com>
Date: Thu, 10 Oct 2024 22:04:09 -0400
Subject: [PATCH 03/24] chore: add dev container config (#6433)

This will make it easier to review PRs in github codespaces.

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
 .devcontainer/devcontainer.json | 45 +++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 .devcontainer/devcontainer.json

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000000000..18705aeafa0fd
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,45 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/rust
+{
+  "name": "Rust",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/rust:latest",
+  "features": {
+    // add `just` for running scripts
+    "ghcr.io/guiyomh/features/just:0": {
+      "version": "latest"
+    },
+    // add `cargo-binstall` for installing other tools.
+    "ghcr.io/lee-orr/rusty-dev-containers/cargo-binstall:0": {
+      "version": "latest"
+    }
+  },
+  // Configure tool-specific properties.
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "rust-lang.rust-analyzer"
+      ]
+    }
+  },
+
+  // Use 'mounts' to make the cargo cache persistent in a Docker Volume.
+  // "mounts": [
+  // 	{
+  // 		"source": "devcontainer-cargo-cache-${devcontainerId}",
+  // 		"target": "/usr/local/cargo",
+  // 		"type": "volume"
+  // 	}
+  // ]
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  // "features": {},
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "just init"
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+}

From 702b574afb13e4aad7dbd4179b87cdd958990e58 Mon Sep 17 00:00:00 2001
From: Dunqing <29533304+Dunqing@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:04:27 +0000
Subject: [PATCH 04/24] refactor(codegen): only print necessary parentheses in
 TSAsExpression (#6429)

Part of fixing #6385
---
 crates/oxc_codegen/src/gen.rs                   | 14 +++++++-------
 .../tests/integration/snapshots/ts.snap         | 17 ++++++++++++++++-
 crates/oxc_codegen/tests/integration/ts.rs      |  5 ++++-
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs
index 93fc53b9fd29b..a815a3c01880a 100644
--- a/crates/oxc_codegen/src/gen.rs
+++ b/crates/oxc_codegen/src/gen.rs
@@ -2092,13 +2092,13 @@ impl<'a> GenExpr for NewExpression<'a> {
 
 impl<'a> GenExpr for TSAsExpression<'a> {
     fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) {
-        p.print_char(b'(');
-        p.print_char(b'(');
-        self.expression.print_expr(p, precedence, Context::default());
-        p.print_char(b')');
-        p.print_str(" as ");
-        self.type_annotation.print(p, ctx);
-        p.print_char(b')');
+        let wrap = precedence >= Precedence::Shift;
+
+        p.wrap(wrap, |p| {
+            self.expression.print_expr(p, Precedence::Exponentiation, ctx);
+            p.print_str(" as ");
+            self.type_annotation.print(p, ctx);
+        });
     }
 }
 
diff --git a/crates/oxc_codegen/tests/integration/snapshots/ts.snap b/crates/oxc_codegen/tests/integration/snapshots/ts.snap
index c5bb3fddcaae7..727c54bba0952 100644
--- a/crates/oxc_codegen/tests/integration/snapshots/ts.snap
+++ b/crates/oxc_codegen/tests/integration/snapshots/ts.snap
@@ -159,7 +159,7 @@ a = x!;
 ########## 25
 b = (x as y);
 ----------
-b = ((x) as y);
+b = x as y;
 
 ########## 26
 c = foo<string>;
@@ -210,3 +210,18 @@ export type Component<
 	E extends EmitsOptions | Record<string, any[]> = {},
 	S extends Record<string, any> = any
 > = ConcreteComponent<Props, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<Props>;
+
+########## 32
+(a || b) as any
+----------
+(a || b) as any;
+
+########## 33
+(a ** b) as any
+----------
+(a ** b) as any;
+
+########## 34
+(function g() {}) as any
+----------
+(function g() {}) as any;
diff --git a/crates/oxc_codegen/tests/integration/ts.rs b/crates/oxc_codegen/tests/integration/ts.rs
index 1ee5d448b786f..69c805f7e1b7f 100644
--- a/crates/oxc_codegen/tests/integration/ts.rs
+++ b/crates/oxc_codegen/tests/integration/ts.rs
@@ -50,7 +50,10 @@ export type Component<
 > =
   | ConcreteComponent<Props, RawBindings, D, C, M, E, S>
   | ComponentPublicInstanceConstructor<Props>
-"
+",
+"(a || b) as any",
+"(a ** b) as any",
+"(function g() {}) as any",
     ];
 
     snapshot("ts", &cases);

From c18c6e9db12112333a9e0896f1c3bd8182caaa51 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:11:27 +0000
Subject: [PATCH 05/24] refactor(linter): split service code into separate
 modules (#6437)

Refactor in preparation of multi-config/`override` support.
---
 crates/oxc_linter/src/service/mod.rs          | 128 ++++++++++++++
 crates/oxc_linter/src/service/module_cache.rs |  34 ++++
 .../src/{service.rs => service/runtime.rs}    | 164 ++----------------
 3 files changed, 175 insertions(+), 151 deletions(-)
 create mode 100644 crates/oxc_linter/src/service/mod.rs
 create mode 100644 crates/oxc_linter/src/service/module_cache.rs
 rename crates/oxc_linter/src/{service.rs => service/runtime.rs} (74%)

diff --git a/crates/oxc_linter/src/service/mod.rs b/crates/oxc_linter/src/service/mod.rs
new file mode 100644
index 0000000000000..1566db3fb0a70
--- /dev/null
+++ b/crates/oxc_linter/src/service/mod.rs
@@ -0,0 +1,128 @@
+mod module_cache;
+mod runtime;
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use oxc_diagnostics::DiagnosticSender;
+use rayon::{iter::ParallelBridge, prelude::ParallelIterator};
+
+use crate::Linter;
+
+use module_cache::{CacheState, CacheStateEntry, ModuleMap, ModuleState};
+use runtime::Runtime;
+
+pub struct LintServiceOptions {
+    /// Current working directory
+    cwd: Box<Path>,
+
+    /// All paths to lint
+    paths: Vec<Box<Path>>,
+
+    /// TypeScript `tsconfig.json` path for reading path alias and project references
+    tsconfig: Option<PathBuf>,
+
+    cross_module: bool,
+}
+
+impl LintServiceOptions {
+    #[must_use]
+    pub fn new<T>(cwd: T, paths: Vec<Box<Path>>) -> Self
+    where
+        T: Into<Box<Path>>,
+    {
+        Self { cwd: cwd.into(), paths, tsconfig: None, cross_module: false }
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn with_tsconfig<T>(mut self, tsconfig: T) -> Self
+    where
+        T: Into<PathBuf>,
+    {
+        let tsconfig = tsconfig.into();
+        // Should this be canonicalized?
+        let tsconfig = if tsconfig.is_relative() { self.cwd.join(tsconfig) } else { tsconfig };
+        debug_assert!(tsconfig.is_file());
+
+        self.tsconfig = Some(tsconfig);
+        self
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn with_cross_module(mut self, cross_module: bool) -> Self {
+        self.cross_module = cross_module;
+        self
+    }
+
+    #[inline]
+    pub fn cwd(&self) -> &Path {
+        &self.cwd
+    }
+}
+
+#[derive(Clone)]
+pub struct LintService {
+    runtime: Arc<Runtime>,
+}
+
+impl LintService {
+    pub fn new(linter: Linter, options: LintServiceOptions) -> Self {
+        let runtime = Arc::new(Runtime::new(linter, options));
+        Self { runtime }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn from_linter(linter: Linter, options: LintServiceOptions) -> Self {
+        let runtime = Arc::new(Runtime::new(linter, options));
+        Self { runtime }
+    }
+
+    pub fn linter(&self) -> &Linter {
+        &self.runtime.linter
+    }
+
+    pub fn number_of_dependencies(&self) -> usize {
+        self.runtime.module_map.len() - self.runtime.paths.len()
+    }
+
+    /// # Panics
+    pub fn run(&self, tx_error: &DiagnosticSender) {
+        self.runtime
+            .paths
+            .iter()
+            .par_bridge()
+            .for_each_with(&self.runtime, |runtime, path| runtime.process_path(path, tx_error));
+        tx_error.send(None).unwrap();
+    }
+
+    /// For tests
+    #[cfg(test)]
+    pub(crate) fn run_source<'a>(
+        &self,
+        allocator: &'a oxc_allocator::Allocator,
+        source_text: &'a str,
+        check_syntax_errors: bool,
+        tx_error: &DiagnosticSender,
+    ) -> Vec<crate::Message<'a>> {
+        self.runtime
+            .paths
+            .iter()
+            .flat_map(|path| {
+                let source_type = oxc_span::SourceType::from_path(path).unwrap();
+                self.runtime.init_cache_state(path);
+                self.runtime.process_source(
+                    path,
+                    allocator,
+                    source_text,
+                    source_type,
+                    check_syntax_errors,
+                    tx_error,
+                )
+            })
+            .collect::<Vec<_>>()
+    }
+}
diff --git a/crates/oxc_linter/src/service/module_cache.rs b/crates/oxc_linter/src/service/module_cache.rs
new file mode 100644
index 0000000000000..bf2e7d6a89666
--- /dev/null
+++ b/crates/oxc_linter/src/service/module_cache.rs
@@ -0,0 +1,34 @@
+use std::{
+    path::Path,
+    sync::{Arc, Condvar, Mutex},
+};
+
+use dashmap::DashMap;
+use oxc_semantic::ModuleRecord;
+use rustc_hash::FxHashMap;
+
+/// `CacheState` and `CacheStateEntry` are used to fix the problem where
+/// there is a brief moment when a concurrent fetch can miss the cache.
+///
+/// Given `ModuleMap` is a `DashMap`, which conceptually is a `RwLock<HashMap>`.
+/// When two requests read the map at the exact same time from different threads,
+/// both will miss the cache so both thread will make a request.
+///
+/// See the "problem section" in <https://medium.com/@polyglot_factotum/rust-concurrency-patterns-condvars-and-locks-e278f18db74f>
+/// and the solution is copied here to fix the issue.
+pub(super) type CacheState = Mutex<FxHashMap<Box<Path>, Arc<(Mutex<CacheStateEntry>, Condvar)>>>;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum CacheStateEntry {
+    ReadyToConstruct,
+    PendingStore(usize),
+}
+
+/// Keyed by canonicalized path
+pub(super) type ModuleMap = DashMap<Box<Path>, ModuleState>;
+
+#[derive(Clone)]
+pub(super) enum ModuleState {
+    Resolved(Arc<ModuleRecord>),
+    Ignored,
+}
diff --git a/crates/oxc_linter/src/service.rs b/crates/oxc_linter/src/service/runtime.rs
similarity index 74%
rename from crates/oxc_linter/src/service.rs
rename to crates/oxc_linter/src/service/runtime.rs
index 4564dd9099b73..3dab419dd9bf1 100644
--- a/crates/oxc_linter/src/service.rs
+++ b/crates/oxc_linter/src/service/runtime.rs
@@ -7,15 +7,14 @@ use std::{
     sync::{Arc, Condvar, Mutex},
 };
 
-use dashmap::DashMap;
 use oxc_allocator::Allocator;
 use oxc_diagnostics::{DiagnosticSender, DiagnosticService, Error, OxcDiagnostic};
 use oxc_parser::{ParseOptions, Parser};
 use oxc_resolver::Resolver;
-use oxc_semantic::{ModuleRecord, SemanticBuilder};
+use oxc_semantic::SemanticBuilder;
 use oxc_span::{SourceType, VALID_EXTENSIONS};
 use rayon::{iter::ParallelBridge, prelude::ParallelIterator};
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashSet;
 
 use crate::{
     loader::{JavaScriptSource, PartialLoader, LINT_PARTIAL_LOADER_EXT},
@@ -23,157 +22,20 @@ use crate::{
     Fixer, Linter, Message,
 };
 
-pub struct LintServiceOptions {
-    /// Current working directory
-    cwd: Box<Path>,
-
-    /// All paths to lint
-    paths: Vec<Box<Path>>,
-
-    /// TypeScript `tsconfig.json` path for reading path alias and project references
-    tsconfig: Option<PathBuf>,
-
-    cross_module: bool,
-}
-
-impl LintServiceOptions {
-    #[must_use]
-    pub fn new<T>(cwd: T, paths: Vec<Box<Path>>) -> Self
-    where
-        T: Into<Box<Path>>,
-    {
-        Self { cwd: cwd.into(), paths, tsconfig: None, cross_module: false }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn with_tsconfig<T>(mut self, tsconfig: T) -> Self
-    where
-        T: Into<PathBuf>,
-    {
-        let tsconfig = tsconfig.into();
-        // Should this be canonicalized?
-        let tsconfig = if tsconfig.is_relative() { self.cwd.join(tsconfig) } else { tsconfig };
-        debug_assert!(tsconfig.is_file());
-
-        self.tsconfig = Some(tsconfig);
-        self
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn with_cross_module(mut self, cross_module: bool) -> Self {
-        self.cross_module = cross_module;
-        self
-    }
-
-    #[inline]
-    pub fn cwd(&self) -> &Path {
-        &self.cwd
-    }
-}
-
-#[derive(Clone)]
-pub struct LintService {
-    runtime: Arc<Runtime>,
-}
-
-impl LintService {
-    pub fn new(linter: Linter, options: LintServiceOptions) -> Self {
-        let runtime = Arc::new(Runtime::new(linter, options));
-        Self { runtime }
-    }
-
-    #[cfg(test)]
-    pub(crate) fn from_linter(linter: Linter, options: LintServiceOptions) -> Self {
-        let runtime = Arc::new(Runtime::new(linter, options));
-        Self { runtime }
-    }
-
-    pub fn linter(&self) -> &Linter {
-        &self.runtime.linter
-    }
-
-    pub fn number_of_dependencies(&self) -> usize {
-        self.runtime.module_map.len() - self.runtime.paths.len()
-    }
-
-    /// # Panics
-    pub fn run(&self, tx_error: &DiagnosticSender) {
-        self.runtime
-            .paths
-            .iter()
-            .par_bridge()
-            .for_each_with(&self.runtime, |runtime, path| runtime.process_path(path, tx_error));
-        tx_error.send(None).unwrap();
-    }
-
-    /// For tests
-    #[cfg(test)]
-    pub(crate) fn run_source<'a>(
-        &self,
-        allocator: &'a Allocator,
-        source_text: &'a str,
-        check_syntax_errors: bool,
-        tx_error: &DiagnosticSender,
-    ) -> Vec<Message<'a>> {
-        self.runtime
-            .paths
-            .iter()
-            .flat_map(|path| {
-                let source_type = SourceType::from_path(path).unwrap();
-                self.runtime.init_cache_state(path);
-                self.runtime.process_source(
-                    path,
-                    allocator,
-                    source_text,
-                    source_type,
-                    check_syntax_errors,
-                    tx_error,
-                )
-            })
-            .collect::<Vec<_>>()
-    }
-}
-
-/// `CacheState` and `CacheStateEntry` are used to fix the problem where
-/// there is a brief moment when a concurrent fetch can miss the cache.
-///
-/// Given `ModuleMap` is a `DashMap`, which conceptually is a `RwLock<HashMap>`.
-/// When two requests read the map at the exact same time from different threads,
-/// both will miss the cache so both thread will make a request.
-///
-/// See the "problem section" in <https://medium.com/@polyglot_factotum/rust-concurrency-patterns-condvars-and-locks-e278f18db74f>
-/// and the solution is copied here to fix the issue.
-type CacheState = Mutex<FxHashMap<Box<Path>, Arc<(Mutex<CacheStateEntry>, Condvar)>>>;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum CacheStateEntry {
-    ReadyToConstruct,
-    PendingStore(usize),
-}
-
-/// Keyed by canonicalized path
-type ModuleMap = DashMap<Box<Path>, ModuleState>;
-
-#[derive(Clone)]
-enum ModuleState {
-    Resolved(Arc<ModuleRecord>),
-    Ignored,
-}
+use super::{CacheState, CacheStateEntry, LintServiceOptions, ModuleMap, ModuleState};
 
 pub struct Runtime {
-    cwd: Box<Path>,
+    pub(super) cwd: Box<Path>,
     /// All paths to lint
-    paths: FxHashSet<Box<Path>>,
-    linter: Linter,
-    resolver: Option<Resolver>,
-    module_map: ModuleMap,
-    cache_state: CacheState,
+    pub(super) paths: FxHashSet<Box<Path>>,
+    pub(super) linter: Linter,
+    pub(super) resolver: Option<Resolver>,
+    pub(super) module_map: ModuleMap,
+    pub(super) cache_state: CacheState,
 }
 
 impl Runtime {
-    fn new(linter: Linter, options: LintServiceOptions) -> Self {
+    pub(super) fn new(linter: Linter, options: LintServiceOptions) -> Self {
         let resolver = options.cross_module.then(|| {
             Self::get_resolver(options.tsconfig.or_else(|| Some(options.cwd.join("tsconfig.json"))))
         });
@@ -230,7 +92,7 @@ impl Runtime {
     // clippy: the source field is checked and assumed to be less than 4GB, and
     // we assume that the fix offset will not exceed 2GB in either direction
     #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
-    fn process_path(&self, path: &Path, tx_error: &DiagnosticSender) {
+    pub(super) fn process_path(&self, path: &Path, tx_error: &DiagnosticSender) {
         if self.init_cache_state(path) {
             return;
         }
@@ -318,7 +180,7 @@ impl Runtime {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn process_source<'a>(
+    pub(super) fn process_source<'a>(
         &self,
         path: &Path,
         allocator: &'a Allocator,
@@ -434,7 +296,7 @@ impl Runtime {
         self.linter.run(path, Rc::new(semantic_ret.semantic))
     }
 
-    fn init_cache_state(&self, path: &Path) -> bool {
+    pub(super) fn init_cache_state(&self, path: &Path) -> bool {
         if self.resolver.is_none() {
             return false;
         }

From 6a0a5337e1a34b5253021ab3b379d1c7546fe935 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:11:27 +0000
Subject: [PATCH 06/24] refactor(linter): move module cache logic out of
 Runtime (#6438)

Pure refactor. Makes `Runtime` easier to reason about.
---
 crates/oxc_linter/src/service/mod.rs          |  3 +-
 crates/oxc_linter/src/service/module_cache.rs | 95 ++++++++++++++++++-
 crates/oxc_linter/src/service/runtime.rs      | 76 +++------------
 3 files changed, 103 insertions(+), 71 deletions(-)

diff --git a/crates/oxc_linter/src/service/mod.rs b/crates/oxc_linter/src/service/mod.rs
index 1566db3fb0a70..93d4ac127757c 100644
--- a/crates/oxc_linter/src/service/mod.rs
+++ b/crates/oxc_linter/src/service/mod.rs
@@ -11,7 +11,6 @@ use rayon::{iter::ParallelBridge, prelude::ParallelIterator};
 
 use crate::Linter;
 
-use module_cache::{CacheState, CacheStateEntry, ModuleMap, ModuleState};
 use runtime::Runtime;
 
 pub struct LintServiceOptions {
@@ -86,7 +85,7 @@ impl LintService {
     }
 
     pub fn number_of_dependencies(&self) -> usize {
-        self.runtime.module_map.len() - self.runtime.paths.len()
+        self.runtime.modules.len() - self.runtime.paths.len()
     }
 
     /// # Panics
diff --git a/crates/oxc_linter/src/service/module_cache.rs b/crates/oxc_linter/src/service/module_cache.rs
index bf2e7d6a89666..069c82ad38193 100644
--- a/crates/oxc_linter/src/service/module_cache.rs
+++ b/crates/oxc_linter/src/service/module_cache.rs
@@ -3,7 +3,7 @@ use std::{
     sync::{Arc, Condvar, Mutex},
 };
 
-use dashmap::DashMap;
+use dashmap::{mapref::one::Ref, DashMap};
 use oxc_semantic::ModuleRecord;
 use rustc_hash::FxHashMap;
 
@@ -16,19 +16,106 @@ use rustc_hash::FxHashMap;
 ///
 /// See the "problem section" in <https://medium.com/@polyglot_factotum/rust-concurrency-patterns-condvars-and-locks-e278f18db74f>
 /// and the solution is copied here to fix the issue.
-pub(super) type CacheState = Mutex<FxHashMap<Box<Path>, Arc<(Mutex<CacheStateEntry>, Condvar)>>>;
+type CacheState = Mutex<FxHashMap<Box<Path>, Arc<(Mutex<CacheStateEntry>, Condvar)>>>;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(super) enum CacheStateEntry {
+enum CacheStateEntry {
     ReadyToConstruct,
     PendingStore(usize),
 }
 
 /// Keyed by canonicalized path
-pub(super) type ModuleMap = DashMap<Box<Path>, ModuleState>;
+type ModuleMap = DashMap<Box<Path>, ModuleState>;
 
 #[derive(Clone)]
 pub(super) enum ModuleState {
     Resolved(Arc<ModuleRecord>),
     Ignored,
 }
+
+#[derive(Default)]
+pub(super) struct ModuleCache {
+    cache_state: Arc<CacheState>,
+    modules: ModuleMap,
+}
+
+impl ModuleCache {
+    #[inline]
+    pub fn get(&self, path: &Path) -> Option<Ref<'_, Box<Path>, ModuleState>> {
+        self.modules.get(path)
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.modules.len()
+    }
+
+    pub(super) fn init_cache_state(&self, path: &Path) -> bool {
+        let (lock, cvar) = {
+            let mut state_map = self.cache_state.lock().expect("Failed to lock cache state");
+            &*Arc::clone(state_map.entry(path.to_path_buf().into_boxed_path()).or_insert_with(
+                || Arc::new((Mutex::new(CacheStateEntry::ReadyToConstruct), Condvar::new())),
+            ))
+        };
+        let mut state = cvar
+            .wait_while(lock.lock().expect("Failed lock inner cache state"), |state| {
+                matches!(*state, CacheStateEntry::PendingStore(_))
+            })
+            .unwrap();
+
+        let cache_hit = if self.modules.contains_key(path) {
+            true
+        } else {
+            let i = if let CacheStateEntry::PendingStore(i) = *state { i } else { 0 };
+            *state = CacheStateEntry::PendingStore(i + 1);
+            false
+        };
+
+        if *state == CacheStateEntry::ReadyToConstruct {
+            cvar.notify_one();
+        }
+
+        drop(state);
+        cache_hit
+    }
+
+    /// # Panics
+    /// If a cache entry for `path` does not exist. You must call `init_cache_state` first.
+    pub(super) fn add_resolved_module(&self, path: &Path, module_record: Arc<ModuleRecord>) {
+        self.modules
+            .insert(path.to_path_buf().into_boxed_path(), ModuleState::Resolved(module_record));
+
+        self.update_cache_state(path);
+    }
+
+    /// # Panics
+    /// If a cache entry for `path` does not exist. You must call `init_cache_state` first.
+    pub(super) fn ignore_path(&self, path: &Path) {
+        self.modules.insert(path.to_path_buf().into_boxed_path(), ModuleState::Ignored);
+        self.update_cache_state(path);
+    }
+
+    /// # Panics
+    /// If a cache entry for `path` does not exist. You must call `init_cache_state` first.
+    fn update_cache_state(&self, path: &Path) {
+        let (lock, cvar) = {
+            let mut state_map = self.cache_state.lock().expect("Failed to lock cache state");
+            &*Arc::clone(
+                state_map
+                    .get_mut(path)
+                    .expect("Entry in http-cache state to have been previously inserted"),
+            )
+        };
+        let mut state = lock.lock().expect("Failed lock inner cache state");
+        if let CacheStateEntry::PendingStore(i) = *state {
+            let new = i - 1;
+            if new == 0 {
+                *state = CacheStateEntry::ReadyToConstruct;
+                // Notify the next thread waiting in line, if there is any.
+                cvar.notify_one();
+            } else {
+                *state = CacheStateEntry::PendingStore(new);
+            }
+        }
+    }
+}
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
index 3dab419dd9bf1..5c8da63b94c27 100644
--- a/crates/oxc_linter/src/service/runtime.rs
+++ b/crates/oxc_linter/src/service/runtime.rs
@@ -4,7 +4,7 @@ use std::{
     fs,
     path::{Path, PathBuf},
     rc::Rc,
-    sync::{Arc, Condvar, Mutex},
+    sync::Arc,
 };
 
 use oxc_allocator::Allocator;
@@ -22,7 +22,10 @@ use crate::{
     Fixer, Linter, Message,
 };
 
-use super::{CacheState, CacheStateEntry, LintServiceOptions, ModuleMap, ModuleState};
+use super::{
+    module_cache::{ModuleCache, ModuleState},
+    LintServiceOptions,
+};
 
 pub struct Runtime {
     pub(super) cwd: Box<Path>,
@@ -30,8 +33,7 @@ pub struct Runtime {
     pub(super) paths: FxHashSet<Box<Path>>,
     pub(super) linter: Linter,
     pub(super) resolver: Option<Resolver>,
-    pub(super) module_map: ModuleMap,
-    pub(super) cache_state: CacheState,
+    pub(super) modules: ModuleCache,
 }
 
 impl Runtime {
@@ -44,8 +46,7 @@ impl Runtime {
             paths: options.paths.iter().cloned().collect(),
             linter,
             resolver,
-            module_map: ModuleMap::default(),
-            cache_state: CacheState::default(),
+            modules: ModuleCache::default(),
         }
     }
 
@@ -216,11 +217,7 @@ impl Runtime {
         let module_record = semantic_builder.module_record();
 
         if self.resolver.is_some() {
-            self.module_map.insert(
-                path.to_path_buf().into_boxed_path(),
-                ModuleState::Resolved(Arc::clone(&module_record)),
-            );
-            self.update_cache_state(path);
+            self.modules.add_resolved_module(path, Arc::clone(&module_record));
 
             // Retrieve all dependency modules from this module.
             let dir = path.parent().unwrap();
@@ -235,7 +232,7 @@ impl Runtime {
                 .for_each_with(tx_error, |tx_error, (specifier, resolution)| {
                     let path = resolution.path();
                     self.process_path(path, tx_error);
-                    let Some(target_module_record_ref) = self.module_map.get(path) else {
+                    let Some(target_module_record_ref) = self.modules.get(path) else {
                         return;
                     };
                     let ModuleState::Resolved(target_module_record) =
@@ -301,60 +298,9 @@ impl Runtime {
             return false;
         }
 
-        let (lock, cvar) = {
-            let mut state_map = self.cache_state.lock().unwrap();
-            &*Arc::clone(state_map.entry(path.to_path_buf().into_boxed_path()).or_insert_with(
-                || Arc::new((Mutex::new(CacheStateEntry::ReadyToConstruct), Condvar::new())),
-            ))
-        };
-        let mut state = cvar
-            .wait_while(lock.lock().unwrap(), |state| {
-                matches!(*state, CacheStateEntry::PendingStore(_))
-            })
-            .unwrap();
-
-        let cache_hit = if self.module_map.contains_key(path) {
-            true
-        } else {
-            let i = if let CacheStateEntry::PendingStore(i) = *state { i } else { 0 };
-            *state = CacheStateEntry::PendingStore(i + 1);
-            false
-        };
-
-        if *state == CacheStateEntry::ReadyToConstruct {
-            cvar.notify_one();
-        }
-
-        drop(state);
-        cache_hit
+        self.modules.init_cache_state(path)
     }
-
-    fn update_cache_state(&self, path: &Path) {
-        let (lock, cvar) = {
-            let mut state_map = self.cache_state.lock().unwrap();
-            &*Arc::clone(
-                state_map
-                    .get_mut(path)
-                    .expect("Entry in http-cache state to have been previously inserted"),
-            )
-        };
-        let mut state = lock.lock().unwrap();
-        if let CacheStateEntry::PendingStore(i) = *state {
-            let new = i - 1;
-            if new == 0 {
-                *state = CacheStateEntry::ReadyToConstruct;
-                // Notify the next thread waiting in line, if there is any.
-                cvar.notify_one();
-            } else {
-                *state = CacheStateEntry::PendingStore(new);
-            }
-        }
-    }
-
     fn ignore_path(&self, path: &Path) {
-        if self.resolver.is_some() {
-            self.module_map.insert(path.to_path_buf().into_boxed_path(), ModuleState::Ignored);
-            self.update_cache_state(path);
-        }
+        self.resolver.is_some().then(|| self.modules.ignore_path(path));
     }
 }

From c00f6694355cc47954906744a5c5cdea129f8f49 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:11:28 +0000
Subject: [PATCH 07/24] perf(linter): use NonZeroUsize for pending module cache
 entries (#6439)

Using `NonZeroUsize` lets `rustc` detect a niche value, shrinking the size of `CacheStateEntry` from 16 bytes to 8. It has the added benefit of making `CacheStateEntry::PendingStore`'s purpose clearer.
---
 crates/oxc_linter/src/service/module_cache.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/crates/oxc_linter/src/service/module_cache.rs b/crates/oxc_linter/src/service/module_cache.rs
index 069c82ad38193..b46b2ff30552f 100644
--- a/crates/oxc_linter/src/service/module_cache.rs
+++ b/crates/oxc_linter/src/service/module_cache.rs
@@ -6,6 +6,7 @@ use std::{
 use dashmap::{mapref::one::Ref, DashMap};
 use oxc_semantic::ModuleRecord;
 use rustc_hash::FxHashMap;
+use std::num::NonZeroUsize;
 
 /// `CacheState` and `CacheStateEntry` are used to fix the problem where
 /// there is a brief moment when a concurrent fetch can miss the cache.
@@ -21,7 +22,7 @@ type CacheState = Mutex<FxHashMap<Box<Path>, Arc<(Mutex<CacheStateEntry>, Condva
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum CacheStateEntry {
     ReadyToConstruct,
-    PendingStore(usize),
+    PendingStore(NonZeroUsize),
 }
 
 /// Keyed by canonicalized path
@@ -66,8 +67,9 @@ impl ModuleCache {
         let cache_hit = if self.modules.contains_key(path) {
             true
         } else {
-            let i = if let CacheStateEntry::PendingStore(i) = *state { i } else { 0 };
-            *state = CacheStateEntry::PendingStore(i + 1);
+            let i = if let CacheStateEntry::PendingStore(i) = *state { i.get() } else { 0 };
+            // SAFETY: 1 + any natural number is always non-zero.
+            *state = CacheStateEntry::PendingStore(unsafe { NonZeroUsize::new_unchecked(i + 1) });
             false
         };
 
@@ -108,13 +110,14 @@ impl ModuleCache {
         };
         let mut state = lock.lock().expect("Failed lock inner cache state");
         if let CacheStateEntry::PendingStore(i) = *state {
-            let new = i - 1;
+            let new = i.get() - 1;
             if new == 0 {
                 *state = CacheStateEntry::ReadyToConstruct;
                 // Notify the next thread waiting in line, if there is any.
                 cvar.notify_one();
             } else {
-                *state = CacheStateEntry::PendingStore(new);
+                // SAFETY: new is never 0 because the previous branch checks for it.
+                *state = CacheStateEntry::PendingStore(unsafe { NonZeroUsize::new_unchecked(new) });
             }
         }
     }

From 002078afe3f4cd69fb1e3ad0c6a04ed56ca2edfe Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:11:28 +0000
Subject: [PATCH 08/24] refactor(linter): make Runtime's members private
 (#6440)

Protecting `Runtime`'s API in preparation of multli-config support.
---
 crates/oxc_linter/src/service/mod.rs     |  8 +++-----
 crates/oxc_linter/src/service/runtime.rs | 17 +++++++++++++----
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/crates/oxc_linter/src/service/mod.rs b/crates/oxc_linter/src/service/mod.rs
index 93d4ac127757c..b9b6726c8d749 100644
--- a/crates/oxc_linter/src/service/mod.rs
+++ b/crates/oxc_linter/src/service/mod.rs
@@ -85,14 +85,13 @@ impl LintService {
     }
 
     pub fn number_of_dependencies(&self) -> usize {
-        self.runtime.modules.len() - self.runtime.paths.len()
+        self.runtime.number_of_dependencies()
     }
 
     /// # Panics
     pub fn run(&self, tx_error: &DiagnosticSender) {
         self.runtime
-            .paths
-            .iter()
+            .iter_paths()
             .par_bridge()
             .for_each_with(&self.runtime, |runtime, path| runtime.process_path(path, tx_error));
         tx_error.send(None).unwrap();
@@ -108,8 +107,7 @@ impl LintService {
         tx_error: &DiagnosticSender,
     ) -> Vec<crate::Message<'a>> {
         self.runtime
-            .paths
-            .iter()
+            .iter_paths()
             .flat_map(|path| {
                 let source_type = oxc_span::SourceType::from_path(path).unwrap();
                 self.runtime.init_cache_state(path);
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
index 5c8da63b94c27..ab9d4542e372a 100644
--- a/crates/oxc_linter/src/service/runtime.rs
+++ b/crates/oxc_linter/src/service/runtime.rs
@@ -28,12 +28,12 @@ use super::{
 };
 
 pub struct Runtime {
-    pub(super) cwd: Box<Path>,
+    cwd: Box<Path>,
     /// All paths to lint
-    pub(super) paths: FxHashSet<Box<Path>>,
+    paths: FxHashSet<Box<Path>>,
     pub(super) linter: Linter,
-    pub(super) resolver: Option<Resolver>,
-    pub(super) modules: ModuleCache,
+    resolver: Option<Resolver>,
+    modules: ModuleCache,
 }
 
 impl Runtime {
@@ -300,7 +300,16 @@ impl Runtime {
 
         self.modules.init_cache_state(path)
     }
+
     fn ignore_path(&self, path: &Path) {
         self.resolver.is_some().then(|| self.modules.ignore_path(path));
     }
+
+    pub(super) fn number_of_dependencies(&self) -> usize {
+        self.modules.len() - self.paths.len()
+    }
+
+    pub(super) fn iter_paths(&self) -> impl Iterator<Item = &Box<Path>> + '_ {
+        self.paths.iter()
+    }
 }

From 2566ce787dcc4915b79672a87538f12e757fa5b4 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:30:26 +0000
Subject: [PATCH 09/24] refactor(linter): remove OxlintOptions (#6098)

Removed in favor of LinterBuilder
---
 crates/oxc_language_server/src/main.rs |  13 +-
 crates/oxc_linter/src/lib.rs           |  15 +-
 crates/oxc_linter/src/options/mod.rs   | 289 +------------------------
 3 files changed, 12 insertions(+), 305 deletions(-)

diff --git a/crates/oxc_language_server/src/main.rs b/crates/oxc_language_server/src/main.rs
index f55dd1342c66a..daedab95e5fd8 100644
--- a/crates/oxc_language_server/src/main.rs
+++ b/crates/oxc_language_server/src/main.rs
@@ -7,7 +7,7 @@ use futures::future::join_all;
 use globset::Glob;
 use ignore::gitignore::Gitignore;
 use log::{debug, error, info};
-use oxc_linter::{FixKind, Linter, OxlintOptions};
+use oxc_linter::{FixKind, LinterBuilder, Oxlintrc};
 use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, OnceCell, RwLock, SetError};
 use tower_lsp::{
@@ -345,12 +345,13 @@ impl Backend {
         if let Some(config_path) = config_path {
             let mut linter = self.server_linter.write().await;
             *linter = ServerLinter::new_with_linter(
-                Linter::from_options(
-                    OxlintOptions::default()
-                        .with_fix(FixKind::SafeFix)
-                        .with_config_path(Some(config_path)),
+                LinterBuilder::from_oxlintrc(
+                    true,
+                    Oxlintrc::from_file(&config_path)
+                        .expect("should have initialized linter with new options"),
                 )
-                .expect("should have initialized linter with new options"),
+                .with_fix(FixKind::SafeFix)
+                .build(),
             );
         }
     }
diff --git a/crates/oxc_linter/src/lib.rs b/crates/oxc_linter/src/lib.rs
index fec6cb9de306a..b2ad5345d530e 100644
--- a/crates/oxc_linter/src/lib.rs
+++ b/crates/oxc_linter/src/lib.rs
@@ -26,7 +26,6 @@ use std::{io::Write, path::Path, rc::Rc, sync::Arc};
 use config::LintConfig;
 use context::ContextHost;
 use options::LintOptions;
-use oxc_diagnostics::Error;
 use oxc_semantic::{AstNode, Semantic};
 
 pub use crate::{
@@ -35,9 +34,7 @@ pub use crate::{
     context::LintContext,
     fixer::FixKind,
     frameworks::FrameworkFlags,
-    options::{
-        AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind, LintPlugins, OxlintOptions,
-    },
+    options::{AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind, LintPlugins},
     rule::{RuleCategory, RuleFixMeta, RuleMeta, RuleWithSeverity},
     service::{LintService, LintServiceOptions},
 };
@@ -66,7 +63,7 @@ pub struct Linter {
 
 impl Default for Linter {
     fn default() -> Self {
-        Self::from_options(OxlintOptions::default()).unwrap()
+        LinterBuilder::default().build()
     }
 }
 
@@ -79,14 +76,6 @@ impl Linter {
         Self { rules, options, config: Arc::new(config) }
     }
 
-    /// # Errors
-    ///
-    /// Returns `Err` if there are any errors parsing the configuration file.
-    pub fn from_options(options: OxlintOptions) -> Result<Self, Error> {
-        let (rules, config) = options.derive_rules_and_config()?;
-        Ok(Self { rules, options: options.into(), config: Arc::new(config) })
-    }
-
     #[cfg(test)]
     #[must_use]
     pub fn with_rules(mut self, rules: Vec<RuleWithSeverity>) -> Self {
diff --git a/crates/oxc_linter/src/options/mod.rs b/crates/oxc_linter/src/options/mod.rs
index ceb566d5cf108..4ce020dc5f984 100644
--- a/crates/oxc_linter/src/options/mod.rs
+++ b/crates/oxc_linter/src/options/mod.rs
@@ -2,28 +2,13 @@ mod allow_warn_deny;
 mod filter;
 mod plugins;
 
-use std::{convert::From, path::PathBuf};
-
-use oxc_diagnostics::Error;
-use rustc_hash::FxHashSet;
-
 pub use allow_warn_deny::AllowWarnDeny;
 pub use filter::{InvalidFilterKind, LintFilter, LintFilterKind};
-pub use plugins::{LintPluginOptions, LintPlugins};
+pub use plugins::LintPlugins;
 
-use crate::{
-    config::{LintConfig, Oxlintrc},
-    fixer::FixKind,
-    rules::RULES,
-    utils::is_jest_rule_adapted_to_vitest,
-    FrameworkFlags, RuleCategory, RuleEnum, RuleWithSeverity,
-};
+use crate::{fixer::FixKind, FrameworkFlags};
 
-/// Subset of options used directly by the [`Linter`]. Derived from
-/// [`OxlintOptions`], which is the public-facing API. Do not expose this
-/// outside of this crate.
-///
-/// [`Linter`]: crate::Linter
+/// Subset of options used directly by the linter.
 #[derive(Debug, Default, Clone, Copy)]
 #[cfg_attr(test, derive(PartialEq))]
 pub(crate) struct LintOptions {
@@ -31,271 +16,3 @@ pub(crate) struct LintOptions {
     pub framework_hints: FrameworkFlags,
     pub plugins: LintPlugins,
 }
-
-impl From<OxlintOptions> for LintOptions {
-    fn from(options: OxlintOptions) -> Self {
-        Self {
-            fix: options.fix,
-            framework_hints: options.framework_hints,
-            plugins: options.plugins.into(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct OxlintOptions {
-    /// Allow / Deny rules in order. [("allow" / "deny", rule name)]
-    /// Defaults to [("deny", "correctness")]
-    pub filter: Vec<LintFilter>,
-    pub config_path: Option<PathBuf>,
-    /// Enable automatic code fixes. Set to [`None`] to disable.
-    ///
-    /// The kind represents the riskiest fix that the linter can apply.
-    pub fix: FixKind,
-
-    pub plugins: LintPluginOptions,
-
-    pub framework_hints: FrameworkFlags,
-}
-
-impl Default for OxlintOptions {
-    fn default() -> Self {
-        Self {
-            filter: vec![LintFilter::warn(RuleCategory::Correctness)],
-            config_path: None,
-            fix: FixKind::None,
-            plugins: LintPluginOptions::default(),
-            framework_hints: FrameworkFlags::default(),
-        }
-    }
-}
-
-impl OxlintOptions {
-    #[must_use]
-    pub fn with_filter(mut self, filter: Vec<LintFilter>) -> Self {
-        if !filter.is_empty() {
-            self.filter = filter;
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn with_config_path(mut self, filter: Option<PathBuf>) -> Self {
-        self.config_path = filter;
-        self
-    }
-
-    /// Set the kind of auto fixes to apply.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use oxc_linter::{LintOptions, FixKind};
-    ///
-    /// // turn off all auto fixes. This is default behavior.
-    /// LintOptions::default().with_fix(FixKind::None);
-    /// ```
-    #[must_use]
-    pub fn with_fix(mut self, kind: FixKind) -> Self {
-        self.fix = kind;
-        self
-    }
-
-    #[must_use]
-    pub fn with_react_plugin(mut self, yes: bool) -> Self {
-        self.plugins.react = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_unicorn_plugin(mut self, yes: bool) -> Self {
-        self.plugins.unicorn = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_typescript_plugin(mut self, yes: bool) -> Self {
-        self.plugins.typescript = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_oxc_plugin(mut self, yes: bool) -> Self {
-        self.plugins.oxc = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_import_plugin(mut self, yes: bool) -> Self {
-        self.plugins.import = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_jsdoc_plugin(mut self, yes: bool) -> Self {
-        self.plugins.jsdoc = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_jest_plugin(mut self, yes: bool) -> Self {
-        self.plugins.jest = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_vitest_plugin(mut self, yes: bool) -> Self {
-        self.plugins.vitest = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_jsx_a11y_plugin(mut self, yes: bool) -> Self {
-        self.plugins.jsx_a11y = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_nextjs_plugin(mut self, yes: bool) -> Self {
-        self.plugins.nextjs = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_react_perf_plugin(mut self, yes: bool) -> Self {
-        self.plugins.react_perf = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_promise_plugin(mut self, yes: bool) -> Self {
-        self.plugins.promise = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_node_plugin(mut self, yes: bool) -> Self {
-        self.plugins.node = yes;
-        self
-    }
-
-    #[must_use]
-    pub fn with_security_plugin(mut self, yes: bool) -> Self {
-        self.plugins.security = yes;
-        self
-    }
-}
-
-impl OxlintOptions {
-    /// # Errors
-    ///
-    /// * Returns `Err` if there are any errors parsing the configuration file.
-    pub(crate) fn derive_rules_and_config(
-        &self,
-    ) -> Result<(Vec<RuleWithSeverity>, LintConfig), Error> {
-        let config = self.config_path.as_ref().map(|path| Oxlintrc::from_file(path)).transpose()?;
-
-        let mut rules: FxHashSet<RuleWithSeverity> = FxHashSet::default();
-        let all_rules = self.get_filtered_rules();
-
-        for (severity, filter) in self.filter.iter().map(Into::into) {
-            match severity {
-                AllowWarnDeny::Deny | AllowWarnDeny::Warn => match filter {
-                    LintFilterKind::Category(category) => {
-                        rules.extend(
-                            all_rules
-                                .iter()
-                                .filter(|rule| rule.category() == *category)
-                                .map(|rule| RuleWithSeverity::new(rule.clone(), severity)),
-                        );
-                    }
-                    LintFilterKind::Rule(_, name) => {
-                        rules.extend(
-                            all_rules
-                                .iter()
-                                .filter(|rule| rule.name() == name)
-                                .map(|rule| RuleWithSeverity::new(rule.clone(), severity)),
-                        );
-                    }
-                    LintFilterKind::Generic(name_or_category) => {
-                        if name_or_category == "all" {
-                            rules.extend(
-                                all_rules
-                                    .iter()
-                                    .filter(|rule| rule.category() != RuleCategory::Nursery)
-                                    .map(|rule| RuleWithSeverity::new(rule.clone(), severity)),
-                            );
-                        } else {
-                            rules.extend(
-                                all_rules
-                                    .iter()
-                                    .filter(|rule| rule.name() == name_or_category)
-                                    .map(|rule| RuleWithSeverity::new(rule.clone(), severity)),
-                            );
-                        }
-                    }
-                },
-                AllowWarnDeny::Allow => match filter {
-                    LintFilterKind::Category(category) => {
-                        rules.retain(|rule| rule.category() != *category);
-                    }
-                    LintFilterKind::Rule(_, name) => {
-                        rules.retain(|rule| rule.name() != name);
-                    }
-                    LintFilterKind::Generic(name_or_category) => {
-                        if name_or_category == "all" {
-                            rules.clear();
-                        } else {
-                            rules.retain(|rule| rule.name() != name_or_category);
-                        }
-                    }
-                },
-            }
-        }
-
-        if let Some(config) = &config {
-            config.rules.override_rules(&mut rules, &all_rules);
-        }
-
-        let mut rules = rules.into_iter().collect::<Vec<_>>();
-
-        // for stable diagnostics output ordering
-        rules.sort_unstable_by_key(|rule| rule.id());
-
-        Ok((rules, config.map(Into::into).unwrap_or_default()))
-    }
-
-    /// Get final filtered rules by reading `self.xxx_plugin`
-    fn get_filtered_rules(&self) -> Vec<RuleEnum> {
-        RULES
-            .iter()
-            .filter(|rule| match rule.plugin_name() {
-                "react" => self.plugins.react,
-                "unicorn" => self.plugins.unicorn,
-                "typescript" => self.plugins.typescript,
-                "import" => self.plugins.import,
-                "jsdoc" => self.plugins.jsdoc,
-                "jest" => {
-                    if self.plugins.jest {
-                        return true;
-                    }
-                    if self.plugins.vitest && is_jest_rule_adapted_to_vitest(rule.name()) {
-                        return true;
-                    }
-                    false
-                }
-                "vitest" => self.plugins.vitest,
-                "jsx_a11y" => self.plugins.jsx_a11y,
-                "nextjs" => self.plugins.nextjs,
-                "react_perf" => self.plugins.react_perf,
-                "oxc" => self.plugins.oxc,
-                "eslint" | "tree_shaking" => true,
-                "promise" => self.plugins.promise,
-                "node" => self.plugins.node,
-                "security" => self.plugins.security,
-                name => panic!("Unhandled plugin: {name}"),
-            })
-            .cloned()
-            .collect::<Vec<_>>()
-    }
-}

From 46a38c63ff12cc9525c1eebac4458dcb237997b1 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 02:54:24 +0000
Subject: [PATCH 10/24] refactor(minifier): remove allow `clippy::unused_self`
 (#6441)

---
 .../src/ast_passes/peephole_fold_constants.rs | 48 +++++----------
 .../peephole_minimize_conditions.rs           |  3 +-
 .../ast_passes/peephole_remove_dead_code.rs   |  3 +-
 .../peephole_substitute_alternate_syntax.rs   | 59 +++++++++----------
 crates/oxc_minifier/src/compressor.rs         |  4 +-
 crates/oxc_minifier/src/lib.rs                |  2 +-
 6 files changed, 48 insertions(+), 71 deletions(-)

diff --git a/crates/oxc_minifier/src/ast_passes/peephole_fold_constants.rs b/crates/oxc_minifier/src/ast_passes/peephole_fold_constants.rs
index 7e5b13cc6bfa0..b1f2010fff66e 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_fold_constants.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_fold_constants.rs
@@ -45,17 +45,17 @@ impl<'a> Traverse<'a> for PeepholeFoldConstants {
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if let Some(folded_expr) = match expr {
             Expression::CallExpression(e) => {
-                self.try_fold_useless_object_dot_define_properties_call(e, ctx)
+                Self::try_fold_useless_object_dot_define_properties_call(e, ctx)
             }
-            Expression::NewExpression(e) => self.try_fold_ctor_cal(e, ctx),
+            Expression::NewExpression(e) => Self::try_fold_ctor_cal(e, ctx),
             // TODO
             // return tryFoldSpread(subtree);
-            Expression::ArrayExpression(e) => self.try_flatten_array_expression(e, ctx),
-            Expression::ObjectExpression(e) => self.try_flatten_object_expression(e, ctx),
-            Expression::BinaryExpression(e) => self.try_fold_binary_expression(e, ctx),
+            Expression::ArrayExpression(e) => Self::try_flatten_array_expression(e, ctx),
+            Expression::ObjectExpression(e) => Self::try_flatten_object_expression(e, ctx),
+            Expression::BinaryExpression(e) => Self::try_fold_binary_expression(e, ctx),
             Expression::UnaryExpression(e) => self.try_fold_unary_expression(e, ctx),
             // TODO: return tryFoldGetProp(subtree);
-            Expression::LogicalExpression(e) => self.try_fold_logical_expression(e, ctx),
+            Expression::LogicalExpression(e) => Self::try_fold_logical_expression(e, ctx),
             // TODO: tryFoldGetElem
             // TODO: tryFoldAssign
             _ => None,
@@ -72,7 +72,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_useless_object_dot_define_properties_call(
-        &mut self,
         _call_expr: &mut CallExpression<'a>,
         _ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -80,7 +79,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_ctor_cal(
-        &mut self,
         _new_expr: &mut NewExpression<'a>,
         _ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -91,7 +89,6 @@ impl<'a> PeepholeFoldConstants {
     /// `typeof("bar") --> "string"`
     /// `typeof(6) --> "number"`
     fn try_fold_type_of(
-        &self,
         expr: &mut UnaryExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -124,7 +121,6 @@ impl<'a> PeepholeFoldConstants {
     // }
 
     fn try_flatten_array_expression(
-        &mut self,
         _new_expr: &mut ArrayExpression<'a>,
         _ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -132,7 +128,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_flatten_object_expression(
-        &mut self,
         _new_expr: &mut ObjectExpression<'a>,
         _ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -149,7 +144,7 @@ impl<'a> PeepholeFoldConstants {
         }
         match expr.operator {
             UnaryOperator::Void => self.try_reduce_void(expr, ctx),
-            UnaryOperator::Typeof => self.try_fold_type_of(expr, ctx),
+            UnaryOperator::Typeof => Self::try_fold_type_of(expr, ctx),
             // TODO: tryReduceOperandsForOp
             #[allow(clippy::float_cmp)]
             UnaryOperator::LogicalNot => {
@@ -273,13 +268,12 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_logical_expression(
-        &self,
         logical_expr: &mut LogicalExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
         match logical_expr.operator {
-            LogicalOperator::And | LogicalOperator::Or => self.try_fold_and_or(logical_expr, ctx),
-            LogicalOperator::Coalesce => self.try_fold_coalesce(logical_expr, ctx),
+            LogicalOperator::And | LogicalOperator::Or => Self::try_fold_and_or(logical_expr, ctx),
+            LogicalOperator::Coalesce => Self::try_fold_coalesce(logical_expr, ctx),
         }
     }
 
@@ -287,7 +281,6 @@ impl<'a> PeepholeFoldConstants {
     ///
     /// port from [closure-compiler](https://github.com/google/closure-compiler/blob/09094b551915a6487a980a783831cba58b5739d1/src/com/google/javascript/jscomp/PeepholeFoldConstants.java#L587)
     pub fn try_fold_and_or(
-        &self,
         logical_expr: &mut LogicalExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -365,7 +358,6 @@ impl<'a> PeepholeFoldConstants {
 
     /// Try to fold a nullish coalesce `foo ?? bar`.
     pub fn try_fold_coalesce(
-        &self,
         logical_expr: &mut LogicalExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -399,22 +391,21 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_binary_expression(
-        &self,
         e: &mut BinaryExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
         // TODO: tryReduceOperandsForOp
         match e.operator {
             op if op.is_bitshift() => {
-                self.try_fold_shift(e.span, e.operator, &e.left, &e.right, ctx)
+                Self::try_fold_shift(e.span, e.operator, &e.left, &e.right, ctx)
             }
-            BinaryOperator::Instanceof => self.try_fold_instanceof(e.span, &e.left, &e.right, ctx),
-            BinaryOperator::Addition => self.try_fold_addition(e.span, &e.left, &e.right, ctx),
+            BinaryOperator::Instanceof => Self::try_fold_instanceof(e.span, &e.left, &e.right, ctx),
+            BinaryOperator::Addition => Self::try_fold_addition(e.span, &e.left, &e.right, ctx),
             BinaryOperator::Subtraction
             | BinaryOperator::Division
             | BinaryOperator::Remainder
             | BinaryOperator::Multiplication
-            | BinaryOperator::Exponential => self.try_fold_arithmetic_op(e, ctx),
+            | BinaryOperator::Exponential => Self::try_fold_arithmetic_op(e, ctx),
             BinaryOperator::BitwiseAnd | BinaryOperator::BitwiseOR | BinaryOperator::BitwiseXOR => {
                 // TODO:
                 // self.try_fold_arithmetic_op(e.span, &e.left, &e.right, ctx)
@@ -425,14 +416,13 @@ impl<'a> PeepholeFoldConstants {
                 None
             }
             op if op.is_equality() || op.is_compare() => {
-                self.try_fold_comparison(e.span, e.operator, &e.left, &e.right, ctx)
+                Self::try_fold_comparison(e.span, e.operator, &e.left, &e.right, ctx)
             }
             _ => None,
         }
     }
 
     fn try_fold_addition<'b>(
-        &self,
         span: Span,
         left: &'b Expression<'a>,
         right: &'b Expression<'a>,
@@ -476,7 +466,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_arithmetic_op(
-        &self,
         operation: &mut BinaryExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -504,7 +493,7 @@ impl<'a> PeepholeFoldConstants {
         let left: f64 = ctx.get_number_value(&operation.left)?.try_into().ok()?;
         let right: f64 = ctx.get_number_value(&operation.right)?.try_into().ok()?;
         if !left.is_finite() || !right.is_finite() {
-            return self.try_fold_infinity_arithmetic(left, operation.operator, right, ctx);
+            return Self::try_fold_infinity_arithmetic(left, operation.operator, right, ctx);
         }
         let result = match operation.operator {
             BinaryOperator::Addition => left + right,
@@ -550,7 +539,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_infinity_arithmetic(
-        &self,
         left: f64,
         operator: BinaryOperator,
         right: f64,
@@ -596,7 +584,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_instanceof<'b>(
-        &self,
         _span: Span,
         _left: &'b Expression<'a>,
         _right: &'b Expression<'a>,
@@ -606,14 +593,13 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn try_fold_comparison<'b>(
-        &self,
         span: Span,
         op: BinaryOperator,
         left: &'b Expression<'a>,
         right: &'b Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
-        let value = match self.evaluate_comparison(op, left, right, ctx) {
+        let value = match Self::evaluate_comparison(op, left, right, ctx) {
             Tri::True => true,
             Tri::False => false,
             Tri::Unknown => return None,
@@ -622,7 +608,6 @@ impl<'a> PeepholeFoldConstants {
     }
 
     fn evaluate_comparison<'b>(
-        &self,
         op: BinaryOperator,
         left: &'b Expression<'a>,
         right: &'b Expression<'a>,
@@ -924,7 +909,6 @@ impl<'a> PeepholeFoldConstants {
     /// ported from [closure-compiler](https://github.com/google/closure-compiler/blob/a4c880032fba961f7a6c06ef99daa3641810bfdd/src/com/google/javascript/jscomp/PeepholeFoldConstants.java#L1114-L1162)
     #[allow(clippy::cast_possible_truncation)]
     fn try_fold_shift<'b>(
-        &self,
         span: Span,
         op: BinaryOperator,
         left: &'b Expression<'a>,
diff --git a/crates/oxc_minifier/src/ast_passes/peephole_minimize_conditions.rs b/crates/oxc_minifier/src/ast_passes/peephole_minimize_conditions.rs
index c0db66ddf4855..3595ae1a5654d 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_minimize_conditions.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_minimize_conditions.rs
@@ -28,7 +28,7 @@ impl<'a> CompressorPass<'a> for PeepholeMinimizeConditions {
 impl<'a> Traverse<'a> for PeepholeMinimizeConditions {
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if let Some(folded_expr) = match expr {
-            Expression::UnaryExpression(e) if e.operator.is_not() => self.try_minimize_not(e, ctx),
+            Expression::UnaryExpression(e) if e.operator.is_not() => Self::try_minimize_not(e, ctx),
             _ => None,
         } {
             *expr = folded_expr;
@@ -44,7 +44,6 @@ impl<'a> PeepholeMinimizeConditions {
 
     /// Try to minimize NOT nodes such as `!(x==y)`.
     fn try_minimize_not(
-        &self,
         expr: &mut UnaryExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
diff --git a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
index 0190bcae65705..05c1a364743f2 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
@@ -46,7 +46,7 @@ impl<'a> Traverse<'a> for PeepholeRemoveDeadCode {
 
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if let Some(folded_expr) = match expr {
-            Expression::ConditionalExpression(e) => self.try_fold_conditional_expression(e, ctx),
+            Expression::ConditionalExpression(e) => Self::try_fold_conditional_expression(e, ctx),
             _ => None,
         } {
             *expr = folded_expr;
@@ -164,7 +164,6 @@ impl<'a> PeepholeRemoveDeadCode {
 
     /// Try folding conditional expression (?:) if the condition results of the condition is known.
     fn try_fold_conditional_expression(
-        &self,
         expr: &mut ConditionalExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
diff --git a/crates/oxc_minifier/src/ast_passes/peephole_substitute_alternate_syntax.rs b/crates/oxc_minifier/src/ast_passes/peephole_substitute_alternate_syntax.rs
index 53e2b157f438b..92596163c17ae 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_substitute_alternate_syntax.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_substitute_alternate_syntax.rs
@@ -82,12 +82,12 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
 
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if let Expression::AssignmentExpression(assignment_expr) = expr {
-            if let Some(new_expr) = self.try_compress_assignment_expression(assignment_expr, ctx) {
+            if let Some(new_expr) = Self::try_compress_assignment_expression(assignment_expr, ctx) {
                 *expr = new_expr;
                 self.changed = true;
             }
         }
-        if !self.compress_undefined(expr, ctx) {
+        if !Self::compress_undefined(expr, ctx) {
             self.compress_boolean(expr, ctx);
         }
     }
@@ -95,13 +95,13 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         match expr {
             Expression::NewExpression(new_expr) => {
-                if let Some(new_expr) = self.try_fold_new_expression(new_expr, ctx) {
+                if let Some(new_expr) = Self::try_fold_new_expression(new_expr, ctx) {
                     *expr = new_expr;
                     self.changed = true;
                 }
             }
             Expression::CallExpression(call_expr) => {
-                if let Some(call_expr) = self.try_fold_call_expression(call_expr, ctx) {
+                if let Some(call_expr) = Self::try_fold_call_expression(call_expr, ctx) {
                     *expr = call_expr;
                     self.changed = true;
                 }
@@ -132,7 +132,7 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
     /* Utilities */
 
     /// Transforms `undefined` => `void 0`
-    fn compress_undefined(&self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) -> bool {
+    fn compress_undefined(expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) -> bool {
         if ctx.is_expression_undefined(expr) {
             *expr = ctx.ast.void_0(expr.span());
             return true;
@@ -316,7 +316,6 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
     }
 
     fn try_compress_assignment_expression(
-        &mut self,
         expr: &mut AssignmentExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -360,7 +359,6 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
     }
 
     fn try_fold_new_expression(
-        &mut self,
         new_expr: &mut NewExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -373,18 +371,19 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
         } else if new_expr.callee.is_global_reference_name("Array", ctx.symbols()) {
             // `new Array` -> `[]`
             if new_expr.arguments.is_empty() {
-                Some(self.empty_array_literal(ctx))
+                Some(Self::empty_array_literal(ctx))
             } else if new_expr.arguments.len() == 1 {
                 let arg = new_expr.arguments.get_mut(0).and_then(|arg| arg.as_expression_mut())?;
                 // `new Array(0)` -> `[]`
                 if arg.is_number_0() {
-                    Some(self.empty_array_literal(ctx))
+                    Some(Self::empty_array_literal(ctx))
                 }
                 // `new Array(8)` -> `Array(8)`
                 else if arg.is_number_literal() {
-                    Some(
-                        self.array_constructor_call(ctx.ast.move_vec(&mut new_expr.arguments), ctx),
-                    )
+                    Some(Self::array_constructor_call(
+                        ctx.ast.move_vec(&mut new_expr.arguments),
+                        ctx,
+                    ))
                 }
                 // `new Array(literal)` -> `[literal]`
                 else if arg.is_literal() || matches!(arg, Expression::ArrayExpression(_)) {
@@ -392,13 +391,14 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
                     let element =
                         ctx.ast.array_expression_element_expression(ctx.ast.move_expression(arg));
                     elements.push(element);
-                    Some(self.array_literal(elements, ctx))
+                    Some(Self::array_literal(elements, ctx))
                 }
                 // `new Array()` -> `Array()`
                 else {
-                    Some(
-                        self.array_constructor_call(ctx.ast.move_vec(&mut new_expr.arguments), ctx),
-                    )
+                    Some(Self::array_constructor_call(
+                        ctx.ast.move_vec(&mut new_expr.arguments),
+                        ctx,
+                    ))
                 }
             } else {
                 // `new Array(1, 2, 3)` -> `[1, 2, 3]`
@@ -410,7 +410,7 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
                         },
                     ),
                 );
-                Some(self.array_literal(elements, ctx))
+                Some(Self::array_literal(elements, ctx))
             }
         } else {
             None
@@ -418,7 +418,6 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
     }
 
     fn try_fold_call_expression(
-        &mut self,
         call_expr: &mut CallExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<Expression<'a>> {
@@ -431,21 +430,19 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
         } else if call_expr.callee.is_global_reference_name("Array", ctx.symbols()) {
             // `Array()` -> `[]`
             if call_expr.arguments.is_empty() {
-                Some(self.empty_array_literal(ctx))
+                Some(Self::empty_array_literal(ctx))
             } else if call_expr.arguments.len() == 1 {
                 let arg = call_expr.arguments.get_mut(0).and_then(|arg| arg.as_expression_mut())?;
                 // `Array(0)` -> `[]`
                 if arg.is_number_0() {
-                    Some(self.empty_array_literal(ctx))
+                    Some(Self::empty_array_literal(ctx))
                 }
                 // `Array(8)` -> `Array(8)`
                 else if arg.is_number_literal() {
-                    Some(
-                        self.array_constructor_call(
-                            ctx.ast.move_vec(&mut call_expr.arguments),
-                            ctx,
-                        ),
-                    )
+                    Some(Self::array_constructor_call(
+                        ctx.ast.move_vec(&mut call_expr.arguments),
+                        ctx,
+                    ))
                 }
                 // `Array(literal)` -> `[literal]`
                 else if arg.is_literal() || matches!(arg, Expression::ArrayExpression(_)) {
@@ -453,7 +450,7 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
                     let element =
                         ctx.ast.array_expression_element_expression(ctx.ast.move_expression(arg));
                     elements.push(element);
-                    Some(self.array_literal(elements, ctx))
+                    Some(Self::array_literal(elements, ctx))
                 } else {
                     None
                 }
@@ -467,7 +464,7 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
                         },
                     ),
                 );
-                Some(self.array_literal(elements, ctx))
+                Some(Self::array_literal(elements, ctx))
             }
         } else {
             None
@@ -489,7 +486,6 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
 
     /// returns an `Array()` constructor call with zero, one, or more arguments, copying from the input
     fn array_constructor_call(
-        &self,
         arguments: Vec<'a, Argument<'a>>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
@@ -499,7 +495,6 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
 
     /// returns an array literal `[]` of zero, one, or more elements, copying from the input
     fn array_literal(
-        &self,
         elements: Vec<'a, ArrayExpressionElement<'a>>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
@@ -507,8 +502,8 @@ impl<'a> PeepholeSubstituteAlternateSyntax {
     }
 
     /// returns a new empty array literal expression: `[]`
-    fn empty_array_literal(&self, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
-        self.array_literal(ctx.ast.vec(), ctx)
+    fn empty_array_literal(ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
+        Self::array_literal(ctx.ast.vec(), ctx)
     }
 }
 
diff --git a/crates/oxc_minifier/src/compressor.rs b/crates/oxc_minifier/src/compressor.rs
index cb1f7076020e9..6f7188a55b634 100644
--- a/crates/oxc_minifier/src/compressor.rs
+++ b/crates/oxc_minifier/src/compressor.rs
@@ -38,7 +38,7 @@ impl<'a> Compressor<'a> {
         RemoveSyntax::new(self.options).build(program, &mut ctx);
 
         if self.options.dead_code_elimination {
-            self.dead_code_elimination(program, &mut ctx);
+            Self::dead_code_elimination(program, &mut ctx);
             return;
         }
 
@@ -76,7 +76,7 @@ impl<'a> Compressor<'a> {
         }
     }
 
-    fn dead_code_elimination(self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+    fn dead_code_elimination(program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
         PeepholeFoldConstants::new().build(program, ctx);
         PeepholeMinimizeConditions::new().build(program, ctx);
         PeepholeRemoveDeadCode::new().build(program, ctx);
diff --git a/crates/oxc_minifier/src/lib.rs b/crates/oxc_minifier/src/lib.rs
index 9fad23f4f3b00..d2041e3cbf89c 100644
--- a/crates/oxc_minifier/src/lib.rs
+++ b/crates/oxc_minifier/src/lib.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::wildcard_imports, clippy::new_without_default, clippy::unused_self)]
+#![allow(clippy::wildcard_imports)]
 
 //! ECMAScript Minifier
 

From b1bf12c336a641565c355f2995615c3e7253174b Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 03:31:24 +0000
Subject: [PATCH 11/24] fix(parser): do not parse `as` and `satisfies`
 expression in javascript (#6442)

closes #6427
---
 crates/oxc_parser/src/js/expression.rs          |  3 ++-
 crates/oxc_parser/src/js/operator.rs            | 14 +++++---------
 tasks/coverage/snapshots/parser_misc.snap       |  4 ++--
 tasks/coverage/snapshots/parser_typescript.snap | 16 ++++++++++++----
 4 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs
index 3ae3be06e6f5f..f028f08172052 100644
--- a/crates/oxc_parser/src/js/expression.rs
+++ b/crates/oxc_parser/src/js/expression.rs
@@ -951,12 +951,13 @@ impl<'a> ParserImpl<'a> {
         // Pratt Parsing Algorithm
         // <https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html>
         let mut lhs = lhs;
+        let is_ts = self.ts_enabled();
         loop {
             // re-lex for `>=` `>>` `>>>`
             // This is need for jsx `<div>=</div>` case
             let kind = self.re_lex_right_angle();
 
-            let Some(left_precedence) = kind_to_precedence(kind) else { break };
+            let Some(left_precedence) = kind_to_precedence(kind, is_ts) else { break };
 
             let stop = if left_precedence.is_right_associative() {
                 left_precedence < min_precedence
diff --git a/crates/oxc_parser/src/js/operator.rs b/crates/oxc_parser/src/js/operator.rs
index 76e9d27d9cd95..4d6457f74801a 100644
--- a/crates/oxc_parser/src/js/operator.rs
+++ b/crates/oxc_parser/src/js/operator.rs
@@ -7,7 +7,7 @@ use oxc_syntax::{
 
 use crate::lexer::Kind;
 
-pub fn kind_to_precedence(kind: Kind) -> Option<Precedence> {
+pub fn kind_to_precedence(kind: Kind, is_typescript: bool) -> Option<Precedence> {
     match kind {
         Kind::Question2 => Some(Precedence::NullishCoalescing),
         Kind::Pipe2 => Some(Precedence::LogicalOr),
@@ -16,18 +16,14 @@ pub fn kind_to_precedence(kind: Kind) -> Option<Precedence> {
         Kind::Caret => Some(Precedence::BitwiseXor),
         Kind::Amp => Some(Precedence::BitwiseAnd),
         Kind::Eq2 | Kind::Eq3 | Kind::Neq | Kind::Neq2 => Some(Precedence::Equals),
-        Kind::LAngle
-        | Kind::RAngle
-        | Kind::LtEq
-        | Kind::GtEq
-        | Kind::Instanceof
-        | Kind::In
-        | Kind::As
-        | Kind::Satisfies => Some(Precedence::Compare),
+        Kind::LAngle | Kind::RAngle | Kind::LtEq | Kind::GtEq | Kind::Instanceof | Kind::In => {
+            Some(Precedence::Compare)
+        }
         Kind::ShiftLeft | Kind::ShiftRight | Kind::ShiftRight3 => Some(Precedence::Shift),
         Kind::Plus | Kind::Minus => Some(Precedence::Add),
         Kind::Star | Kind::Slash | Kind::Percent => Some(Precedence::Multiply),
         Kind::Star2 => Some(Precedence::Exponentiation),
+        Kind::As | Kind::Satisfies if is_typescript => Some(Precedence::Compare),
         _ => None,
     }
 }
diff --git a/tasks/coverage/snapshots/parser_misc.snap b/tasks/coverage/snapshots/parser_misc.snap
index 8944a566e3b05..5ac2dc81441f2 100644
--- a/tasks/coverage/snapshots/parser_misc.snap
+++ b/tasks/coverage/snapshots/parser_misc.snap
@@ -159,9 +159,9 @@ Negative Passed: 20/20 (100.00%)
    ╰────
 
   × Expected a semicolon or an implicit semicolon after a statement, but found none
-   ╭─[misc/fail/oxc-4111-1.js:1:35]
+   ╭─[misc/fail/oxc-4111-1.js:1:18]
  1 │ funtransientction as longciiConÞr>ol(cde) {
-   ·                                  ▲
+   ·                  ▲
    ╰────
   help: Try insert a semicolon here
 
diff --git a/tasks/coverage/snapshots/parser_typescript.snap b/tasks/coverage/snapshots/parser_typescript.snap
index cd4dbec7cb8c7..a72ca1a3856d2 100644
--- a/tasks/coverage/snapshots/parser_typescript.snap
+++ b/tasks/coverage/snapshots/parser_typescript.snap
@@ -3,7 +3,7 @@ commit: a709f989
 parser_typescript Summary:
 AST Parsed     : 6470/6479 (99.86%)
 Positive Passed: 6459/6479 (99.69%)
-Negative Passed: 1235/5715 (21.61%)
+Negative Passed: 1236/5715 (21.63%)
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/compiler/ClassDeclaration10.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/compiler/ClassDeclaration11.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/compiler/ClassDeclaration13.ts
@@ -3130,7 +3130,6 @@ Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressio
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfactionWithDefaultExport.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_contextualTyping2.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_errorLocations1.ts
-Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_js.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_optionalMemberConformance.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_propNameConstraining.ts
 Expect Syntax Error: tasks/coverage/typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_propertyNameFulfillment.ts
@@ -8491,11 +8490,13 @@ Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/salsa/private
  2 │ Foo<number>(1);
    ╰────
 
-  × Expected `<` but found `EOF`
-   ╭─[typescript/tests/cases/compiler/jsFileCompilationTypeAssertions.ts:2:27]
+  × Expected a semicolon or an implicit semicolon after a statement, but found none
+   ╭─[typescript/tests/cases/compiler/jsFileCompilationTypeAssertions.ts:1:2]
  1 │ 0 as number;
+   ·  ▲
  2 │ var v = <string>undefined;
    ╰────
+  help: Try insert a semicolon here
 
   × Expected `,` but found `:`
    ╭─[typescript/tests/cases/compiler/jsFileCompilationTypeOfParameter.ts:1:13]
@@ -18681,6 +18682,13 @@ Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/salsa/private
    ╰────
   help: Try insert a semicolon here
 
+  × Expected a semicolon or an implicit semicolon after a statement, but found none
+   ╭─[typescript/tests/cases/conformance/expressions/typeSatisfaction/typeSatisfaction_js.ts:1:18]
+ 1 │ var v = undefined satisfies 1;
+   ·                  ▲
+   ╰────
+  help: Try insert a semicolon here
+
   × Expected a semicolon or an implicit semicolon after a statement, but found none
    ╭─[typescript/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorInvalidOperations.ts:5:10]
  4 │ // operand before ~

From 4d8bc8c8af7388803d05303d4562e0cee6c01bef Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 03:39:38 +0000
Subject: [PATCH 12/24] perf(parser): precompute `is_typescript` (#6443)

---
 crates/oxc_parser/src/js/arrow.rs       |  2 +-
 crates/oxc_parser/src/js/binding.rs     |  5 ++---
 crates/oxc_parser/src/js/class.rs       | 11 ++++------
 crates/oxc_parser/src/js/declaration.rs |  2 +-
 crates/oxc_parser/src/js/expression.rs  |  9 ++++----
 crates/oxc_parser/src/js/function.rs    |  4 ++--
 crates/oxc_parser/src/js/module.rs      | 28 ++++++++++---------------
 crates/oxc_parser/src/js/object.rs      |  2 +-
 crates/oxc_parser/src/js/statement.rs   |  4 ++--
 crates/oxc_parser/src/jsx/mod.rs        |  3 +--
 crates/oxc_parser/src/lib.rs            | 10 ++++-----
 crates/oxc_parser/src/ts/statement.rs   |  4 ++--
 crates/oxc_parser/src/ts/types.rs       |  8 +++----
 13 files changed, 40 insertions(+), 52 deletions(-)

diff --git a/crates/oxc_parser/src/js/arrow.rs b/crates/oxc_parser/src/js/arrow.rs
index 632d5cc71f72d..4f536b8ab2cb5 100644
--- a/crates/oxc_parser/src/js/arrow.rs
+++ b/crates/oxc_parser/src/js/arrow.rs
@@ -79,7 +79,7 @@ impl<'a> ParserImpl<'a> {
                     Kind::RParen => {
                         let third = self.nth_kind(offset + 2);
                         return match third {
-                            Kind::Colon if self.ts_enabled() => Tristate::Maybe,
+                            Kind::Colon if self.is_ts => Tristate::Maybe,
                             Kind::Arrow | Kind::LCurly => Tristate::True,
                             _ => Tristate::False,
                         };
diff --git a/crates/oxc_parser/src/js/binding.rs b/crates/oxc_parser/src/js/binding.rs
index af0b05cddf707..07df82ee1c984 100644
--- a/crates/oxc_parser/src/js/binding.rs
+++ b/crates/oxc_parser/src/js/binding.rs
@@ -19,8 +19,7 @@ impl<'a> ParserImpl<'a> {
         allow_question: bool,
     ) -> Result<BindingPattern<'a>> {
         let mut kind = self.parse_binding_pattern_kind()?;
-        let optional =
-            if allow_question && self.ts_enabled() { self.eat(Kind::Question) } else { false };
+        let optional = if allow_question && self.is_ts { self.eat(Kind::Question) } else { false };
         let type_annotation = self.parse_ts_type_annotation()?;
         if let Some(type_annotation) = &type_annotation {
             Self::extend_binding_pattern_span_end(type_annotation.span, &mut kind);
@@ -111,7 +110,7 @@ impl<'a> ParserImpl<'a> {
 
         let kind = self.parse_binding_pattern_kind()?;
         // Rest element does not allow `?`, checked in checker/typescript.rs
-        if self.at(Kind::Question) && self.ts_enabled() {
+        if self.at(Kind::Question) && self.is_ts {
             let span = self.cur_token().span();
             self.bump_any();
             self.error(diagnostics::a_rest_parameter_cannot_be_optional(span));
diff --git a/crates/oxc_parser/src/js/class.rs b/crates/oxc_parser/src/js/class.rs
index d8ed536cf7bb4..089bd49e04b63 100644
--- a/crates/oxc_parser/src/js/class.rs
+++ b/crates/oxc_parser/src/js/class.rs
@@ -75,8 +75,7 @@ impl<'a> ParserImpl<'a> {
             None
         };
 
-        let type_parameters =
-            if self.ts_enabled() { self.parse_ts_type_parameters()? } else { None };
+        let type_parameters = if self.is_ts { self.parse_ts_type_parameters()? } else { None };
         let (extends, implements) = self.parse_heritage_clause()?;
         let mut super_class = None;
         let mut super_type_parameters = None;
@@ -283,7 +282,7 @@ impl<'a> ParserImpl<'a> {
 
         if let PropertyKey::PrivateIdentifier(private_ident) = &key {
             // `private #foo`, etc. is illegal
-            if self.ts_enabled() {
+            if self.is_ts {
                 self.verify_modifiers(
                     &modifiers,
                     ModifierFlags::all() - ModifierFlags::ACCESSIBILITY,
@@ -457,8 +456,7 @@ impl<'a> ParserImpl<'a> {
         optional: bool,
         definite: bool,
     ) -> Result<ClassElement<'a>> {
-        let type_annotation =
-            if self.ts_enabled() { self.parse_ts_type_annotation()? } else { None };
+        let type_annotation = if self.is_ts { self.parse_ts_type_annotation()? } else { None };
         let decorators = self.consume_decorators();
         let value = if self.eat(Kind::Eq) { Some(self.parse_expr()?) } else { None };
         self.asi()?;
@@ -506,8 +504,7 @@ impl<'a> ParserImpl<'a> {
         definite: bool,
         accessibility: Option<TSAccessibility>,
     ) -> Result<ClassElement<'a>> {
-        let type_annotation =
-            if self.ts_enabled() { self.parse_ts_type_annotation()? } else { None };
+        let type_annotation = if self.is_ts { self.parse_ts_type_annotation()? } else { None };
         let value =
             self.eat(Kind::Eq).then(|| self.parse_assignment_expression_or_higher()).transpose()?;
         let r#type = if r#abstract {
diff --git a/crates/oxc_parser/src/js/declaration.rs b/crates/oxc_parser/src/js/declaration.rs
index b7d4757b82ca6..ab8f87132e367 100644
--- a/crates/oxc_parser/src/js/declaration.rs
+++ b/crates/oxc_parser/src/js/declaration.rs
@@ -95,7 +95,7 @@ impl<'a> ParserImpl<'a> {
 
         let mut binding_kind = self.parse_binding_pattern_kind()?;
 
-        let (id, definite) = if self.ts_enabled() {
+        let (id, definite) = if self.is_ts {
             // const x!: number = 1
             //        ^ definite
             let mut definite = false;
diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs
index f028f08172052..3edbf02f0230e 100644
--- a/crates/oxc_parser/src/js/expression.rs
+++ b/crates/oxc_parser/src/js/expression.rs
@@ -644,7 +644,7 @@ impl<'a> ParserImpl<'a> {
                         _ => break,
                     }
                 }
-                Kind::Bang if !self.cur_token().is_on_new_line && self.ts_enabled() => {
+                Kind::Bang if !self.cur_token().is_on_new_line && self.is_ts => {
                     self.bump_any();
                     self.ast.expression_ts_non_null(self.end_span(lhs_span), lhs)
                 }
@@ -905,7 +905,7 @@ impl<'a> ParserImpl<'a> {
                 if self.source_type.is_jsx() {
                     return self.parse_jsx_expression();
                 }
-                if self.ts_enabled() {
+                if self.is_ts {
                     return self.parse_ts_type_assertion();
                 }
                 Err(self.unexpected())
@@ -951,13 +951,12 @@ impl<'a> ParserImpl<'a> {
         // Pratt Parsing Algorithm
         // <https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html>
         let mut lhs = lhs;
-        let is_ts = self.ts_enabled();
         loop {
             // re-lex for `>=` `>>` `>>>`
             // This is need for jsx `<div>=</div>` case
             let kind = self.re_lex_right_angle();
 
-            let Some(left_precedence) = kind_to_precedence(kind, is_ts) else { break };
+            let Some(left_precedence) = kind_to_precedence(kind, self.is_ts) else { break };
 
             let stop = if left_precedence.is_right_associative() {
                 left_precedence < min_precedence
@@ -976,7 +975,7 @@ impl<'a> ParserImpl<'a> {
                 break;
             }
 
-            if self.ts_enabled() && matches!(kind, Kind::As | Kind::Satisfies) {
+            if self.is_ts && matches!(kind, Kind::As | Kind::Satisfies) {
                 if self.cur_token().is_on_new_line {
                     break;
                 }
diff --git a/crates/oxc_parser/src/js/function.rs b/crates/oxc_parser/src/js/function.rs
index a5bb794897c43..e204053c46314 100644
--- a/crates/oxc_parser/src/js/function.rs
+++ b/crates/oxc_parser/src/js/function.rs
@@ -47,7 +47,7 @@ impl<'a> ParserImpl<'a> {
     ) -> Result<(Option<TSThisParameter<'a>>, Box<'a, FormalParameters<'a>>)> {
         let span = self.start_span();
         self.expect(Kind::LParen)?;
-        let this_param = if self.ts_enabled() && self.at(Kind::This) {
+        let this_param = if self.is_ts && self.at(Kind::This) {
             let param = self.parse_ts_this_parameter()?;
             if !self.at(Kind::RParen) {
                 self.expect(Kind::Comma)?;
@@ -135,7 +135,7 @@ impl<'a> ParserImpl<'a> {
         self.ctx =
             self.ctx.and_in(ctx.has_in()).and_await(ctx.has_await()).and_yield(ctx.has_yield());
 
-        if !self.ts_enabled() && body.is_none() {
+        if !self.is_ts && body.is_none() {
             return Err(self.unexpected());
         }
 
diff --git a/crates/oxc_parser/src/js/module.rs b/crates/oxc_parser/src/js/module.rs
index 088b4a424a818..82ada7b37b441 100644
--- a/crates/oxc_parser/src/js/module.rs
+++ b/crates/oxc_parser/src/js/module.rs
@@ -34,7 +34,7 @@ impl<'a> ParserImpl<'a> {
 
         self.bump_any(); // advance `import`
 
-        if self.ts_enabled()
+        if self.is_ts
             && ((self.cur_kind().is_binding_identifier() && self.peek_at(Kind::Eq))
                 || (self.at(Kind::Type)
                     && self.peek_kind().is_binding_identifier()
@@ -208,10 +208,10 @@ impl<'a> ParserImpl<'a> {
         self.bump_any(); // advance `export`
 
         let decl = match self.cur_kind() {
-            Kind::Eq if self.ts_enabled() => self
+            Kind::Eq if self.is_ts => self
                 .parse_ts_export_assignment_declaration(span)
                 .map(ModuleDeclaration::TSExportAssignment),
-            Kind::As if self.peek_at(Kind::Namespace) && self.ts_enabled() => self
+            Kind::As if self.peek_at(Kind::Namespace) && self.is_ts => self
                 .parse_ts_export_namespace()
                 .map(ModuleDeclaration::TSNamespaceExportDeclaration),
             Kind::Default => self
@@ -223,7 +223,7 @@ impl<'a> ParserImpl<'a> {
             Kind::LCurly => self
                 .parse_export_named_specifiers(span)
                 .map(ModuleDeclaration::ExportNamedDeclaration),
-            Kind::Type if self.peek_at(Kind::LCurly) && self.ts_enabled() => self
+            Kind::Type if self.peek_at(Kind::LCurly) && self.is_ts => self
                 .parse_export_named_specifiers(span)
                 .map(ModuleDeclaration::ExportNamedDeclaration),
             Kind::Type if self.peek_at(Kind::Star) => {
@@ -328,11 +328,8 @@ impl<'a> ParserImpl<'a> {
         // For tc39/proposal-decorators
         // For more information, please refer to <https://babeljs.io/docs/babel-plugin-proposal-decorators#decoratorsbeforeexport>
         self.eat_decorators()?;
-        let modifiers = if self.ts_enabled() {
-            self.eat_modifiers_before_declaration()?
-        } else {
-            Modifiers::empty()
-        };
+        let modifiers =
+            if self.is_ts { self.eat_modifiers_before_declaration()? } else { Modifiers::empty() };
 
         let declaration = self.parse_declaration(decl_span, &modifiers)?;
         let span = self.end_span(span);
@@ -362,16 +359,13 @@ impl<'a> ParserImpl<'a> {
             Kind::Class => self
                 .parse_class_declaration(decl_span, /* modifiers */ &Modifiers::empty())
                 .map(ExportDefaultDeclarationKind::ClassDeclaration)?,
-            _ if self.at(Kind::Abstract) && self.peek_at(Kind::Class) && self.ts_enabled() => {
+            _ if self.at(Kind::Abstract) && self.peek_at(Kind::Class) && self.is_ts => {
                 // eat the abstract modifier
                 let modifiers = self.eat_modifiers_before_declaration()?;
                 self.parse_class_declaration(decl_span, &modifiers)
                     .map(ExportDefaultDeclarationKind::ClassDeclaration)?
             }
-            _ if self.at(Kind::Interface)
-                && !self.peek_token().is_on_new_line
-                && self.ts_enabled() =>
-            {
+            _ if self.at(Kind::Interface) && !self.peek_token().is_on_new_line && self.is_ts => {
                 self.parse_ts_interface_declaration(decl_span, &Modifiers::empty()).map(|decl| {
                     match decl {
                         Declaration::TSInterfaceDeclaration(decl) => {
@@ -424,7 +418,7 @@ impl<'a> ParserImpl<'a> {
         let specifier_span = self.start_span();
         let peek_kind = self.peek_kind();
         let mut import_kind = ImportOrExportKind::Value;
-        if self.ts_enabled() && self.at(Kind::Type) {
+        if self.is_ts && self.at(Kind::Type) {
             if self.peek_at(Kind::As) {
                 if self.nth_at(2, Kind::As) {
                     if self.nth_kind(3).is_identifier_name() {
@@ -477,7 +471,7 @@ impl<'a> ParserImpl<'a> {
     }
 
     fn parse_import_or_export_kind(&mut self) -> ImportOrExportKind {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return ImportOrExportKind::Value;
         }
         // OK
@@ -521,7 +515,7 @@ impl<'a> ParserImpl<'a> {
         // export { type as as }       // name: `type`    type-export: `false` (aliased to `as`)
         // export { type as as as }    // name: `as`      type-export: `true`, aliased to `as`
         let mut export_kind = ImportOrExportKind::Value;
-        if self.ts_enabled() && self.at(Kind::Type) {
+        if self.is_ts && self.at(Kind::Type) {
             if self.peek_at(Kind::As) {
                 if self.nth_at(2, Kind::As) {
                     if self.nth_at(3, Kind::Str) || self.nth_kind(3).is_identifier_name() {
diff --git a/crates/oxc_parser/src/js/object.rs b/crates/oxc_parser/src/js/object.rs
index f6aaa6e608ac4..71976138f37e0 100644
--- a/crates/oxc_parser/src/js/object.rs
+++ b/crates/oxc_parser/src/js/object.rs
@@ -65,7 +65,7 @@ impl<'a> ParserImpl<'a> {
             // Report and handle illegal modifiers
             // e.g. const x = { public foo() {} }
             modifier_kind
-                if self.ts_enabled()
+                if self.is_ts
                     && modifier_kind.is_modifier_kind()
                     && peek_kind.is_identifier_or_keyword() =>
             {
diff --git a/crates/oxc_parser/src/js/statement.rs b/crates/oxc_parser/src/js/statement.rs
index da4edcee57722..4c9ceafa8cbcf 100644
--- a/crates/oxc_parser/src/js/statement.rs
+++ b/crates/oxc_parser/src/js/statement.rs
@@ -105,7 +105,7 @@ impl<'a> ParserImpl<'a> {
             // [+Return] ReturnStatement[?Yield, ?Await]
             Kind::Return => self.parse_return_statement(),
             Kind::Var => self.parse_variable_statement(stmt_ctx),
-            Kind::Const if !(self.ts_enabled() && self.is_at_enum_declaration()) => {
+            Kind::Const if !(self.is_ts && self.is_at_enum_declaration()) => {
                 self.parse_variable_statement(stmt_ctx)
             }
             Kind::Let if !self.cur_token().escaped() => self.parse_let(stmt_ctx),
@@ -116,7 +116,7 @@ impl<'a> ParserImpl<'a> {
             }
             Kind::Using if self.peek_kind().is_binding_identifier() => self.parse_using(),
             _ if self.at_function_with_async() => self.parse_function_declaration(stmt_ctx),
-            _ if self.ts_enabled() && self.at_start_of_ts_declaration() => {
+            _ if self.is_ts && self.at_start_of_ts_declaration() => {
                 self.parse_ts_declaration_statement(start_span)
             }
             _ => self.parse_expression_or_labeled_statement(),
diff --git a/crates/oxc_parser/src/jsx/mod.rs b/crates/oxc_parser/src/jsx/mod.rs
index 62cd1bccae1f5..6c06b45e88b91 100644
--- a/crates/oxc_parser/src/jsx/mod.rs
+++ b/crates/oxc_parser/src/jsx/mod.rs
@@ -95,8 +95,7 @@ impl<'a> ParserImpl<'a> {
         self.expect(Kind::LAngle)?;
         let name = self.parse_jsx_element_name()?;
         // <Component<TsType> for tsx
-        let type_parameters =
-            if self.ts_enabled() { self.try_parse_type_arguments()? } else { None };
+        let type_parameters = if self.is_ts { self.try_parse_type_arguments()? } else { None };
         let attributes = self.parse_jsx_attributes()?;
         let self_closing = self.eat(Kind::Slash);
         if !self_closing || in_jsx_child {
diff --git a/crates/oxc_parser/src/lib.rs b/crates/oxc_parser/src/lib.rs
index b7f0419dd3775..264771157cf76 100644
--- a/crates/oxc_parser/src/lib.rs
+++ b/crates/oxc_parser/src/lib.rs
@@ -356,8 +356,11 @@ struct ParserImpl<'a> {
     /// Parsing context
     ctx: Context,
 
-    /// Ast builder for creating AST spans
+    /// Ast builder for creating AST nodes
     ast: AstBuilder<'a>,
+
+    /// Precomputed typescript detection
+    is_ts: bool,
 }
 
 impl<'a> ParserImpl<'a> {
@@ -384,6 +387,7 @@ impl<'a> ParserImpl<'a> {
             state: ParserState::default(),
             ctx: Self::default_context(source_type, options),
             ast: AstBuilder::new(allocator),
+            is_ts: source_type.is_typescript(),
         }
     }
 
@@ -508,10 +512,6 @@ impl<'a> ParserImpl<'a> {
         self.errors.len() + self.lexer.errors.len()
     }
 
-    fn ts_enabled(&self) -> bool {
-        self.source_type.is_typescript()
-    }
-
     fn set_source_type_to_module_if_unambiguous(&mut self) {
         if self.source_type.is_unambiguous() {
             self.source_type = self.source_type.with_module(true);
diff --git a/crates/oxc_parser/src/ts/statement.rs b/crates/oxc_parser/src/ts/statement.rs
index ecf6a898ad4f5..6fb24353b15ba 100644
--- a/crates/oxc_parser/src/ts/statement.rs
+++ b/crates/oxc_parser/src/ts/statement.rs
@@ -116,7 +116,7 @@ impl<'a> ParserImpl<'a> {
     pub(crate) fn parse_ts_type_annotation(
         &mut self,
     ) -> Result<Option<Box<'a, TSTypeAnnotation<'a>>>> {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return Ok(None);
         }
         if !self.at(Kind::Colon) {
@@ -398,7 +398,7 @@ impl<'a> ParserImpl<'a> {
                 if declare {
                     self.parse_ts_declare_function(start_span, modifiers)
                         .map(Declaration::FunctionDeclaration)
-                } else if self.ts_enabled() {
+                } else if self.is_ts {
                     self.parse_ts_function_impl(start_span, FunctionKind::Declaration, modifiers)
                         .map(Declaration::FunctionDeclaration)
                 } else {
diff --git a/crates/oxc_parser/src/ts/types.rs b/crates/oxc_parser/src/ts/types.rs
index aa631c26c6b7b..8f09720c159c6 100644
--- a/crates/oxc_parser/src/ts/types.rs
+++ b/crates/oxc_parser/src/ts/types.rs
@@ -138,7 +138,7 @@ impl<'a> ParserImpl<'a> {
     pub(crate) fn parse_ts_type_parameters(
         &mut self,
     ) -> Result<Option<Box<'a, TSTypeParameterDeclaration<'a>>>> {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return Ok(None);
         }
         if !self.at(Kind::LAngle) {
@@ -811,7 +811,7 @@ impl<'a> ParserImpl<'a> {
     pub(crate) fn parse_type_arguments_in_expression(
         &mut self,
     ) -> Result<Option<Box<'a, TSTypeParameterInstantiation<'a>>>> {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return Ok(None);
         }
         let span = self.start_span();
@@ -1049,7 +1049,7 @@ impl<'a> ParserImpl<'a> {
         kind: Kind,
         is_type: bool,
     ) -> Result<Option<Box<'a, TSTypeAnnotation<'a>>>> {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return Ok(None);
         }
         if !self.at(Kind::Colon) {
@@ -1315,7 +1315,7 @@ impl<'a> ParserImpl<'a> {
         &mut self,
         is_constructor_parameter: bool,
     ) -> Modifiers<'a> {
-        if !self.ts_enabled() {
+        if !self.is_ts {
             return Modifiers::empty();
         }
 

From 2b7be08af4ca983a3e5ae53d928b7a31ae357688 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 04:13:41 +0000
Subject: [PATCH 13/24] feat(ast)! add `source_text` to `Program` (#6444)

---
 crates/oxc/README.md                          |  2 +-
 crates/oxc/src/compiler.rs                    | 43 ++++++-------------
 crates/oxc_ast/src/ast/js.rs                  |  2 +
 crates/oxc_ast/src/ast_impl/js.rs             | 14 +-----
 .../oxc_ast/src/generated/assert_layouts.rs   | 22 +++++-----
 crates/oxc_ast/src/generated/ast_builder.rs   | 33 +++++++++++---
 .../oxc_ast/src/generated/derive_clone_in.rs  |  1 +
 .../src/generated/derive_content_eq.rs        |  1 +
 .../src/generated/derive_content_hash.rs      |  1 +
 crates/oxc_isolated_declarations/src/lib.rs   |  3 +-
 crates/oxc_language_server/src/linter.rs      |  2 +-
 crates/oxc_linter/examples/linter.rs          |  2 +-
 crates/oxc_linter/src/service/runtime.rs      |  2 +-
 crates/oxc_linter/src/utils/jest.rs           |  2 +-
 crates/oxc_mangler/src/lib.rs                 |  2 +-
 crates/oxc_minifier/src/compressor.rs         |  2 +-
 crates/oxc_minifier/src/tester.rs             |  2 +-
 crates/oxc_parser/src/lib.rs                  | 10 ++++-
 crates/oxc_semantic/examples/cfg.rs           |  2 +-
 crates/oxc_semantic/examples/simple.rs        |  2 +-
 crates/oxc_semantic/src/builder.rs            | 17 ++++++--
 crates/oxc_semantic/src/jsdoc/builder.rs      |  3 +-
 crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs |  2 +-
 .../src/jsdoc/parser/jsdoc_tag.rs             |  2 +-
 crates/oxc_semantic/src/lib.rs                |  2 +-
 crates/oxc_semantic/src/module_record/mod.rs  |  5 +--
 .../tests/integration/util/mod.rs             |  2 +-
 crates/oxc_semantic/tests/main.rs             |  6 +--
 .../oxc_transformer/examples/transformer.rs   |  4 +-
 crates/oxc_transformer/src/context.rs         |  9 +---
 crates/oxc_transformer/src/lib.rs             |  4 +-
 .../tests/plugins/inject_global_variables.rs  |  6 +--
 .../tests/plugins/replace_global_defines.rs   |  6 +--
 crates/oxc_traverse/src/generated/ancestor.rs | 16 +++++++
 crates/oxc_wasm/src/lib.rs                    | 12 +++---
 tasks/benchmark/benches/linter.rs             |  2 +-
 tasks/benchmark/benches/minifier.rs           |  2 +-
 tasks/benchmark/benches/semantic.rs           |  2 +-
 tasks/benchmark/benches/transformer.rs        | 13 ++----
 tasks/transform_checker/src/lib.rs            |  2 +-
 tasks/transform_conformance/src/driver.rs     |  5 +--
 41 files changed, 143 insertions(+), 129 deletions(-)

diff --git a/crates/oxc/README.md b/crates/oxc/README.md
index e5fb1399df72b..20d07dfaf5dfa 100644
--- a/crates/oxc/README.md
+++ b/crates/oxc/README.md
@@ -99,7 +99,7 @@ if panicked {
 let SemanticBuilderReturn {
     semantic,
     errors: semantic_errors,
-} = SemanticBuilder::new(source_text)
+} = SemanticBuilder::new()
     .with_check_syntax_error(true) // Enable extra syntax error checking
     .with_trivias(trivias)         // Pass comments for JSDoc parsing
     .with_build_jsdoc(true)        // Enable JSDoc parsing
diff --git a/crates/oxc/src/compiler.rs b/crates/oxc/src/compiler.rs
index 6b72e597c43df..30027347a5bea 100644
--- a/crates/oxc/src/compiler.rs
+++ b/crates/oxc/src/compiler.rs
@@ -139,19 +139,12 @@ pub trait CompilerInterface {
 
         /* Isolated Declarations */
         if let Some(options) = self.isolated_declaration_options() {
-            self.isolated_declaration(
-                options,
-                &allocator,
-                &program,
-                source_text,
-                source_path,
-                &trivias,
-            );
+            self.isolated_declaration(options, &allocator, &program, source_path, &trivias);
         }
 
         /* Semantic */
 
-        let mut semantic_return = self.semantic(&program, source_text, source_path);
+        let mut semantic_return = self.semantic(&program, source_path);
         if !semantic_return.errors.is_empty() {
             self.handle_errors(semantic_return.errors);
             return;
@@ -170,7 +163,6 @@ pub trait CompilerInterface {
                 &allocator,
                 &mut program,
                 source_path,
-                source_text,
                 &trivias,
                 symbols,
                 scopes,
@@ -218,7 +210,7 @@ pub trait CompilerInterface {
         /* Codegen */
 
         if let Some(options) = self.codegen_options() {
-            let ret = self.codegen(&program, source_text, source_path, &trivias, mangler, options);
+            let ret = self.codegen(&program, source_path, &trivias, mangler, options);
             self.after_codegen(ret);
         }
     }
@@ -232,13 +224,8 @@ pub trait CompilerInterface {
         Parser::new(allocator, source_text, source_type).with_options(self.parse_options()).parse()
     }
 
-    fn semantic<'a>(
-        &self,
-        program: &Program<'a>,
-        source_text: &'a str,
-        source_path: &Path,
-    ) -> SemanticBuilderReturn<'a> {
-        let mut builder = SemanticBuilder::new(source_text);
+    fn semantic<'a>(&self, program: &Program<'a>, source_path: &Path) -> SemanticBuilderReturn<'a> {
+        let mut builder = SemanticBuilder::new();
 
         if self.transform_options().is_some() {
             // Estimate transformer will triple scopes, symbols, references
@@ -257,16 +244,14 @@ pub trait CompilerInterface {
         options: IsolatedDeclarationsOptions,
         allocator: &'a Allocator,
         program: &Program<'a>,
-        source_text: &'a str,
         source_path: &Path,
         trivias: &Trivias,
     ) {
-        let ret =
-            IsolatedDeclarations::new(allocator, source_text, trivias, options).build(program);
+        let ret = IsolatedDeclarations::new(allocator, program.source_text, trivias, options)
+            .build(program);
         self.handle_errors(ret.errors);
         let ret = self.codegen(
             &ret.program,
-            source_text,
             source_path,
             trivias,
             None,
@@ -282,12 +267,11 @@ pub trait CompilerInterface {
         allocator: &'a Allocator,
         program: &mut Program<'a>,
         source_path: &Path,
-        source_text: &'a str,
         trivias: &Trivias,
         symbols: SymbolTable,
         scopes: ScopeTree,
     ) -> TransformerReturn {
-        Transformer::new(allocator, source_path, source_text, trivias.clone(), options)
+        Transformer::new(allocator, source_path, trivias.clone(), options)
             .build_with_symbols_and_scopes(symbols, scopes, program)
     }
 
@@ -304,10 +288,9 @@ pub trait CompilerInterface {
         Mangler::new().with_options(options).build(program)
     }
 
-    fn codegen<'a>(
+    fn codegen(
         &self,
-        program: &Program<'a>,
-        source_text: &'a str,
+        program: &Program<'_>,
         source_path: &Path,
         trivias: &Trivias,
         mangler: Option<Mangler>,
@@ -317,10 +300,10 @@ pub trait CompilerInterface {
         let mut codegen = CodeGenerator::new()
             .with_options(options)
             .with_mangler(mangler)
-            .enable_comment(source_text, trivias.clone(), comment_options);
+            .enable_comment(program.source_text, trivias.clone(), comment_options);
         if self.enable_sourcemap() {
-            codegen =
-                codegen.enable_source_map(source_path.to_string_lossy().as_ref(), source_text);
+            codegen = codegen
+                .enable_source_map(source_path.to_string_lossy().as_ref(), program.source_text);
         }
         codegen.build(program)
     }
diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs
index e06d43eb38e4a..a68e3911082a0 100644
--- a/crates/oxc_ast/src/ast/js.rs
+++ b/crates/oxc_ast/src/ast/js.rs
@@ -39,6 +39,8 @@ pub struct Program<'a> {
     #[serde(flatten)]
     pub span: Span,
     pub source_type: SourceType,
+    #[serde(skip)]
+    pub source_text: &'a str,
     pub hashbang: Option<Hashbang<'a>>,
     pub directives: Vec<'a, Directive<'a>>,
     pub body: Vec<'a, Statement<'a>>,
diff --git a/crates/oxc_ast/src/ast_impl/js.rs b/crates/oxc_ast/src/ast_impl/js.rs
index c11746f21b938..9aaacb8227760 100644
--- a/crates/oxc_ast/src/ast_impl/js.rs
+++ b/crates/oxc_ast/src/ast_impl/js.rs
@@ -1,7 +1,7 @@
 use std::{borrow::Cow, cell::Cell, fmt};
 
 use oxc_allocator::{Box, FromIn, Vec};
-use oxc_span::{Atom, GetSpan, SourceType, Span};
+use oxc_span::{Atom, GetSpan, Span};
 use oxc_syntax::{
     operator::UnaryOperator,
     reference::ReferenceId,
@@ -28,18 +28,6 @@ export interface FormalParameterRest extends Span {
 }
 "#;
 
-impl<'a> Program<'a> {
-    pub fn new(
-        span: Span,
-        source_type: SourceType,
-        directives: Vec<'a, Directive<'a>>,
-        hashbang: Option<Hashbang<'a>>,
-        body: Vec<'a, Statement<'a>>,
-    ) -> Self {
-        Self { span, source_type, directives, hashbang, body, scope_id: Cell::default() }
-    }
-}
-
 impl<'a> Program<'a> {
     pub fn is_empty(&self) -> bool {
         self.body.is_empty() && self.directives.is_empty()
diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs
index 7969d6dfe8585..ed4f099ca52b0 100644
--- a/crates/oxc_ast/src/generated/assert_layouts.rs
+++ b/crates/oxc_ast/src/generated/assert_layouts.rs
@@ -55,14 +55,15 @@ const _: () = {
     assert!(offset_of!(StringLiteral, span) == 0usize);
     assert!(offset_of!(StringLiteral, value) == 8usize);
 
-    assert!(size_of::<Program>() == 112usize);
+    assert!(size_of::<Program>() == 128usize);
     assert!(align_of::<Program>() == 8usize);
     assert!(offset_of!(Program, span) == 0usize);
     assert!(offset_of!(Program, source_type) == 8usize);
-    assert!(offset_of!(Program, hashbang) == 16usize);
-    assert!(offset_of!(Program, directives) == 40usize);
-    assert!(offset_of!(Program, body) == 72usize);
-    assert!(offset_of!(Program, scope_id) == 104usize);
+    assert!(offset_of!(Program, source_text) == 16usize);
+    assert!(offset_of!(Program, hashbang) == 32usize);
+    assert!(offset_of!(Program, directives) == 56usize);
+    assert!(offset_of!(Program, body) == 88usize);
+    assert!(offset_of!(Program, scope_id) == 120usize);
 
     assert!(size_of::<Expression>() == 16usize);
     assert!(align_of::<Expression>() == 8usize);
@@ -1597,14 +1598,15 @@ const _: () = {
     assert!(offset_of!(StringLiteral, span) == 0usize);
     assert!(offset_of!(StringLiteral, value) == 8usize);
 
-    assert!(size_of::<Program>() == 64usize);
+    assert!(size_of::<Program>() == 72usize);
     assert!(align_of::<Program>() == 4usize);
     assert!(offset_of!(Program, span) == 0usize);
     assert!(offset_of!(Program, source_type) == 8usize);
-    assert!(offset_of!(Program, hashbang) == 12usize);
-    assert!(offset_of!(Program, directives) == 28usize);
-    assert!(offset_of!(Program, body) == 44usize);
-    assert!(offset_of!(Program, scope_id) == 60usize);
+    assert!(offset_of!(Program, source_text) == 12usize);
+    assert!(offset_of!(Program, hashbang) == 20usize);
+    assert!(offset_of!(Program, directives) == 36usize);
+    assert!(offset_of!(Program, body) == 52usize);
+    assert!(offset_of!(Program, scope_id) == 68usize);
 
     assert!(size_of::<Expression>() == 8usize);
     assert!(align_of::<Expression>() == 4usize);
diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
index e0fe52d16d83b..000ed9f5234f6 100644
--- a/crates/oxc_ast/src/generated/ast_builder.rs
+++ b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -221,19 +221,32 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// - span: The [`Span`] covering this node
     /// - source_type
+    /// - source_text
     /// - hashbang
     /// - directives
     /// - body
     #[inline]
-    pub fn program(
+    pub fn program<S>(
         self,
         span: Span,
         source_type: SourceType,
+        source_text: S,
         hashbang: Option<Hashbang<'a>>,
         directives: Vec<'a, Directive<'a>>,
         body: Vec<'a, Statement<'a>>,
-    ) -> Program<'a> {
-        Program { span, source_type, hashbang, directives, body, scope_id: Default::default() }
+    ) -> Program<'a>
+    where
+        S: IntoIn<'a, &'a str>,
+    {
+        Program {
+            span,
+            source_type,
+            source_text: source_text.into_in(self.allocator),
+            hashbang,
+            directives,
+            body,
+            scope_id: Default::default(),
+        }
     }
 
     /// Builds a [`Program`] and stores it in the memory arena.
@@ -243,19 +256,27 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// - span: The [`Span`] covering this node
     /// - source_type
+    /// - source_text
     /// - hashbang
     /// - directives
     /// - body
     #[inline]
-    pub fn alloc_program(
+    pub fn alloc_program<S>(
         self,
         span: Span,
         source_type: SourceType,
+        source_text: S,
         hashbang: Option<Hashbang<'a>>,
         directives: Vec<'a, Directive<'a>>,
         body: Vec<'a, Statement<'a>>,
-    ) -> Box<'a, Program<'a>> {
-        Box::new_in(self.program(span, source_type, hashbang, directives, body), self.allocator)
+    ) -> Box<'a, Program<'a>>
+    where
+        S: IntoIn<'a, &'a str>,
+    {
+        Box::new_in(
+            self.program(span, source_type, source_text, hashbang, directives, body),
+            self.allocator,
+        )
     }
 
     /// Build a [`Expression::BooleanLiteral`]
diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs
index 798007b74b4ff..6f48349f6af21 100644
--- a/crates/oxc_ast/src/generated/derive_clone_in.rs
+++ b/crates/oxc_ast/src/generated/derive_clone_in.rs
@@ -112,6 +112,7 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Program<'old_alloc> {
         Program {
             span: CloneIn::clone_in(&self.span, allocator),
             source_type: CloneIn::clone_in(&self.source_type, allocator),
+            source_text: CloneIn::clone_in(&self.source_text, allocator),
             hashbang: CloneIn::clone_in(&self.hashbang, allocator),
             directives: CloneIn::clone_in(&self.directives, allocator),
             body: CloneIn::clone_in(&self.body, allocator),
diff --git a/crates/oxc_ast/src/generated/derive_content_eq.rs b/crates/oxc_ast/src/generated/derive_content_eq.rs
index 783c23b7c7e79..d85fe2fb7e3f7 100644
--- a/crates/oxc_ast/src/generated/derive_content_eq.rs
+++ b/crates/oxc_ast/src/generated/derive_content_eq.rs
@@ -92,6 +92,7 @@ impl<'a> ContentEq for StringLiteral<'a> {
 impl<'a> ContentEq for Program<'a> {
     fn content_eq(&self, other: &Self) -> bool {
         ContentEq::content_eq(&self.source_type, &other.source_type)
+            && ContentEq::content_eq(&self.source_text, &other.source_text)
             && ContentEq::content_eq(&self.hashbang, &other.hashbang)
             && ContentEq::content_eq(&self.directives, &other.directives)
             && ContentEq::content_eq(&self.body, &other.body)
diff --git a/crates/oxc_ast/src/generated/derive_content_hash.rs b/crates/oxc_ast/src/generated/derive_content_hash.rs
index dfe5280b67d5f..82f89e9bac5d9 100644
--- a/crates/oxc_ast/src/generated/derive_content_hash.rs
+++ b/crates/oxc_ast/src/generated/derive_content_hash.rs
@@ -70,6 +70,7 @@ impl<'a> ContentHash for StringLiteral<'a> {
 impl<'a> ContentHash for Program<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
         ContentHash::content_hash(&self.source_type, state);
+        ContentHash::content_hash(&self.source_text, state);
         ContentHash::content_hash(&self.hashbang, state);
         ContentHash::content_hash(&self.directives, state);
         ContentHash::content_hash(&self.body, state);
diff --git a/crates/oxc_isolated_declarations/src/lib.rs b/crates/oxc_isolated_declarations/src/lib.rs
index a057a516a5d85..acb5f0be76fe6 100644
--- a/crates/oxc_isolated_declarations/src/lib.rs
+++ b/crates/oxc_isolated_declarations/src/lib.rs
@@ -92,7 +92,8 @@ impl<'a> IsolatedDeclarations<'a> {
         let source_type = SourceType::d_ts();
         let directives = self.ast.vec();
         let stmts = self.transform_program(program);
-        let program = self.ast.program(SPAN, source_type, None, directives, stmts);
+        let program =
+            self.ast.program(SPAN, source_type, program.source_text, None, directives, stmts);
         IsolatedDeclarationsReturn { program, errors: self.take_errors() }
     }
 
diff --git a/crates/oxc_language_server/src/linter.rs b/crates/oxc_language_server/src/linter.rs
index 8cf40c4e3cac8..6bc98d6b1c3f1 100644
--- a/crates/oxc_language_server/src/linter.rs
+++ b/crates/oxc_language_server/src/linter.rs
@@ -260,7 +260,7 @@ impl IsolatedLintHandler {
             };
 
             let program = allocator.alloc(ret.program);
-            let semantic_ret = SemanticBuilder::new(javascript_source_text)
+            let semantic_ret = SemanticBuilder::new()
                 .with_cfg(true)
                 .with_trivias(ret.trivias)
                 .with_check_syntax_error(true)
diff --git a/crates/oxc_linter/examples/linter.rs b/crates/oxc_linter/examples/linter.rs
index be0ae5575bd2b..c93dbef31ac13 100644
--- a/crates/oxc_linter/examples/linter.rs
+++ b/crates/oxc_linter/examples/linter.rs
@@ -30,7 +30,7 @@ fn main() -> std::io::Result<()> {
     }
 
     let program = allocator.alloc(ret.program);
-    let semantic_ret = SemanticBuilder::new(&source_text).with_trivias(ret.trivias).build(program);
+    let semantic_ret = SemanticBuilder::new().with_trivias(ret.trivias).build(program);
 
     let mut errors: Vec<OxcDiagnostic> = vec![];
 
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
index ab9d4542e372a..1820efb090099 100644
--- a/crates/oxc_linter/src/service/runtime.rs
+++ b/crates/oxc_linter/src/service/runtime.rs
@@ -208,7 +208,7 @@ impl Runtime {
 
         // Build the module record to unblock other threads from waiting for too long.
         // The semantic model is not built at this stage.
-        let semantic_builder = SemanticBuilder::new(source_text)
+        let semantic_builder = SemanticBuilder::new()
             .with_cfg(true)
             .with_trivias(trivias)
             .with_build_jsdoc(true)
diff --git a/crates/oxc_linter/src/utils/jest.rs b/crates/oxc_linter/src/utils/jest.rs
index 2479167e50988..27a61b9f02c3a 100644
--- a/crates/oxc_linter/src/utils/jest.rs
+++ b/crates/oxc_linter/src/utils/jest.rs
@@ -318,7 +318,7 @@ mod test {
         let source_type = SourceType::default();
         let parser_ret = Parser::new(&allocator, "", source_type).parse();
         let program = allocator.alloc(parser_ret.program);
-        let semantic_ret = SemanticBuilder::new("").with_cfg(true).build(program).semantic;
+        let semantic_ret = SemanticBuilder::new().with_cfg(true).build(program).semantic;
         let semantic_ret = Rc::new(semantic_ret);
 
         let build_ctx = |path: &'static str| {
diff --git a/crates/oxc_mangler/src/lib.rs b/crates/oxc_mangler/src/lib.rs
index 22034deffa8fb..94202715d3bc3 100644
--- a/crates/oxc_mangler/src/lib.rs
+++ b/crates/oxc_mangler/src/lib.rs
@@ -82,7 +82,7 @@ impl Mangler {
 
     #[must_use]
     pub fn build<'a>(mut self, program: &'a Program<'a>) -> Mangler {
-        let semantic = SemanticBuilder::new("").build(program).semantic;
+        let semantic = SemanticBuilder::new().build(program).semantic;
 
         // Mangle the symbol table by computing slots from the scope tree.
         // A slot is the occurrence index of a binding identifier inside a scope.
diff --git a/crates/oxc_minifier/src/compressor.rs b/crates/oxc_minifier/src/compressor.rs
index 6f7188a55b634..f722a2266a420 100644
--- a/crates/oxc_minifier/src/compressor.rs
+++ b/crates/oxc_minifier/src/compressor.rs
@@ -24,7 +24,7 @@ impl<'a> Compressor<'a> {
 
     pub fn build(self, program: &mut Program<'a>) {
         let (symbols, scopes) =
-            SemanticBuilder::new("").build(program).semantic.into_symbol_table_and_scope_tree();
+            SemanticBuilder::new().build(program).semantic.into_symbol_table_and_scope_tree();
         self.build_with_symbols_and_scopes(symbols, scopes, program);
     }
 
diff --git a/crates/oxc_minifier/src/tester.rs b/crates/oxc_minifier/src/tester.rs
index e159d0036f0b9..6daeec5369eb2 100644
--- a/crates/oxc_minifier/src/tester.rs
+++ b/crates/oxc_minifier/src/tester.rs
@@ -28,7 +28,7 @@ fn run<'a, P: CompressorPass<'a>>(
 
     if let Some(pass) = pass {
         let (symbols, scopes) =
-            SemanticBuilder::new("").build(&program).semantic.into_symbol_table_and_scope_tree();
+            SemanticBuilder::new().build(&program).semantic.into_symbol_table_and_scope_tree();
         let mut ctx = TraverseCtx::new(scopes, symbols, allocator);
         RemoveSyntax::new(CompressOptions::all_false()).build(&mut program, &mut ctx);
         pass.build(&mut program, &mut ctx);
diff --git a/crates/oxc_parser/src/lib.rs b/crates/oxc_parser/src/lib.rs
index 264771157cf76..6f115f8945160 100644
--- a/crates/oxc_parser/src/lib.rs
+++ b/crates/oxc_parser/src/lib.rs
@@ -404,6 +404,7 @@ impl<'a> ParserImpl<'a> {
                 let program = self.ast.program(
                     Span::default(),
                     self.source_type,
+                    self.source_text,
                     None,
                     self.ast.vec(),
                     self.ast.vec(),
@@ -450,7 +451,14 @@ impl<'a> ParserImpl<'a> {
         self.set_source_type_to_script_if_unambiguous();
 
         let span = Span::new(0, self.source_text.len() as u32);
-        Ok(self.ast.program(span, self.source_type, hashbang, directives, statements))
+        Ok(self.ast.program(
+            span,
+            self.source_type,
+            self.source_text,
+            hashbang,
+            directives,
+            statements,
+        ))
     }
 
     fn default_context(source_type: SourceType, options: ParseOptions) -> Context {
diff --git a/crates/oxc_semantic/examples/cfg.rs b/crates/oxc_semantic/examples/cfg.rs
index 02e4a3abb7a6c..e3a94b4ca3451 100644
--- a/crates/oxc_semantic/examples/cfg.rs
+++ b/crates/oxc_semantic/examples/cfg.rs
@@ -55,7 +55,7 @@ fn main() -> std::io::Result<()> {
     std::fs::write(ast_file_path, format!("{:#?}", &program))?;
     println!("Wrote AST to: {}", &ast_file_name);
 
-    let semantic = SemanticBuilder::new(&source_text)
+    let semantic = SemanticBuilder::new()
         .with_check_syntax_error(true)
         .with_trivias(parser_ret.trivias)
         .with_cfg(true)
diff --git a/crates/oxc_semantic/examples/simple.rs b/crates/oxc_semantic/examples/simple.rs
index 890b5abb8ba55..29609e2a079bd 100644
--- a/crates/oxc_semantic/examples/simple.rs
+++ b/crates/oxc_semantic/examples/simple.rs
@@ -34,7 +34,7 @@ fn main() -> std::io::Result<()> {
 
     let program = allocator.alloc(parser_ret.program);
 
-    let semantic = SemanticBuilder::new(&source_text)
+    let semantic = SemanticBuilder::new()
         .build_module_record(path, program)
         // Enable additional syntax checks not performed by the parser
         .with_check_syntax_error(true)
diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs
index b8ec6c94ebd81..45aa581730d40 100644
--- a/crates/oxc_semantic/src/builder.rs
+++ b/crates/oxc_semantic/src/builder.rs
@@ -119,14 +119,20 @@ pub struct SemanticBuilderReturn<'a> {
     pub errors: Vec<OxcDiagnostic>,
 }
 
+impl<'a> Default for SemanticBuilder<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<'a> SemanticBuilder<'a> {
-    pub fn new(source_text: &'a str) -> Self {
+    pub fn new() -> Self {
         let scope = ScopeTree::default();
         let current_scope_id = scope.root_scope_id();
 
         let trivias = Trivias::default();
         Self {
-            source_text,
+            source_text: "",
             source_type: SourceType::default(),
             trivias: trivias.clone(),
             errors: RefCell::new(vec![]),
@@ -145,7 +151,7 @@ impl<'a> SemanticBuilder<'a> {
             module_record: Arc::new(ModuleRecord::default()),
             unused_labels: UnusedLabels::default(),
             build_jsdoc: false,
-            jsdoc: JSDocBuilder::new(source_text, &trivias),
+            jsdoc: JSDocBuilder::default(),
             stats: None,
             excess_capacity: 0.0,
             check_syntax_error: false,
@@ -178,7 +184,6 @@ impl<'a> SemanticBuilder<'a> {
     /// `with_trivias` must be called prior to this call.
     #[must_use]
     pub fn with_build_jsdoc(mut self, yes: bool) -> Self {
-        self.jsdoc = JSDocBuilder::new(self.source_text, &self.trivias);
         self.build_jsdoc = yes;
         self
     }
@@ -252,7 +257,11 @@ impl<'a> SemanticBuilder<'a> {
     ///
     /// # Panics
     pub fn build(mut self, program: &Program<'a>) -> SemanticBuilderReturn<'a> {
+        self.source_text = program.source_text;
         self.source_type = program.source_type;
+        if self.build_jsdoc {
+            self.jsdoc = JSDocBuilder::new(self.source_text, &self.trivias);
+        }
         if self.source_type.is_typescript_definition() {
             let scope_id = self.scope.add_scope(None, NodeId::DUMMY, ScopeFlags::Top);
             program.scope_id.set(Some(scope_id));
diff --git a/crates/oxc_semantic/src/jsdoc/builder.rs b/crates/oxc_semantic/src/jsdoc/builder.rs
index 62a8fe2872364..9ae9fb384c108 100644
--- a/crates/oxc_semantic/src/jsdoc/builder.rs
+++ b/crates/oxc_semantic/src/jsdoc/builder.rs
@@ -7,6 +7,7 @@ use crate::jsdoc::JSDocFinder;
 
 use super::parser::JSDoc;
 
+#[derive(Default)]
 pub struct JSDocBuilder<'a> {
     not_attached_docs: FxHashMap<u32, Vec<JSDoc<'a>>>,
     attached_docs: FxHashMap<u32, Vec<JSDoc<'a>>>,
@@ -207,7 +208,7 @@ mod test {
         let source_type = source_type.unwrap_or_default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new(source_text)
+        let semantic = SemanticBuilder::new()
             .with_trivias(ret.trivias)
             .with_build_jsdoc(true)
             .build(program)
diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
index 8a892968008e1..ddd8d3c757e55 100644
--- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
+++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
@@ -46,7 +46,7 @@ mod test {
         let source_type = SourceType::default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new(source_text)
+        let semantic = SemanticBuilder::new()
             .with_trivias(ret.trivias)
             .with_build_jsdoc(true)
             .build(program)
diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
index fbee06e55273b..de79328e0a4ca 100644
--- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
+++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
@@ -195,7 +195,7 @@ mod test {
         let source_type = SourceType::default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new(source_text)
+        let semantic = SemanticBuilder::new()
             .with_trivias(ret.trivias)
             .with_build_jsdoc(true)
             .build(program)
diff --git a/crates/oxc_semantic/src/lib.rs b/crates/oxc_semantic/src/lib.rs
index f863183136fe6..65db5557fb02b 100644
--- a/crates/oxc_semantic/src/lib.rs
+++ b/crates/oxc_semantic/src/lib.rs
@@ -230,7 +230,7 @@ mod tests {
         let parse = oxc_parser::Parser::new(allocator, source, source_type).parse();
         assert!(parse.errors.is_empty());
         let program = allocator.alloc(parse.program);
-        let semantic = SemanticBuilder::new(source).build(program);
+        let semantic = SemanticBuilder::new().build(program);
         assert!(semantic.errors.is_empty(), "Parse error: {}", semantic.errors[0]);
         semantic.semantic
     }
diff --git a/crates/oxc_semantic/src/module_record/mod.rs b/crates/oxc_semantic/src/module_record/mod.rs
index 28a67df331d93..879aaeae2856a 100644
--- a/crates/oxc_semantic/src/module_record/mod.rs
+++ b/crates/oxc_semantic/src/module_record/mod.rs
@@ -19,9 +19,8 @@ mod module_record_tests {
         let allocator = Allocator::default();
         let ret = Parser::new(&allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic_ret = SemanticBuilder::new(source_text)
-            .build_module_record(Path::new(""), program)
-            .build(program);
+        let semantic_ret =
+            SemanticBuilder::new().build_module_record(Path::new(""), program).build(program);
         Arc::clone(&semantic_ret.semantic.module_record)
     }
 
diff --git a/crates/oxc_semantic/tests/integration/util/mod.rs b/crates/oxc_semantic/tests/integration/util/mod.rs
index 1ba05e62bf243..505739d46f3f2 100644
--- a/crates/oxc_semantic/tests/integration/util/mod.rs
+++ b/crates/oxc_semantic/tests/integration/util/mod.rs
@@ -167,7 +167,7 @@ impl<'a> SemanticTester<'a> {
         );
 
         let program = self.allocator.alloc(parse.program);
-        SemanticBuilder::new(self.source_text)
+        SemanticBuilder::new()
             .with_check_syntax_error(true)
             .with_trivias(parse.trivias)
             .with_cfg(self.cfg)
diff --git a/crates/oxc_semantic/tests/main.rs b/crates/oxc_semantic/tests/main.rs
index 000d394a08d59..ad755bfb85500 100644
--- a/crates/oxc_semantic/tests/main.rs
+++ b/crates/oxc_semantic/tests/main.rs
@@ -123,10 +123,8 @@ fn analyze(path: &Path, source_text: &str, conformance_suite: &SemanticConforman
     let source_type = SourceType::from_path(path).unwrap();
 
     let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let semantic = SemanticBuilder::new(source_text)
-        .with_check_syntax_error(true)
-        .build(&ret.program)
-        .semantic;
+    let semantic =
+        SemanticBuilder::new().with_check_syntax_error(true).build(&ret.program).semantic;
 
     let ctx = TestContext { path, semantic };
 
diff --git a/crates/oxc_transformer/examples/transformer.rs b/crates/oxc_transformer/examples/transformer.rs
index 410d0feb41ba4..a99222b468304 100644
--- a/crates/oxc_transformer/examples/transformer.rs
+++ b/crates/oxc_transformer/examples/transformer.rs
@@ -40,7 +40,7 @@ fn main() {
     let mut program = ret.program;
     let trivias = ret.trivias;
 
-    let ret = SemanticBuilder::new(&source_text)
+    let ret = SemanticBuilder::new()
         // Estimate transformer will triple scopes, symbols, references
         .with_excess_capacity(2.0)
         .build(&program);
@@ -65,7 +65,7 @@ fn main() {
         TransformOptions::enable_all()
     };
 
-    let ret = Transformer::new(&allocator, path, &source_text, trivias.clone(), transform_options)
+    let ret = Transformer::new(&allocator, path, trivias.clone(), transform_options)
         .build_with_symbols_and_scopes(symbols, scopes, &mut program);
 
     if !ret.errors.is_empty() {
diff --git a/crates/oxc_transformer/src/context.rs b/crates/oxc_transformer/src/context.rs
index 3f0b166a011b6..aba1ec3c57b13 100644
--- a/crates/oxc_transformer/src/context.rs
+++ b/crates/oxc_transformer/src/context.rs
@@ -41,12 +41,7 @@ pub struct TransformCtx<'a> {
 }
 
 impl<'a> TransformCtx<'a> {
-    pub fn new(
-        source_path: &Path,
-        source_text: &'a str,
-        trivias: Trivias,
-        options: &TransformOptions,
-    ) -> Self {
+    pub fn new(source_path: &Path, trivias: Trivias, options: &TransformOptions) -> Self {
         let filename = source_path
             .file_stem() // omit file extension
             .map_or_else(|| String::from("unknown"), |name| name.to_string_lossy().to_string());
@@ -60,7 +55,7 @@ impl<'a> TransformCtx<'a> {
             filename,
             source_path,
             source_type: SourceType::default(),
-            source_text,
+            source_text: "",
             trivias,
             module_imports: ModuleImportsStore::new(),
             var_declarations: VarDeclarationsStore::new(),
diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs
index a9f502ebb47af..ea92aa0d89628 100644
--- a/crates/oxc_transformer/src/lib.rs
+++ b/crates/oxc_transformer/src/lib.rs
@@ -72,11 +72,10 @@ impl<'a> Transformer<'a> {
     pub fn new(
         allocator: &'a Allocator,
         source_path: &Path,
-        source_text: &'a str,
         trivias: Trivias,
         options: TransformOptions,
     ) -> Self {
-        let ctx = TransformCtx::new(source_path, source_text, trivias, &options);
+        let ctx = TransformCtx::new(source_path, trivias, &options);
         Self { ctx, options, allocator }
     }
 
@@ -90,6 +89,7 @@ impl<'a> Transformer<'a> {
         let ast_builder = AstBuilder::new(allocator);
 
         self.ctx.source_type = program.source_type;
+        self.ctx.source_text = program.source_text;
         react::update_options_with_comments(&mut self.options, &self.ctx);
 
         let mut transformer = TransformerImpl {
diff --git a/crates/oxc_transformer/tests/plugins/inject_global_variables.rs b/crates/oxc_transformer/tests/plugins/inject_global_variables.rs
index b34ef5aea1482..015664ecc0149 100644
--- a/crates/oxc_transformer/tests/plugins/inject_global_variables.rs
+++ b/crates/oxc_transformer/tests/plugins/inject_global_variables.rs
@@ -16,10 +16,8 @@ pub(crate) fn test(source_text: &str, expected: &str, config: InjectGlobalVariab
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = allocator.alloc(ret.program);
-    let (symbols, scopes) = SemanticBuilder::new(source_text)
-        .build(program)
-        .semantic
-        .into_symbol_table_and_scope_tree();
+    let (symbols, scopes) =
+        SemanticBuilder::new().build(program).semantic.into_symbol_table_and_scope_tree();
     let _ = InjectGlobalVariables::new(&allocator, config).build(symbols, scopes, program);
     let result = CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
diff --git a/crates/oxc_transformer/tests/plugins/replace_global_defines.rs b/crates/oxc_transformer/tests/plugins/replace_global_defines.rs
index 9fa7aec2293df..b5e15b333e4ac 100644
--- a/crates/oxc_transformer/tests/plugins/replace_global_defines.rs
+++ b/crates/oxc_transformer/tests/plugins/replace_global_defines.rs
@@ -12,10 +12,8 @@ pub(crate) fn test(source_text: &str, expected: &str, config: ReplaceGlobalDefin
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = allocator.alloc(ret.program);
-    let (symbols, scopes) = SemanticBuilder::new(source_text)
-        .build(program)
-        .semantic
-        .into_symbol_table_and_scope_tree();
+    let (symbols, scopes) =
+        SemanticBuilder::new().build(program).semantic.into_symbol_table_and_scope_tree();
     let _ = ReplaceGlobalDefines::new(&allocator, config).build(symbols, scopes, program);
     let result = CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
diff --git a/crates/oxc_traverse/src/generated/ancestor.rs b/crates/oxc_traverse/src/generated/ancestor.rs
index 0dbe693eb8e5e..44327c49900b6 100644
--- a/crates/oxc_traverse/src/generated/ancestor.rs
+++ b/crates/oxc_traverse/src/generated/ancestor.rs
@@ -2201,6 +2201,7 @@ impl<'a, 't> Ancestor<'a, 't> {
 
 pub(crate) const OFFSET_PROGRAM_SPAN: usize = offset_of!(Program, span);
 pub(crate) const OFFSET_PROGRAM_SOURCE_TYPE: usize = offset_of!(Program, source_type);
+pub(crate) const OFFSET_PROGRAM_SOURCE_TEXT: usize = offset_of!(Program, source_text);
 pub(crate) const OFFSET_PROGRAM_HASHBANG: usize = offset_of!(Program, hashbang);
 pub(crate) const OFFSET_PROGRAM_DIRECTIVES: usize = offset_of!(Program, directives);
 pub(crate) const OFFSET_PROGRAM_BODY: usize = offset_of!(Program, body);
@@ -2224,6 +2225,11 @@ impl<'a, 't> ProgramWithoutHashbang<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TYPE) as *const SourceType) }
     }
 
+    #[inline]
+    pub fn source_text(self) -> &'t &'a str {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
+    }
+
     #[inline]
     pub fn directives(self) -> &'t Vec<'a, Directive<'a>> {
         unsafe {
@@ -2265,6 +2271,11 @@ impl<'a, 't> ProgramWithoutDirectives<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TYPE) as *const SourceType) }
     }
 
+    #[inline]
+    pub fn source_text(self) -> &'t &'a str {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
+    }
+
     #[inline]
     pub fn hashbang(self) -> &'t Option<Hashbang<'a>> {
         unsafe {
@@ -2305,6 +2316,11 @@ impl<'a, 't> ProgramWithoutBody<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TYPE) as *const SourceType) }
     }
 
+    #[inline]
+    pub fn source_text(self) -> &'t &'a str {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
+    }
+
     #[inline]
     pub fn hashbang(self) -> &'t Option<Hashbang<'a>> {
         unsafe {
diff --git a/crates/oxc_wasm/src/lib.rs b/crates/oxc_wasm/src/lib.rs
index ef245fd626502..65ebccc4c63f7 100644
--- a/crates/oxc_wasm/src/lib.rs
+++ b/crates/oxc_wasm/src/lib.rs
@@ -197,7 +197,7 @@ impl Oxc {
         self.ir = format!("{:#?}", program.body);
         self.ast = program.serialize(&self.serializer)?;
 
-        let mut semantic_builder = SemanticBuilder::new(source_text);
+        let mut semantic_builder = SemanticBuilder::new();
         if run_options.transform.unwrap_or_default() {
             // Estimate transformer will triple scopes, symbols, references
             semantic_builder = semantic_builder.with_excess_capacity(2.0);
@@ -221,7 +221,7 @@ impl Oxc {
             );
         }
 
-        self.run_linter(&run_options, source_text, &path, &trivias, &program);
+        self.run_linter(&run_options, &path, &trivias, &program);
 
         self.run_prettier(&run_options, source_text, source_type);
 
@@ -241,9 +241,8 @@ impl Oxc {
                 targets: Targets::from_query("chrome 51"),
                 ..EnvOptions::default()
             }) {
-                let result =
-                    Transformer::new(&allocator, &path, source_text, trivias.clone(), options)
-                        .build_with_symbols_and_scopes(symbols, scopes, &mut program);
+                let result = Transformer::new(&allocator, &path, trivias.clone(), options)
+                    .build_with_symbols_and_scopes(symbols, scopes, &mut program);
                 if !result.errors.is_empty() {
                     self.save_diagnostics(
                         result.errors.into_iter().map(Error::from).collect::<Vec<_>>(),
@@ -293,14 +292,13 @@ impl Oxc {
     fn run_linter(
         &mut self,
         run_options: &OxcRunOptions,
-        source_text: &str,
         path: &Path,
         trivias: &Trivias,
         program: &Program,
     ) {
         // Only lint if there are no syntax errors
         if run_options.lint.unwrap_or_default() && self.diagnostics.borrow().is_empty() {
-            let semantic_ret = SemanticBuilder::new(source_text)
+            let semantic_ret = SemanticBuilder::new()
                 .with_cfg(true)
                 .with_trivias(trivias.clone())
                 .build_module_record(path, program)
diff --git a/tasks/benchmark/benches/linter.rs b/tasks/benchmark/benches/linter.rs
index 19089074e7aa1..d3f25a9b97e6c 100644
--- a/tasks/benchmark/benches/linter.rs
+++ b/tasks/benchmark/benches/linter.rs
@@ -28,7 +28,7 @@ fn bench_linter(criterion: &mut Criterion) {
                 let allocator = Allocator::default();
                 let ret = Parser::new(&allocator, source_text, source_type).parse();
                 let program = allocator.alloc(ret.program);
-                let semantic_ret = SemanticBuilder::new(source_text)
+                let semantic_ret = SemanticBuilder::new()
                     .with_trivias(ret.trivias)
                     .with_build_jsdoc(true)
                     .with_cfg(true)
diff --git a/tasks/benchmark/benches/minifier.rs b/tasks/benchmark/benches/minifier.rs
index 2d600f85626ec..cffac57cf136b 100644
--- a/tasks/benchmark/benches/minifier.rs
+++ b/tasks/benchmark/benches/minifier.rs
@@ -26,7 +26,7 @@ fn bench_minifier(criterion: &mut Criterion) {
                 // Create fresh AST + semantic data for each iteration
                 let program = Parser::new(&allocator, source_text, source_type).parse().program;
                 let program = allocator.alloc(program);
-                let (symbols, scopes) = SemanticBuilder::new(source_text)
+                let (symbols, scopes) = SemanticBuilder::new()
                     .build(program)
                     .semantic
                     .into_symbol_table_and_scope_tree();
diff --git a/tasks/benchmark/benches/semantic.rs b/tasks/benchmark/benches/semantic.rs
index ca7a58d601632..bc8823e1d8556 100644
--- a/tasks/benchmark/benches/semantic.rs
+++ b/tasks/benchmark/benches/semantic.rs
@@ -23,7 +23,7 @@ fn bench_semantic(criterion: &mut Criterion) {
                     // We return `error`s to be dropped outside of the measured section, as usually
                     // code would have no errors. One of our benchmarks `cal.com.tsx` has a lot of errors,
                     // but that's atypical, so don't want to include it in benchmark time.
-                    let ret = SemanticBuilder::new(source_text)
+                    let ret = SemanticBuilder::new()
                         .with_trivias(ret.trivias.clone())
                         .with_build_jsdoc(true)
                         .build_module_record(Path::new(""), program)
diff --git a/tasks/benchmark/benches/transformer.rs b/tasks/benchmark/benches/transformer.rs
index ea764b3f55719..b83698f667c0c 100644
--- a/tasks/benchmark/benches/transformer.rs
+++ b/tasks/benchmark/benches/transformer.rs
@@ -29,7 +29,7 @@ fn bench_transformer(criterion: &mut Criterion) {
                 let ParserReturn { trivias, program, .. } =
                     Parser::new(&allocator, source_text, source_type).parse();
                 let program = allocator.alloc(program);
-                let (symbols, scopes) = SemanticBuilder::new(source_text)
+                let (symbols, scopes) = SemanticBuilder::new()
                     // Estimate transformer will triple scopes, symbols, references
                     .with_excess_capacity(2.0)
                     .build(program)
@@ -47,14 +47,9 @@ fn bench_transformer(criterion: &mut Criterion) {
                 options.es2015.arrow_function = Some(ArrowFunctionsOptions { spec: true });
 
                 runner.run(|| {
-                    let ret = Transformer::new(
-                        &allocator,
-                        Path::new(&file.file_name),
-                        source_text,
-                        trivias,
-                        options,
-                    )
-                    .build_with_symbols_and_scopes(symbols, scopes, program);
+                    let ret =
+                        Transformer::new(&allocator, Path::new(&file.file_name), trivias, options)
+                            .build_with_symbols_and_scopes(symbols, scopes, program);
 
                     // Return the `TransformerReturn`, so it's dropped outside of the measured section.
                     // `TransformerReturn` contains `ScopeTree` and `SymbolTable` which are costly to drop.
diff --git a/tasks/transform_checker/src/lib.rs b/tasks/transform_checker/src/lib.rs
index 3d29bf3f83abc..329235e295a91 100644
--- a/tasks/transform_checker/src/lib.rs
+++ b/tasks/transform_checker/src/lib.rs
@@ -137,7 +137,7 @@ pub fn check_semantic_after_transform(
     // so the cloned AST will be "clean" of all semantic data, as if it had come fresh from the parser.
     let allocator = Allocator::default();
     let program = program.clone_in(&allocator);
-    let (symbols_rebuilt, scopes_rebuilt) = SemanticBuilder::new("")
+    let (symbols_rebuilt, scopes_rebuilt) = SemanticBuilder::new()
         .with_scope_tree_child_ids(scopes_after_transform.has_child_ids())
         .build(&program)
         .semantic
diff --git a/tasks/transform_conformance/src/driver.rs b/tasks/transform_conformance/src/driver.rs
index 701caca8f1a55..56778147f253d 100644
--- a/tasks/transform_conformance/src/driver.rs
+++ b/tasks/transform_conformance/src/driver.rs
@@ -57,10 +57,9 @@ impl CompilerInterface for Driver {
     }
 
     // Disable comments
-    fn codegen<'a>(
+    fn codegen(
         &self,
-        program: &Program<'a>,
-        _source_text: &'a str,
+        program: &Program<'_>,
         _source_path: &Path,
         _trivias: &Trivias,
         mangler: Option<Mangler>,

From 2808973af35c1c8cb73c57844cacc8e506601ec1 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 04:47:36 +0000
Subject: [PATCH 14/24] feat(ast)!: add `Program::comments` (#6445)

---
 .github/.generated_ast_watch_list.yml         |   1 +
 crates/oxc_ast/src/ast/comment.rs             | 112 ++++++++++++++++++
 crates/oxc_ast/src/ast/js.rs                  |   3 +
 crates/oxc_ast/src/ast/mod.rs                 |   3 +-
 .../oxc_ast/src/generated/assert_layouts.rs   |  52 ++++++--
 crates/oxc_ast/src/generated/ast_builder.rs   |   7 +-
 .../oxc_ast/src/generated/derive_clone_in.rs  |  38 ++++++
 .../src/generated/derive_content_eq.rs        |  26 ++++
 .../src/generated/derive_content_hash.rs      |  26 ++++
 crates/oxc_ast/src/lib.rs                     |   3 +-
 crates/oxc_ast/src/trivia.rs                  | 102 +---------------
 crates/oxc_isolated_declarations/src/lib.rs   |  11 +-
 crates/oxc_parser/src/lexer/trivia_builder.rs |   5 +-
 crates/oxc_parser/src/lib.rs                  |   5 +-
 crates/oxc_semantic/src/jsdoc/builder.rs      |   2 +-
 crates/oxc_traverse/src/generated/ancestor.rs |  16 +++
 tasks/ast_tools/src/main.rs                   |   1 +
 17 files changed, 294 insertions(+), 119 deletions(-)
 create mode 100644 crates/oxc_ast/src/ast/comment.rs

diff --git a/.github/.generated_ast_watch_list.yml b/.github/.generated_ast_watch_list.yml
index 818c9ee29d83c..b801c6d9f9d89 100644
--- a/.github/.generated_ast_watch_list.yml
+++ b/.github/.generated_ast_watch_list.yml
@@ -6,6 +6,7 @@ src:
   - 'crates/oxc_ast/src/ast/js.rs'
   - 'crates/oxc_ast/src/ast/ts.rs'
   - 'crates/oxc_ast/src/ast/jsx.rs'
+  - 'crates/oxc_ast/src/ast/comment.rs'
   - 'crates/oxc_syntax/src/number.rs'
   - 'crates/oxc_syntax/src/operator.rs'
   - 'crates/oxc_span/src/span/types.rs'
diff --git a/crates/oxc_ast/src/ast/comment.rs b/crates/oxc_ast/src/ast/comment.rs
new file mode 100644
index 0000000000000..a52892f9c9bda
--- /dev/null
+++ b/crates/oxc_ast/src/ast/comment.rs
@@ -0,0 +1,112 @@
+use oxc_allocator::CloneIn;
+use oxc_ast_macros::ast;
+use oxc_span::{cmp::ContentEq, hash::ContentHash, Span};
+
+#[ast]
+#[generate_derive(CloneIn, ContentEq, ContentHash)]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+pub enum CommentKind {
+    #[default]
+    Line = 0,
+    Block = 1,
+}
+
+#[ast]
+#[generate_derive(CloneIn, ContentEq, ContentHash)]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+pub enum CommentPosition {
+    /// Comments prior to a token until another token or trailing comment.
+    ///
+    /// e.g.
+    ///
+    /// ```
+    /// /* leading */ token;
+    /// /* leading */
+    /// // leading
+    /// token;
+    /// ```
+    #[default]
+    Leading = 0,
+
+    /// Comments tailing a token until a newline.
+    /// e.g. `token /* trailing */ // trailing`
+    Trailing = 1,
+}
+
+#[ast]
+#[generate_derive(CloneIn, ContentEq, ContentHash)]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+pub struct Comment {
+    /// The span of the comment text (without leading/trailing delimiters).
+    pub span: Span,
+
+    /// Line or block comment
+    pub kind: CommentKind,
+
+    /// Leading or trailing comment
+    pub position: CommentPosition,
+
+    /// Start of token this leading comment is attached to.
+    /// `/* Leading */ token`
+    ///                ^ This start
+    /// NOTE: Trailing comment attachment is not computed yet.
+    pub attached_to: u32,
+
+    /// Whether this comment has a preceding newline.
+    /// Used to avoid becoming a trailing comment in codegen.
+    pub preceded_by_newline: bool,
+
+    /// Whether this comment has a tailing newline.
+    pub followed_by_newline: bool,
+}
+
+impl Comment {
+    #[inline]
+    pub fn new(start: u32, end: u32, kind: CommentKind) -> Self {
+        let span = Span::new(start, end);
+        Self {
+            span,
+            kind,
+            position: CommentPosition::Trailing,
+            attached_to: 0,
+            preceded_by_newline: false,
+            followed_by_newline: false,
+        }
+    }
+
+    pub fn is_line(self) -> bool {
+        self.kind == CommentKind::Line
+    }
+
+    pub fn is_block(self) -> bool {
+        self.kind == CommentKind::Block
+    }
+
+    pub fn is_leading(self) -> bool {
+        self.position == CommentPosition::Leading
+    }
+
+    pub fn is_trailing(self) -> bool {
+        self.position == CommentPosition::Trailing
+    }
+
+    pub fn real_span(&self) -> Span {
+        Span::new(self.real_span_start(), self.real_span_end())
+    }
+
+    pub fn real_span_end(&self) -> u32 {
+        match self.kind {
+            CommentKind::Line => self.span.end,
+            // length of `*/`
+            CommentKind::Block => self.span.end + 2,
+        }
+    }
+
+    pub fn real_span_start(&self) -> u32 {
+        self.span.start - 2
+    }
+
+    pub fn is_jsdoc(&self, source_text: &str) -> bool {
+        self.is_leading() && self.is_block() && self.span.source_text(source_text).starts_with('*')
+    }
+}
diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs
index a68e3911082a0..719e69c543ba7 100644
--- a/crates/oxc_ast/src/ast/js.rs
+++ b/crates/oxc_ast/src/ast/js.rs
@@ -41,6 +41,9 @@ pub struct Program<'a> {
     pub source_type: SourceType,
     #[serde(skip)]
     pub source_text: &'a str,
+    /// Sorted comments
+    #[serde(skip)]
+    pub comments: Vec<'a, Comment>,
     pub hashbang: Option<Hashbang<'a>>,
     pub directives: Vec<'a, Directive<'a>>,
     pub body: Vec<'a, Statement<'a>>,
diff --git a/crates/oxc_ast/src/ast/mod.rs b/crates/oxc_ast/src/ast/mod.rs
index 3370e1c231408..19a3c0b505cbe 100644
--- a/crates/oxc_ast/src/ast/mod.rs
+++ b/crates/oxc_ast/src/ast/mod.rs
@@ -175,6 +175,7 @@
 //!
 //! If you are seeing compile-time errors in `src/ast/macros.rs`, this will be the cause.
 
+pub(crate) mod comment;
 pub(crate) mod js;
 pub(crate) mod jsx;
 pub(crate) mod literal;
@@ -191,4 +192,4 @@ pub use oxc_syntax::{
     },
 };
 
-pub use self::{js::*, jsx::*, literal::*, ts::*};
+pub use self::{comment::*, js::*, jsx::*, literal::*, ts::*};
diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs
index ed4f099ca52b0..956e4b8e48802 100644
--- a/crates/oxc_ast/src/generated/assert_layouts.rs
+++ b/crates/oxc_ast/src/generated/assert_layouts.rs
@@ -55,15 +55,16 @@ const _: () = {
     assert!(offset_of!(StringLiteral, span) == 0usize);
     assert!(offset_of!(StringLiteral, value) == 8usize);
 
-    assert!(size_of::<Program>() == 128usize);
+    assert!(size_of::<Program>() == 160usize);
     assert!(align_of::<Program>() == 8usize);
     assert!(offset_of!(Program, span) == 0usize);
     assert!(offset_of!(Program, source_type) == 8usize);
     assert!(offset_of!(Program, source_text) == 16usize);
-    assert!(offset_of!(Program, hashbang) == 32usize);
-    assert!(offset_of!(Program, directives) == 56usize);
-    assert!(offset_of!(Program, body) == 88usize);
-    assert!(offset_of!(Program, scope_id) == 120usize);
+    assert!(offset_of!(Program, comments) == 32usize);
+    assert!(offset_of!(Program, hashbang) == 64usize);
+    assert!(offset_of!(Program, directives) == 88usize);
+    assert!(offset_of!(Program, body) == 120usize);
+    assert!(offset_of!(Program, scope_id) == 152usize);
 
     assert!(size_of::<Expression>() == 16usize);
     assert!(align_of::<Expression>() == 8usize);
@@ -1375,6 +1376,21 @@ const _: () = {
     assert!(offset_of!(JSXText, span) == 0usize);
     assert!(offset_of!(JSXText, value) == 8usize);
 
+    assert!(size_of::<CommentKind>() == 1usize);
+    assert!(align_of::<CommentKind>() == 1usize);
+
+    assert!(size_of::<CommentPosition>() == 1usize);
+    assert!(align_of::<CommentPosition>() == 1usize);
+
+    assert!(size_of::<Comment>() == 20usize);
+    assert!(align_of::<Comment>() == 4usize);
+    assert!(offset_of!(Comment, span) == 0usize);
+    assert!(offset_of!(Comment, kind) == 8usize);
+    assert!(offset_of!(Comment, position) == 9usize);
+    assert!(offset_of!(Comment, attached_to) == 12usize);
+    assert!(offset_of!(Comment, preceded_by_newline) == 16usize);
+    assert!(offset_of!(Comment, followed_by_newline) == 17usize);
+
     assert!(size_of::<NumberBase>() == 1usize);
     assert!(align_of::<NumberBase>() == 1usize);
 
@@ -1598,15 +1614,16 @@ const _: () = {
     assert!(offset_of!(StringLiteral, span) == 0usize);
     assert!(offset_of!(StringLiteral, value) == 8usize);
 
-    assert!(size_of::<Program>() == 72usize);
+    assert!(size_of::<Program>() == 88usize);
     assert!(align_of::<Program>() == 4usize);
     assert!(offset_of!(Program, span) == 0usize);
     assert!(offset_of!(Program, source_type) == 8usize);
     assert!(offset_of!(Program, source_text) == 12usize);
-    assert!(offset_of!(Program, hashbang) == 20usize);
-    assert!(offset_of!(Program, directives) == 36usize);
-    assert!(offset_of!(Program, body) == 52usize);
-    assert!(offset_of!(Program, scope_id) == 68usize);
+    assert!(offset_of!(Program, comments) == 20usize);
+    assert!(offset_of!(Program, hashbang) == 36usize);
+    assert!(offset_of!(Program, directives) == 52usize);
+    assert!(offset_of!(Program, body) == 68usize);
+    assert!(offset_of!(Program, scope_id) == 84usize);
 
     assert!(size_of::<Expression>() == 8usize);
     assert!(align_of::<Expression>() == 4usize);
@@ -2918,6 +2935,21 @@ const _: () = {
     assert!(offset_of!(JSXText, span) == 0usize);
     assert!(offset_of!(JSXText, value) == 8usize);
 
+    assert!(size_of::<CommentKind>() == 1usize);
+    assert!(align_of::<CommentKind>() == 1usize);
+
+    assert!(size_of::<CommentPosition>() == 1usize);
+    assert!(align_of::<CommentPosition>() == 1usize);
+
+    assert!(size_of::<Comment>() == 20usize);
+    assert!(align_of::<Comment>() == 4usize);
+    assert!(offset_of!(Comment, span) == 0usize);
+    assert!(offset_of!(Comment, kind) == 8usize);
+    assert!(offset_of!(Comment, position) == 9usize);
+    assert!(offset_of!(Comment, attached_to) == 12usize);
+    assert!(offset_of!(Comment, preceded_by_newline) == 16usize);
+    assert!(offset_of!(Comment, followed_by_newline) == 17usize);
+
     assert!(size_of::<NumberBase>() == 1usize);
     assert!(align_of::<NumberBase>() == 1usize);
 
diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
index 000ed9f5234f6..34d309007df04 100644
--- a/crates/oxc_ast/src/generated/ast_builder.rs
+++ b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -222,6 +222,7 @@ impl<'a> AstBuilder<'a> {
     /// - span: The [`Span`] covering this node
     /// - source_type
     /// - source_text
+    /// - comments: Sorted comments
     /// - hashbang
     /// - directives
     /// - body
@@ -231,6 +232,7 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         source_type: SourceType,
         source_text: S,
+        comments: Vec<'a, Comment>,
         hashbang: Option<Hashbang<'a>>,
         directives: Vec<'a, Directive<'a>>,
         body: Vec<'a, Statement<'a>>,
@@ -242,6 +244,7 @@ impl<'a> AstBuilder<'a> {
             span,
             source_type,
             source_text: source_text.into_in(self.allocator),
+            comments,
             hashbang,
             directives,
             body,
@@ -257,6 +260,7 @@ impl<'a> AstBuilder<'a> {
     /// - span: The [`Span`] covering this node
     /// - source_type
     /// - source_text
+    /// - comments: Sorted comments
     /// - hashbang
     /// - directives
     /// - body
@@ -266,6 +270,7 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         source_type: SourceType,
         source_text: S,
+        comments: Vec<'a, Comment>,
         hashbang: Option<Hashbang<'a>>,
         directives: Vec<'a, Directive<'a>>,
         body: Vec<'a, Statement<'a>>,
@@ -274,7 +279,7 @@ impl<'a> AstBuilder<'a> {
         S: IntoIn<'a, &'a str>,
     {
         Box::new_in(
-            self.program(span, source_type, source_text, hashbang, directives, body),
+            self.program(span, source_type, source_text, comments, hashbang, directives, body),
             self.allocator,
         )
     }
diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs
index 6f48349f6af21..59b5f3ffc83b8 100644
--- a/crates/oxc_ast/src/generated/derive_clone_in.rs
+++ b/crates/oxc_ast/src/generated/derive_clone_in.rs
@@ -5,6 +5,9 @@
 
 use oxc_allocator::{Allocator, CloneIn};
 
+#[allow(clippy::wildcard_imports)]
+use crate::ast::comment::*;
+
 #[allow(clippy::wildcard_imports)]
 use crate::ast::js::*;
 
@@ -113,6 +116,7 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Program<'old_alloc> {
             span: CloneIn::clone_in(&self.span, allocator),
             source_type: CloneIn::clone_in(&self.source_type, allocator),
             source_text: CloneIn::clone_in(&self.source_text, allocator),
+            comments: CloneIn::clone_in(&self.comments, allocator),
             hashbang: CloneIn::clone_in(&self.hashbang, allocator),
             directives: CloneIn::clone_in(&self.directives, allocator),
             body: CloneIn::clone_in(&self.body, allocator),
@@ -4231,3 +4235,37 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXText<'old_alloc> {
         }
     }
 }
+
+impl<'alloc> CloneIn<'alloc> for CommentKind {
+    type Cloned = CommentKind;
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
+        match self {
+            Self::Line => CommentKind::Line,
+            Self::Block => CommentKind::Block,
+        }
+    }
+}
+
+impl<'alloc> CloneIn<'alloc> for CommentPosition {
+    type Cloned = CommentPosition;
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
+        match self {
+            Self::Leading => CommentPosition::Leading,
+            Self::Trailing => CommentPosition::Trailing,
+        }
+    }
+}
+
+impl<'alloc> CloneIn<'alloc> for Comment {
+    type Cloned = Comment;
+    fn clone_in(&self, allocator: &'alloc Allocator) -> Self::Cloned {
+        Comment {
+            span: CloneIn::clone_in(&self.span, allocator),
+            kind: CloneIn::clone_in(&self.kind, allocator),
+            position: CloneIn::clone_in(&self.position, allocator),
+            attached_to: CloneIn::clone_in(&self.attached_to, allocator),
+            preceded_by_newline: CloneIn::clone_in(&self.preceded_by_newline, allocator),
+            followed_by_newline: CloneIn::clone_in(&self.followed_by_newline, allocator),
+        }
+    }
+}
diff --git a/crates/oxc_ast/src/generated/derive_content_eq.rs b/crates/oxc_ast/src/generated/derive_content_eq.rs
index d85fe2fb7e3f7..e06196f26fe12 100644
--- a/crates/oxc_ast/src/generated/derive_content_eq.rs
+++ b/crates/oxc_ast/src/generated/derive_content_eq.rs
@@ -5,6 +5,9 @@
 
 use oxc_span::cmp::ContentEq;
 
+#[allow(clippy::wildcard_imports)]
+use crate::ast::comment::*;
+
 #[allow(clippy::wildcard_imports)]
 use crate::ast::js::*;
 
@@ -93,6 +96,7 @@ impl<'a> ContentEq for Program<'a> {
     fn content_eq(&self, other: &Self) -> bool {
         ContentEq::content_eq(&self.source_type, &other.source_type)
             && ContentEq::content_eq(&self.source_text, &other.source_text)
+            && ContentEq::content_eq(&self.comments, &other.comments)
             && ContentEq::content_eq(&self.hashbang, &other.hashbang)
             && ContentEq::content_eq(&self.directives, &other.directives)
             && ContentEq::content_eq(&self.body, &other.body)
@@ -4212,3 +4216,25 @@ impl<'a> ContentEq for JSXText<'a> {
         ContentEq::content_eq(&self.value, &other.value)
     }
 }
+
+impl ContentEq for CommentKind {
+    fn content_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl ContentEq for CommentPosition {
+    fn content_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl ContentEq for Comment {
+    fn content_eq(&self, other: &Self) -> bool {
+        ContentEq::content_eq(&self.kind, &other.kind)
+            && ContentEq::content_eq(&self.position, &other.position)
+            && ContentEq::content_eq(&self.attached_to, &other.attached_to)
+            && ContentEq::content_eq(&self.preceded_by_newline, &other.preceded_by_newline)
+            && ContentEq::content_eq(&self.followed_by_newline, &other.followed_by_newline)
+    }
+}
diff --git a/crates/oxc_ast/src/generated/derive_content_hash.rs b/crates/oxc_ast/src/generated/derive_content_hash.rs
index 82f89e9bac5d9..6d8311d4ff484 100644
--- a/crates/oxc_ast/src/generated/derive_content_hash.rs
+++ b/crates/oxc_ast/src/generated/derive_content_hash.rs
@@ -7,6 +7,9 @@ use std::{hash::Hasher, mem::discriminant};
 
 use oxc_span::hash::ContentHash;
 
+#[allow(clippy::wildcard_imports)]
+use crate::ast::comment::*;
+
 #[allow(clippy::wildcard_imports)]
 use crate::ast::js::*;
 
@@ -71,6 +74,7 @@ impl<'a> ContentHash for Program<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
         ContentHash::content_hash(&self.source_type, state);
         ContentHash::content_hash(&self.source_text, state);
+        ContentHash::content_hash(&self.comments, state);
         ContentHash::content_hash(&self.hashbang, state);
         ContentHash::content_hash(&self.directives, state);
         ContentHash::content_hash(&self.body, state);
@@ -2374,3 +2378,25 @@ impl<'a> ContentHash for JSXText<'a> {
         ContentHash::content_hash(&self.value, state);
     }
 }
+
+impl ContentHash for CommentKind {
+    fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&discriminant(self), state);
+    }
+}
+
+impl ContentHash for CommentPosition {
+    fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&discriminant(self), state);
+    }
+}
+
+impl ContentHash for Comment {
+    fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&self.kind, state);
+        ContentHash::content_hash(&self.position, state);
+        ContentHash::content_hash(&self.attached_to, state);
+        ContentHash::content_hash(&self.preceded_by_newline, state);
+        ContentHash::content_hash(&self.followed_by_newline, state);
+    }
+}
diff --git a/crates/oxc_ast/src/lib.rs b/crates/oxc_ast/src/lib.rs
index 2a99c0960347f..52711c9461f71 100644
--- a/crates/oxc_ast/src/lib.rs
+++ b/crates/oxc_ast/src/lib.rs
@@ -57,10 +57,11 @@ pub use generated::{ast_builder, ast_kind};
 pub use num_bigint::BigUint;
 
 pub use crate::{
+    ast::comment::{Comment, CommentKind, CommentPosition},
     ast_builder::AstBuilder,
     ast_builder_impl::NONE,
     ast_kind::{AstKind, AstType},
-    trivia::{Comment, CommentKind, CommentPosition, SortedComments, Trivias},
+    trivia::{SortedComments, Trivias},
     visit::{Visit, VisitMut},
 };
 
diff --git a/crates/oxc_ast/src/trivia.rs b/crates/oxc_ast/src/trivia.rs
index e00f2c7e3afd2..52b4c0da497d3 100644
--- a/crates/oxc_ast/src/trivia.rs
+++ b/crates/oxc_ast/src/trivia.rs
@@ -8,107 +8,7 @@ use std::{
 
 use oxc_span::Span;
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum CommentKind {
-    Line,
-    Block,
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum CommentPosition {
-    /// Comments prior to a token until another token or trailing comment.
-    ///
-    /// e.g.
-    ///
-    /// ```
-    /// /* leading */ token;
-    /// /* leading */
-    /// // leading
-    /// token;
-    /// ```
-    Leading,
-
-    /// Comments tailing a token until a newline.
-    /// e.g. `token /* trailing */ // trailing`
-    Trailing,
-}
-
-/// Single or multiline comment
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Comment {
-    /// The span of the comment text (without leading/trailing delimiters).
-    pub span: Span,
-
-    /// Line or block comment
-    pub kind: CommentKind,
-
-    /// Leading or trailing comment
-    pub position: CommentPosition,
-
-    /// Start of token this leading comment is attached to.
-    /// `/* Leading */ token`
-    ///                ^ This start
-    /// NOTE: Trailing comment attachment is not computed yet.
-    pub attached_to: u32,
-
-    /// Whether this comment has a preceding newline.
-    /// Used to avoid becoming a trailing comment in codegen.
-    pub preceded_by_newline: bool,
-
-    /// Whether this comment has a tailing newline.
-    pub followed_by_newline: bool,
-}
-
-impl Comment {
-    #[inline]
-    pub fn new(start: u32, end: u32, kind: CommentKind) -> Self {
-        let span = Span::new(start, end);
-        Self {
-            span,
-            kind,
-            position: CommentPosition::Trailing,
-            attached_to: 0,
-            preceded_by_newline: false,
-            followed_by_newline: false,
-        }
-    }
-
-    pub fn is_line(self) -> bool {
-        self.kind == CommentKind::Line
-    }
-
-    pub fn is_block(self) -> bool {
-        self.kind == CommentKind::Block
-    }
-
-    pub fn is_leading(self) -> bool {
-        self.position == CommentPosition::Leading
-    }
-
-    pub fn is_trailing(self) -> bool {
-        self.position == CommentPosition::Trailing
-    }
-
-    pub fn real_span(&self) -> Span {
-        Span::new(self.real_span_start(), self.real_span_end())
-    }
-
-    pub fn real_span_end(&self) -> u32 {
-        match self.kind {
-            CommentKind::Line => self.span.end,
-            // length of `*/`
-            CommentKind::Block => self.span.end + 2,
-        }
-    }
-
-    pub fn real_span_start(&self) -> u32 {
-        self.span.start - 2
-    }
-
-    pub fn is_jsdoc(&self, source_text: &str) -> bool {
-        self.is_leading() && self.is_block() && self.span.source_text(source_text).starts_with('*')
-    }
-}
+use crate::ast::comment::*;
 
 /// Sorted set of unique trivia comments, in ascending order by starting position.
 pub type SortedComments = Box<[Comment]>;
diff --git a/crates/oxc_isolated_declarations/src/lib.rs b/crates/oxc_isolated_declarations/src/lib.rs
index acb5f0be76fe6..b3f65227e9648 100644
--- a/crates/oxc_isolated_declarations/src/lib.rs
+++ b/crates/oxc_isolated_declarations/src/lib.rs
@@ -92,8 +92,15 @@ impl<'a> IsolatedDeclarations<'a> {
         let source_type = SourceType::d_ts();
         let directives = self.ast.vec();
         let stmts = self.transform_program(program);
-        let program =
-            self.ast.program(SPAN, source_type, program.source_text, None, directives, stmts);
+        let program = self.ast.program(
+            SPAN,
+            source_type,
+            program.source_text,
+            self.ast.vec_from_iter(program.comments.iter().copied()),
+            None,
+            directives,
+            stmts,
+        );
         IsolatedDeclarationsReturn { program, errors: self.take_errors() }
     }
 
diff --git a/crates/oxc_parser/src/lexer/trivia_builder.rs b/crates/oxc_parser/src/lexer/trivia_builder.rs
index 4579dc2737f3a..acbe2294c88d5 100644
--- a/crates/oxc_parser/src/lexer/trivia_builder.rs
+++ b/crates/oxc_parser/src/lexer/trivia_builder.rs
@@ -1,4 +1,7 @@
-use oxc_ast::{Comment, CommentKind, CommentPosition, Trivias};
+use oxc_ast::{
+    ast::{Comment, CommentKind, CommentPosition},
+    Trivias,
+};
 use oxc_span::Span;
 
 use super::{Kind, Token};
diff --git a/crates/oxc_parser/src/lib.rs b/crates/oxc_parser/src/lib.rs
index 6f115f8945160..ee6d242b9ccb5 100644
--- a/crates/oxc_parser/src/lib.rs
+++ b/crates/oxc_parser/src/lib.rs
@@ -405,6 +405,7 @@ impl<'a> ParserImpl<'a> {
                     Span::default(),
                     self.source_type,
                     self.source_text,
+                    self.ast.vec(),
                     None,
                     self.ast.vec(),
                     self.ast.vec(),
@@ -451,10 +452,12 @@ impl<'a> ParserImpl<'a> {
         self.set_source_type_to_script_if_unambiguous();
 
         let span = Span::new(0, self.source_text.len() as u32);
+        let comments = self.ast.vec_from_iter(self.lexer.trivia_builder.comments.iter().copied());
         Ok(self.ast.program(
             span,
             self.source_type,
             self.source_text,
+            comments,
             hashbang,
             directives,
             statements,
@@ -537,7 +540,7 @@ impl<'a> ParserImpl<'a> {
 mod test {
     use std::path::Path;
 
-    use oxc_ast::{ast::Expression, CommentKind};
+    use oxc_ast::ast::{CommentKind, Expression};
 
     use super::*;
 
diff --git a/crates/oxc_semantic/src/jsdoc/builder.rs b/crates/oxc_semantic/src/jsdoc/builder.rs
index 9ae9fb384c108..3f655d47daa85 100644
--- a/crates/oxc_semantic/src/jsdoc/builder.rs
+++ b/crates/oxc_semantic/src/jsdoc/builder.rs
@@ -1,6 +1,6 @@
 use rustc_hash::FxHashMap;
 
-use oxc_ast::{AstKind, Comment, Trivias};
+use oxc_ast::{ast::Comment, AstKind, Trivias};
 use oxc_span::{GetSpan, Span};
 
 use crate::jsdoc::JSDocFinder;
diff --git a/crates/oxc_traverse/src/generated/ancestor.rs b/crates/oxc_traverse/src/generated/ancestor.rs
index 44327c49900b6..e919a7f582b60 100644
--- a/crates/oxc_traverse/src/generated/ancestor.rs
+++ b/crates/oxc_traverse/src/generated/ancestor.rs
@@ -2202,6 +2202,7 @@ impl<'a, 't> Ancestor<'a, 't> {
 pub(crate) const OFFSET_PROGRAM_SPAN: usize = offset_of!(Program, span);
 pub(crate) const OFFSET_PROGRAM_SOURCE_TYPE: usize = offset_of!(Program, source_type);
 pub(crate) const OFFSET_PROGRAM_SOURCE_TEXT: usize = offset_of!(Program, source_text);
+pub(crate) const OFFSET_PROGRAM_COMMENTS: usize = offset_of!(Program, comments);
 pub(crate) const OFFSET_PROGRAM_HASHBANG: usize = offset_of!(Program, hashbang);
 pub(crate) const OFFSET_PROGRAM_DIRECTIVES: usize = offset_of!(Program, directives);
 pub(crate) const OFFSET_PROGRAM_BODY: usize = offset_of!(Program, body);
@@ -2230,6 +2231,11 @@ impl<'a, 't> ProgramWithoutHashbang<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
     }
 
+    #[inline]
+    pub fn comments(self) -> &'t Vec<'a, Comment> {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_COMMENTS) as *const Vec<'a, Comment>) }
+    }
+
     #[inline]
     pub fn directives(self) -> &'t Vec<'a, Directive<'a>> {
         unsafe {
@@ -2276,6 +2282,11 @@ impl<'a, 't> ProgramWithoutDirectives<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
     }
 
+    #[inline]
+    pub fn comments(self) -> &'t Vec<'a, Comment> {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_COMMENTS) as *const Vec<'a, Comment>) }
+    }
+
     #[inline]
     pub fn hashbang(self) -> &'t Option<Hashbang<'a>> {
         unsafe {
@@ -2321,6 +2332,11 @@ impl<'a, 't> ProgramWithoutBody<'a, 't> {
         unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_SOURCE_TEXT) as *const &'a str) }
     }
 
+    #[inline]
+    pub fn comments(self) -> &'t Vec<'a, Comment> {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_PROGRAM_COMMENTS) as *const Vec<'a, Comment>) }
+    }
+
     #[inline]
     pub fn hashbang(self) -> &'t Option<Hashbang<'a>> {
         unsafe {
diff --git a/tasks/ast_tools/src/main.rs b/tasks/ast_tools/src/main.rs
index 6e8dcf94ed346..dc9e3595dfef2 100644
--- a/tasks/ast_tools/src/main.rs
+++ b/tasks/ast_tools/src/main.rs
@@ -31,6 +31,7 @@ static SOURCE_PATHS: &[&str] = &[
     "crates/oxc_ast/src/ast/js.rs",
     "crates/oxc_ast/src/ast/ts.rs",
     "crates/oxc_ast/src/ast/jsx.rs",
+    "crates/oxc_ast/src/ast/comment.rs",
     "crates/oxc_syntax/src/number.rs",
     "crates/oxc_syntax/src/operator.rs",
     "crates/oxc_span/src/span/types.rs",

From 520096030a61a41d067554939bd4eb57f0c63e73 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 06:09:25 +0000
Subject: [PATCH 15/24] refactor(oxc)!: remove passing `Trivias` around (#6446)

part of #6426
---
 crates/oxc/README.md                          |  1 -
 crates/oxc/src/compiler.rs                    | 29 +++-----
 crates/oxc_ast/src/lib.rs                     |  2 +-
 crates/oxc_ast/src/trivia.rs                  | 68 ++++---------------
 crates/oxc_codegen/examples/codegen.rs        | 12 ++--
 crates/oxc_codegen/src/comment.rs             |  8 +--
 crates/oxc_codegen/src/lib.rs                 | 19 ++----
 crates/oxc_codegen/tests/integration/main.rs  |  6 +-
 .../oxc_codegen/tests/integration/tester.rs   |  6 +-
 .../examples/isolated_declarations.rs         | 16 ++---
 crates/oxc_isolated_declarations/src/lib.rs   | 25 +++----
 .../tests/deno/mod.rs                         |  2 -
 crates/oxc_isolated_declarations/tests/mod.rs | 16 ++---
 crates/oxc_language_server/src/linter.rs      | 11 ++-
 crates/oxc_linter/examples/linter.rs          |  2 +-
 crates/oxc_linter/src/context/host.rs         |  3 +-
 crates/oxc_linter/src/disable_directives.rs   | 34 ++++------
 .../src/rules/eslint/default_case.rs          |  1 -
 .../oxc_linter/src/rules/eslint/max_lines.rs  |  2 +-
 .../oxc_linter/src/rules/eslint/no_empty.rs   |  4 +-
 .../src/rules/eslint/no_empty_function.rs     |  2 +-
 .../src/rules/eslint/no_empty_static_block.rs |  2 +-
 .../src/rules/eslint/no_fallthrough.rs        |  1 -
 .../rules/eslint/no_irregular_whitespace.rs   |  2 +-
 .../src/rules/eslint/sort_imports.rs          |  2 +-
 .../src/rules/jest/no_commented_out_tests.rs  |  4 +-
 .../src/rules/typescript/ban_ts_comment.rs    |  2 +-
 .../rules/typescript/ban_tslint_comment.rs    |  2 +-
 .../rules/typescript/prefer_function_type.rs  |  7 +-
 .../typescript/prefer_ts_expect_error.rs      |  2 +-
 .../typescript/triple_slash_reference.rs      |  2 +-
 .../src/rules/unicorn/empty_brace_spaces.rs   |  4 +-
 .../src/rules/unicorn/no_empty_file.rs        |  2 +-
 .../unicorn/no_magic_array_flat_depth.rs      |  8 +--
 .../src/rules/unicorn/no_useless_undefined.rs |  1 -
 crates/oxc_linter/src/service/runtime.rs      | 12 ++--
 crates/oxc_linter/src/utils/tree_shaking.rs   |  4 +-
 crates/oxc_parser/examples/parser.rs          |  2 +-
 crates/oxc_parser/examples/parser_tsx.rs      |  4 +-
 crates/oxc_parser/src/lexer/trivia_builder.rs | 13 +---
 crates/oxc_parser/src/lib.rs                  | 13 ++--
 crates/oxc_prettier/examples/prettier.rs      |  1 -
 crates/oxc_prettier/src/lib.rs                | 12 +---
 crates/oxc_semantic/examples/cfg.rs           |  7 +-
 crates/oxc_semantic/examples/simple.rs        |  2 -
 crates/oxc_semantic/src/builder.rs            | 20 ++----
 crates/oxc_semantic/src/jsdoc/builder.rs      | 12 ++--
 crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs |  6 +-
 .../src/jsdoc/parser/jsdoc_tag.rs             |  6 +-
 crates/oxc_semantic/src/lib.rs                | 31 +++++++--
 .../tests/integration/util/mod.rs             |  1 -
 .../oxc_transformer/examples/transformer.rs   |  8 ++-
 crates/oxc_transformer/src/context.rs         |  6 +-
 crates/oxc_transformer/src/lib.rs             | 13 ++--
 crates/oxc_transformer/src/react/comments.rs  |  8 ++-
 crates/oxc_wasm/src/lib.rs                    | 42 ++++--------
 napi/parser/src/lib.rs                        |  5 +-
 napi/transform/src/isolated_declaration.rs    |  9 +--
 .../benches/isolated_declarations.rs          |  4 +-
 tasks/benchmark/benches/linter.rs             |  1 -
 tasks/benchmark/benches/prettier.rs           |  9 +--
 tasks/benchmark/benches/semantic.rs           |  1 -
 tasks/benchmark/benches/transformer.rs        | 15 +---
 tasks/coverage/src/driver.rs                  | 10 +--
 tasks/coverage/src/tools/prettier.rs          |  8 +--
 .../src/typescript/transpile_runner.rs        | 10 +--
 tasks/prettier_conformance/src/lib.rs         |  2 +-
 tasks/transform_conformance/src/driver.rs     |  3 +-
 68 files changed, 213 insertions(+), 397 deletions(-)

diff --git a/crates/oxc/README.md b/crates/oxc/README.md
index 20d07dfaf5dfa..39a894cbb41cd 100644
--- a/crates/oxc/README.md
+++ b/crates/oxc/README.md
@@ -101,7 +101,6 @@ let SemanticBuilderReturn {
     errors: semantic_errors,
 } = SemanticBuilder::new()
     .with_check_syntax_error(true) // Enable extra syntax error checking
-    .with_trivias(trivias)         // Pass comments for JSDoc parsing
     .with_build_jsdoc(true)        // Enable JSDoc parsing
     .with_cfg(true)                // Build a Control Flow Graph
     .build(&program);              // Produce the `Semantic`
diff --git a/crates/oxc/src/compiler.rs b/crates/oxc/src/compiler.rs
index 30027347a5bea..a0c30aea74920 100644
--- a/crates/oxc/src/compiler.rs
+++ b/crates/oxc/src/compiler.rs
@@ -1,7 +1,7 @@
 use std::{mem, ops::ControlFlow, path::Path};
 
 use oxc_allocator::Allocator;
-use oxc_ast::{ast::Program, Trivias};
+use oxc_ast::ast::Program;
 use oxc_codegen::{CodeGenerator, CodegenOptions, CodegenReturn, CommentOptions};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_isolated_declarations::{IsolatedDeclarations, IsolatedDeclarationsOptions};
@@ -135,11 +135,10 @@ pub trait CompilerInterface {
         }
 
         let mut program = parser_return.program;
-        let trivias = parser_return.trivias;
 
         /* Isolated Declarations */
         if let Some(options) = self.isolated_declaration_options() {
-            self.isolated_declaration(options, &allocator, &program, source_path, &trivias);
+            self.isolated_declaration(options, &allocator, &program, source_path);
         }
 
         /* Semantic */
@@ -158,15 +157,8 @@ pub trait CompilerInterface {
         /* Transform */
 
         if let Some(options) = self.transform_options() {
-            let mut transformer_return = self.transform(
-                options,
-                &allocator,
-                &mut program,
-                source_path,
-                &trivias,
-                symbols,
-                scopes,
-            );
+            let mut transformer_return =
+                self.transform(options, &allocator, &mut program, source_path, symbols, scopes);
 
             if !transformer_return.errors.is_empty() {
                 self.handle_errors(transformer_return.errors);
@@ -210,7 +202,7 @@ pub trait CompilerInterface {
         /* Codegen */
 
         if let Some(options) = self.codegen_options() {
-            let ret = self.codegen(&program, source_path, &trivias, mangler, options);
+            let ret = self.codegen(&program, source_path, mangler, options);
             self.after_codegen(ret);
         }
     }
@@ -245,15 +237,12 @@ pub trait CompilerInterface {
         allocator: &'a Allocator,
         program: &Program<'a>,
         source_path: &Path,
-        trivias: &Trivias,
     ) {
-        let ret = IsolatedDeclarations::new(allocator, program.source_text, trivias, options)
-            .build(program);
+        let ret = IsolatedDeclarations::new(allocator, options).build(program);
         self.handle_errors(ret.errors);
         let ret = self.codegen(
             &ret.program,
             source_path,
-            trivias,
             None,
             self.codegen_options().unwrap_or_default(),
         );
@@ -267,11 +256,10 @@ pub trait CompilerInterface {
         allocator: &'a Allocator,
         program: &mut Program<'a>,
         source_path: &Path,
-        trivias: &Trivias,
         symbols: SymbolTable,
         scopes: ScopeTree,
     ) -> TransformerReturn {
-        Transformer::new(allocator, source_path, trivias.clone(), options)
+        Transformer::new(allocator, source_path, options)
             .build_with_symbols_and_scopes(symbols, scopes, program)
     }
 
@@ -292,7 +280,6 @@ pub trait CompilerInterface {
         &self,
         program: &Program<'_>,
         source_path: &Path,
-        trivias: &Trivias,
         mangler: Option<Mangler>,
         options: CodegenOptions,
     ) -> CodegenReturn {
@@ -300,7 +287,7 @@ pub trait CompilerInterface {
         let mut codegen = CodeGenerator::new()
             .with_options(options)
             .with_mangler(mangler)
-            .enable_comment(program.source_text, trivias.clone(), comment_options);
+            .enable_comment(program, comment_options);
         if self.enable_sourcemap() {
             codegen = codegen
                 .enable_source_map(source_path.to_string_lossy().as_ref(), program.source_text);
diff --git a/crates/oxc_ast/src/lib.rs b/crates/oxc_ast/src/lib.rs
index 52711c9461f71..eab91afe0b717 100644
--- a/crates/oxc_ast/src/lib.rs
+++ b/crates/oxc_ast/src/lib.rs
@@ -61,7 +61,7 @@ pub use crate::{
     ast_builder::AstBuilder,
     ast_builder_impl::NONE,
     ast_kind::{AstKind, AstType},
-    trivia::{SortedComments, Trivias},
+    trivia::{comments_range, has_comments_between, CommentsRange},
     visit::{Visit, VisitMut},
 };
 
diff --git a/crates/oxc_ast/src/trivia.rs b/crates/oxc_ast/src/trivia.rs
index 52b4c0da497d3..cd9ae1df92c1e 100644
--- a/crates/oxc_ast/src/trivia.rs
+++ b/crates/oxc_ast/src/trivia.rs
@@ -2,63 +2,22 @@
 
 use std::{
     iter::FusedIterator,
-    ops::{Bound, Deref, RangeBounds},
-    sync::Arc,
+    ops::{Bound, RangeBounds},
 };
 
 use oxc_span::Span;
 
 use crate::ast::comment::*;
 
-/// Sorted set of unique trivia comments, in ascending order by starting position.
-pub type SortedComments = Box<[Comment]>;
-
-#[derive(Debug, Clone, Default)]
-pub struct Trivias(Arc<TriviasImpl>);
-
-#[derive(Debug, Default)]
-pub struct TriviasImpl {
-    /// Unique comments, ordered by increasing span-start.
-    comments: SortedComments,
-
-    irregular_whitespaces: Box<[Span]>,
+pub fn comments_range<R>(comments: &[Comment], range: R) -> CommentsRange<'_>
+where
+    R: RangeBounds<u32>,
+{
+    CommentsRange::new(comments, range.start_bound().cloned(), range.end_bound().cloned())
 }
 
-impl Deref for Trivias {
-    type Target = TriviasImpl;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.0.as_ref()
-    }
-}
-
-impl Trivias {
-    pub fn new(comments: SortedComments, irregular_whitespaces: Vec<Span>) -> Trivias {
-        Self(Arc::new(TriviasImpl {
-            comments,
-            irregular_whitespaces: irregular_whitespaces.into_boxed_slice(),
-        }))
-    }
-
-    pub fn comments(&self) -> impl Iterator<Item = &Comment> {
-        self.comments.iter()
-    }
-
-    pub fn comments_range<R>(&self, range: R) -> CommentsRange<'_>
-    where
-        R: RangeBounds<u32>,
-    {
-        CommentsRange::new(&self.comments, range.start_bound().cloned(), range.end_bound().cloned())
-    }
-
-    pub fn has_comments_between(&self, span: Span) -> bool {
-        self.comments_range(span.start..span.end).count() > 0
-    }
-
-    pub fn irregular_whitespaces(&self) -> &[Span] {
-        &self.irregular_whitespaces
-    }
+pub fn has_comments_between(comments: &[Comment], span: Span) -> bool {
+    comments_range(comments, span.start..span.end).count() > 0
 }
 
 /// Double-ended iterator over a range of comments, by starting position.
@@ -141,7 +100,7 @@ mod test {
 
     #[test]
     fn test_comments_range() {
-        let comments: SortedComments = vec![
+        let comments = vec![
             Comment::new(0, 4, CommentKind::Line),
             Comment::new(5, 9, CommentKind::Line),
             Comment::new(10, 13, CommentKind::Line),
@@ -150,10 +109,9 @@ mod test {
         ]
         .into_boxed_slice();
         let full_len = comments.len();
-        let trivias = Trivias::new(comments, vec![]);
-        assert_eq!(trivias.comments_range(..).count(), full_len);
-        assert_eq!(trivias.comments_range(1..).count(), full_len.saturating_sub(1));
-        assert_eq!(trivias.comments_range(..18).count(), full_len.saturating_sub(1));
-        assert_eq!(trivias.comments_range(..=18).count(), full_len);
+        assert_eq!(comments_range(&comments, ..).count(), full_len);
+        assert_eq!(comments_range(&comments, 1..).count(), full_len.saturating_sub(1));
+        assert_eq!(comments_range(&comments, ..18).count(), full_len.saturating_sub(1));
+        assert_eq!(comments_range(&comments, ..=18).count(), full_len);
     }
 }
diff --git a/crates/oxc_codegen/examples/codegen.rs b/crates/oxc_codegen/examples/codegen.rs
index 3804cf50d0921..895a7f3eeb41d 100644
--- a/crates/oxc_codegen/examples/codegen.rs
+++ b/crates/oxc_codegen/examples/codegen.rs
@@ -24,7 +24,7 @@ fn main() -> std::io::Result<()> {
 
     let printed = {
         let Some(ret) = parse(&allocator, &source_text, source_type) else { return Ok(()) };
-        codegen(&source_text, &ret, minify)
+        codegen(&ret, minify)
     };
     println!("First time:");
     println!("{printed}");
@@ -35,7 +35,7 @@ fn main() -> std::io::Result<()> {
 
         let Some(ret) = parse(&allocator, &printed, source_type) else { return Ok(()) };
         println!("Second time:");
-        let printed = codegen(&printed, &ret, minify);
+        let printed = codegen(&ret, minify);
         println!("{printed}");
         // Check syntax error
         parse(&allocator, &printed, source_type);
@@ -59,13 +59,9 @@ fn parse<'a>(
     Some(ret)
 }
 
-fn codegen(source_text: &str, ret: &ParserReturn<'_>, minify: bool) -> String {
+fn codegen(ret: &ParserReturn<'_>, minify: bool) -> String {
     CodeGenerator::new()
-        .enable_comment(
-            source_text,
-            ret.trivias.clone(),
-            CommentOptions { preserve_annotate_comments: true },
-        )
+        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
         .with_options(CodegenOptions { minify, ..CodegenOptions::default() })
         .build(&ret.program)
         .code
diff --git a/crates/oxc_codegen/src/comment.rs b/crates/oxc_codegen/src/comment.rs
index aa2b41dd58ebd..389b0ad55ad5d 100644
--- a/crates/oxc_codegen/src/comment.rs
+++ b/crates/oxc_codegen/src/comment.rs
@@ -2,7 +2,7 @@ use daachorse::DoubleArrayAhoCorasick;
 use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
 
-use oxc_ast::{Comment, CommentKind, Trivias};
+use oxc_ast::{Comment, CommentKind};
 use oxc_syntax::identifier::is_line_terminator;
 
 use crate::Codegen;
@@ -20,9 +20,9 @@ impl<'a> Codegen<'a> {
         self.comment_options.preserve_annotate_comments && !self.options.minify
     }
 
-    pub(crate) fn build_comments(&mut self, trivias: &Trivias) {
-        for comment in trivias.comments().copied() {
-            self.comments.entry(comment.attached_to).or_default().push(comment);
+    pub(crate) fn build_comments(&mut self, comments: &[Comment]) {
+        for comment in comments {
+            self.comments.entry(comment.attached_to).or_default().push(*comment);
         }
     }
 
diff --git a/crates/oxc_codegen/src/lib.rs b/crates/oxc_codegen/src/lib.rs
index 9d8fe0cc30a71..8fc7f1d2f67f8 100644
--- a/crates/oxc_codegen/src/lib.rs
+++ b/crates/oxc_codegen/src/lib.rs
@@ -12,9 +12,8 @@ mod sourcemap_builder;
 
 use std::borrow::Cow;
 
-use oxc_ast::{
-    ast::{BindingIdentifier, BlockStatement, Expression, IdentifierReference, Program, Statement},
-    Trivias,
+use oxc_ast::ast::{
+    BindingIdentifier, BlockStatement, Expression, IdentifierReference, Program, Statement,
 };
 use oxc_mangler::Mangler;
 use oxc_span::{GetSpan, Span};
@@ -72,7 +71,6 @@ pub struct Codegen<'a> {
     /// Original source code of the AST
     source_text: Option<&'a str>,
 
-    trivias: Trivias,
     comments: CommentsMap,
 
     /// Start of comment that needs to be moved to the before VariableDeclarator
@@ -146,7 +144,6 @@ impl<'a> Codegen<'a> {
             options: CodegenOptions::default(),
             comment_options: CommentOptions::default(),
             source_text: None,
-            trivias: Trivias::default(),
             comments: CommentsMap::default(),
             start_of_annotation_comment: None,
             mangler: None,
@@ -199,16 +196,10 @@ impl<'a> Codegen<'a> {
 
     /// Also sets the [Self::with_source_text]
     #[must_use]
-    pub fn enable_comment(
-        mut self,
-        source_text: &'a str,
-        trivias: Trivias,
-        options: CommentOptions,
-    ) -> Self {
+    pub fn enable_comment(mut self, program: &Program<'a>, options: CommentOptions) -> Self {
         self.comment_options = options;
-        self.build_comments(&trivias);
-        self.trivias = trivias;
-        self.with_source_text(source_text)
+        self.build_comments(&program.comments);
+        self.with_source_text(program.source_text)
     }
 
     #[must_use]
diff --git a/crates/oxc_codegen/tests/integration/main.rs b/crates/oxc_codegen/tests/integration/main.rs
index 73e5b9827b3b2..21e6e641aaa75 100644
--- a/crates/oxc_codegen/tests/integration/main.rs
+++ b/crates/oxc_codegen/tests/integration/main.rs
@@ -17,11 +17,7 @@ pub fn codegen(source_text: &str) -> String {
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
-        .enable_comment(
-            source_text,
-            ret.trivias,
-            CommentOptions { preserve_annotate_comments: true },
-        )
+        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
         .build(&ret.program)
         .code
 }
diff --git a/crates/oxc_codegen/tests/integration/tester.rs b/crates/oxc_codegen/tests/integration/tester.rs
index 6dd64ba49a1af..e6460fd82af45 100644
--- a/crates/oxc_codegen/tests/integration/tester.rs
+++ b/crates/oxc_codegen/tests/integration/tester.rs
@@ -8,11 +8,7 @@ pub fn test(source_text: &str, expected: &str) {
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let result = CodeGenerator::new()
-        .enable_comment(
-            source_text,
-            ret.trivias,
-            CommentOptions { preserve_annotate_comments: true },
-        )
+        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
         .build(&ret.program)
         .code;
     assert_eq!(result, expected, "\nfor source: {source_text:?}");
diff --git a/crates/oxc_isolated_declarations/examples/isolated_declarations.rs b/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
index fedc99f37c04a..2074fcb19d820 100644
--- a/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
+++ b/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
@@ -32,19 +32,11 @@ fn main() {
     println!("Original:\n");
     println!("{source_text}\n");
 
-    let id_ret = IsolatedDeclarations::new(
-        &allocator,
-        &source_text,
-        &ret.trivias,
-        IsolatedDeclarationsOptions { strip_internal: true },
-    )
-    .build(&ret.program);
+    let id_ret =
+        IsolatedDeclarations::new(&allocator, IsolatedDeclarationsOptions { strip_internal: true })
+            .build(&ret.program);
     let printed = CodeGenerator::new()
-        .enable_comment(
-            &source_text,
-            ret.trivias,
-            CommentOptions { preserve_annotate_comments: false },
-        )
+        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: false })
         .build(&id_ret.program)
         .code;
 
diff --git a/crates/oxc_isolated_declarations/src/lib.rs b/crates/oxc_isolated_declarations/src/lib.rs
index b3f65227e9648..84303623efda5 100644
--- a/crates/oxc_isolated_declarations/src/lib.rs
+++ b/crates/oxc_isolated_declarations/src/lib.rs
@@ -24,7 +24,7 @@ use std::{cell::RefCell, mem};
 use diagnostics::function_with_assigning_properties;
 use oxc_allocator::{Allocator, CloneIn};
 #[allow(clippy::wildcard_imports)]
-use oxc_ast::{ast::*, AstBuilder, Trivias, Visit, NONE};
+use oxc_ast::{ast::*, AstBuilder, Visit, NONE};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::{Atom, GetSpan, SourceType, SPAN};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -65,21 +65,12 @@ pub struct IsolatedDeclarations<'a> {
 }
 
 impl<'a> IsolatedDeclarations<'a> {
-    pub fn new(
-        allocator: &'a Allocator,
-        source_text: &str,
-        trivias: &Trivias,
-        options: IsolatedDeclarationsOptions,
-    ) -> Self {
+    pub fn new(allocator: &'a Allocator, options: IsolatedDeclarationsOptions) -> Self {
         let strip_internal = options.strip_internal;
-        let is_internal_set = strip_internal
-            .then(|| Self::build_internal_annotations(source_text, trivias))
-            .unwrap_or_default();
-
         Self {
             ast: AstBuilder::new(allocator),
             strip_internal,
-            internal_annotations: is_internal_set,
+            internal_annotations: FxHashSet::default(),
             scope: ScopeTree::new(allocator),
             errors: RefCell::new(vec![]),
         }
@@ -89,6 +80,10 @@ impl<'a> IsolatedDeclarations<'a> {
     ///
     /// Returns `Vec<Error>` if any errors were collected during the transformation.
     pub fn build(mut self, program: &Program<'a>) -> IsolatedDeclarationsReturn<'a> {
+        self.internal_annotations = self
+            .strip_internal
+            .then(|| Self::build_internal_annotations(program))
+            .unwrap_or_default();
         let source_type = SourceType::d_ts();
         let directives = self.ast.vec();
         let stmts = self.transform_program(program);
@@ -114,10 +109,10 @@ impl<'a> IsolatedDeclarations<'a> {
     }
 
     /// Build the lookup table for jsdoc `@internal`.
-    fn build_internal_annotations(source_text: &str, trivias: &Trivias) -> FxHashSet<u32> {
+    fn build_internal_annotations(program: &Program<'a>) -> FxHashSet<u32> {
         let mut set = FxHashSet::default();
-        for comment in trivias.comments() {
-            let has_internal = comment.span.source_text(source_text).contains("@internal");
+        for comment in &program.comments {
+            let has_internal = comment.span.source_text(program.source_text).contains("@internal");
             // Use the first jsdoc comment if there are multiple jsdoc comments for the same node.
             if has_internal && !set.contains(&comment.attached_to) {
                 set.insert(comment.attached_to);
diff --git a/crates/oxc_isolated_declarations/tests/deno/mod.rs b/crates/oxc_isolated_declarations/tests/deno/mod.rs
index d9ca61aecdb9d..b320b6738032c 100644
--- a/crates/oxc_isolated_declarations/tests/deno/mod.rs
+++ b/crates/oxc_isolated_declarations/tests/deno/mod.rs
@@ -15,8 +15,6 @@ mod tests {
         let ret = Parser::new(&allocator, source, source_type).parse();
         let ret = IsolatedDeclarations::new(
             &allocator,
-            source,
-            &ret.trivias,
             IsolatedDeclarationsOptions { strip_internal: true },
         )
         .build(&ret.program);
diff --git a/crates/oxc_isolated_declarations/tests/mod.rs b/crates/oxc_isolated_declarations/tests/mod.rs
index e67169764e6d2..dc0f18e6ca9e7 100644
--- a/crates/oxc_isolated_declarations/tests/mod.rs
+++ b/crates/oxc_isolated_declarations/tests/mod.rs
@@ -13,19 +13,11 @@ fn transform(path: &Path, source_text: &str) -> String {
     let source_type = SourceType::from_path(path).unwrap();
     let parser_ret = Parser::new(&allocator, source_text, source_type).parse();
 
-    let id_ret = IsolatedDeclarations::new(
-        &allocator,
-        source_text,
-        &parser_ret.trivias,
-        IsolatedDeclarationsOptions { strip_internal: true },
-    )
-    .build(&parser_ret.program);
+    let id_ret =
+        IsolatedDeclarations::new(&allocator, IsolatedDeclarationsOptions { strip_internal: true })
+            .build(&parser_ret.program);
     let code = CodeGenerator::new()
-        .enable_comment(
-            source_text,
-            parser_ret.trivias,
-            CommentOptions { preserve_annotate_comments: false },
-        )
+        .enable_comment(&parser_ret.program, CommentOptions { preserve_annotate_comments: false })
         .build(&id_ret.program)
         .code;
 
diff --git a/crates/oxc_language_server/src/linter.rs b/crates/oxc_language_server/src/linter.rs
index 6bc98d6b1c3f1..0191a26cf1640 100644
--- a/crates/oxc_language_server/src/linter.rs
+++ b/crates/oxc_language_server/src/linter.rs
@@ -260,11 +260,8 @@ impl IsolatedLintHandler {
             };
 
             let program = allocator.alloc(ret.program);
-            let semantic_ret = SemanticBuilder::new()
-                .with_cfg(true)
-                .with_trivias(ret.trivias)
-                .with_check_syntax_error(true)
-                .build(program);
+            let semantic_ret =
+                SemanticBuilder::new().with_cfg(true).with_check_syntax_error(true).build(program);
 
             if !semantic_ret.errors.is_empty() {
                 let reports = semantic_ret
@@ -278,7 +275,9 @@ impl IsolatedLintHandler {
                 return Some(Self::wrap_diagnostics(path, &source_text, reports, start));
             };
 
-            let result = self.linter.run(path, Rc::new(semantic_ret.semantic));
+            let mut semantic = semantic_ret.semantic;
+            semantic.set_irregular_whitespaces(ret.irregular_whitespaces);
+            let result = self.linter.run(path, Rc::new(semantic));
 
             let reports = result
                 .into_iter()
diff --git a/crates/oxc_linter/examples/linter.rs b/crates/oxc_linter/examples/linter.rs
index c93dbef31ac13..a2522866781ab 100644
--- a/crates/oxc_linter/examples/linter.rs
+++ b/crates/oxc_linter/examples/linter.rs
@@ -30,7 +30,7 @@ fn main() -> std::io::Result<()> {
     }
 
     let program = allocator.alloc(ret.program);
-    let semantic_ret = SemanticBuilder::new().with_trivias(ret.trivias).build(program);
+    let semantic_ret = SemanticBuilder::new().build(program);
 
     let mut errors: Vec<OxcDiagnostic> = vec![];
 
diff --git a/crates/oxc_linter/src/context/host.rs b/crates/oxc_linter/src/context/host.rs
index ceca3b8968211..f285ce5e60b7e 100644
--- a/crates/oxc_linter/src/context/host.rs
+++ b/crates/oxc_linter/src/context/host.rs
@@ -79,8 +79,7 @@ impl<'a> ContextHost<'a> {
         );
 
         let disable_directives =
-            DisableDirectivesBuilder::new(semantic.source_text(), semantic.trivias().clone())
-                .build();
+            DisableDirectivesBuilder::new().build(semantic.source_text(), semantic.comments());
 
         let file_path = file_path.as_ref().to_path_buf().into_boxed_path();
 
diff --git a/crates/oxc_linter/src/disable_directives.rs b/crates/oxc_linter/src/disable_directives.rs
index eada7a89aceb7..812229f1919b6 100644
--- a/crates/oxc_linter/src/disable_directives.rs
+++ b/crates/oxc_linter/src/disable_directives.rs
@@ -1,4 +1,4 @@
-use oxc_ast::Trivias;
+use oxc_ast::Comment;
 use oxc_span::Span;
 use rust_lapper::{Interval, Lapper};
 use rustc_hash::FxHashMap;
@@ -48,8 +48,6 @@ impl<'a> DisableDirectives<'a> {
 }
 
 pub struct DisableDirectivesBuilder<'a> {
-    source_text: &'a str,
-    trivias: Trivias,
     /// All the disabled rules with their corresponding covering spans
     intervals: Lapper<u32, DisabledRule<'a>>,
     /// Start of `eslint-disable` or `oxlint-disable`
@@ -63,10 +61,8 @@ pub struct DisableDirectivesBuilder<'a> {
 }
 
 impl<'a> DisableDirectivesBuilder<'a> {
-    pub fn new(source_text: &'a str, trivias: Trivias) -> Self {
+    pub fn new() -> Self {
         Self {
-            source_text,
-            trivias,
             intervals: Lapper::new(vec![]),
             disable_all_start: None,
             disable_start_map: FxHashMap::default(),
@@ -75,8 +71,8 @@ impl<'a> DisableDirectivesBuilder<'a> {
         }
     }
 
-    pub fn build(mut self) -> DisableDirectives<'a> {
-        self.build_impl();
+    pub fn build(mut self, source_text: &'a str, comments: &[Comment]) -> DisableDirectives<'a> {
+        self.build_impl(source_text, comments);
         DisableDirectives {
             intervals: self.intervals,
             disable_all_comments: self.disable_all_comments.into_boxed_slice(),
@@ -89,13 +85,13 @@ impl<'a> DisableDirectivesBuilder<'a> {
     }
 
     #[allow(clippy::cast_possible_truncation)] // for `as u32`
-    fn build_impl(&mut self) {
-        let source_len = self.source_text.len() as u32;
+    fn build_impl(&mut self, source_text: &'a str, comments: &[Comment]) {
+        let source_len = source_text.len() as u32;
         // This algorithm iterates through the comments and builds all intervals
         // for matching disable and enable pairs.
         // Wrongly ordered matching pairs are not taken into consideration.
-        for comment in self.trivias.clone().comments() {
-            let text = comment.span.source_text(self.source_text);
+        for comment in comments {
+            let text = comment.span.source_text(source_text);
             let text = text.trim_start();
 
             if let Some(text) =
@@ -112,7 +108,7 @@ impl<'a> DisableDirectivesBuilder<'a> {
                 // `eslint-disable-next-line`
                 else if let Some(text) = text.strip_prefix("-next-line") {
                     // Get the span up to the next new line
-                    let stop = self.source_text[comment.span.end as usize..]
+                    let stop = source_text[comment.span.end as usize..]
                         .lines()
                         .take(2)
                         .fold(comment.span.end, |acc, line| acc + line.len() as u32);
@@ -138,7 +134,7 @@ impl<'a> DisableDirectivesBuilder<'a> {
                 // `eslint-disable-line`
                 else if let Some(text) = text.strip_prefix("-line") {
                     // Get the span between the preceding newline to this comment
-                    let start = self.source_text[..=comment.span.start as usize]
+                    let start = source_text[..=comment.span.start as usize]
                         .lines()
                         .next_back()
                         .map_or(0, |line| comment.span.start - (line.len() as u32 - 1));
@@ -369,7 +365,7 @@ fn test() {
             debugger;
 
             debugger; /*{prefix}-disable-line*/
-            
+
             debugger; //{prefix}-disable-line no-debugger
 
             //{prefix}-disable-next-line no-debugger
@@ -393,7 +389,7 @@ fn test() {
             debugger;
 
             debugger; /*    {prefix}-disable-line       */
-            
+
             debugger; //            {prefix}-disable-line no-debugger
 
             //          {prefix}-disable-next-line no-debugger
@@ -597,15 +593,15 @@ semi*/
             "
             ),
             format!(
-                "debugger; //   \t\t {prefix}-disable-line   \t\t  no-alert,   \t\t quotes,   \t\t semi   \t\t 
+                "debugger; //   \t\t {prefix}-disable-line   \t\t  no-alert,   \t\t quotes,   \t\t semi   \t\t
             //   \t\t {prefix}-disable-next-line   \t\t  no-alert,   \t\t quotes,   \t\t semi
             debugger;
             debugger; /*   \t\t {prefix}-disable-line    \t\t no-alert,   \t\t quotes,   \t\t semi   \t\t  */
             /*   \t\t {prefix}-disable-next-line   \t\t  no-alert,   \t\t quotes,   \t\t semi */
             debugger;
             /*  \t\t {prefix}-disable-next-line
-  \t\t no-alert,  \t\t 
-  \t\t quotes,  \t\t 
+  \t\t no-alert,  \t\t
+  \t\t quotes,  \t\t
   \t\t semi  \t\t */
             debugger;
         "
diff --git a/crates/oxc_linter/src/rules/eslint/default_case.rs b/crates/oxc_linter/src/rules/eslint/default_case.rs
index e3e329dcf1929..59977313b665b 100644
--- a/crates/oxc_linter/src/rules/eslint/default_case.rs
+++ b/crates/oxc_linter/src/rules/eslint/default_case.rs
@@ -76,7 +76,6 @@ impl Rule for DefaultCase {
 
             let has_default_comment = ctx
                 .semantic()
-                .trivias()
                 .comments_range(last_case.span.start..switch.span.end)
                 .last()
                 .is_some_and(|comment| {
diff --git a/crates/oxc_linter/src/rules/eslint/max_lines.rs b/crates/oxc_linter/src/rules/eslint/max_lines.rs
index 1f6a3955b0d44..2311b346a411b 100644
--- a/crates/oxc_linter/src/rules/eslint/max_lines.rs
+++ b/crates/oxc_linter/src/rules/eslint/max_lines.rs
@@ -82,7 +82,7 @@ impl Rule for MaxLines {
     fn run_once(&self, ctx: &LintContext) {
         let comment_lines = if self.skip_comments {
             let mut comment_lines: usize = 0;
-            for comment in ctx.semantic().trivias().comments() {
+            for comment in ctx.semantic().comments() {
                 if comment.is_line() {
                     let comment_line = ctx.source_text()[..comment.span.start as usize]
                         .lines()
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty.rs b/crates/oxc_linter/src/rules/eslint/no_empty.rs
index 4949672d74907..5ee42bec6415b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty.rs
@@ -54,7 +54,7 @@ impl Rule for NoEmpty {
                     return;
                 }
 
-                if ctx.semantic().trivias().has_comments_between(block.span) {
+                if ctx.semantic().has_comments_between(block.span) {
                     return;
                 }
                 ctx.diagnostic_with_suggestion(no_empty_diagnostic("block", block.span), |fixer| {
@@ -72,7 +72,7 @@ impl Rule for NoEmpty {
             // The visitor does not visit the `BlockStatement` inside the `FinallyClause`.
             // See `Visit::visit_finally_clause`.
             AstKind::FinallyClause(finally_clause) if finally_clause.body.is_empty() => {
-                if ctx.semantic().trivias().has_comments_between(finally_clause.span) {
+                if ctx.semantic().has_comments_between(finally_clause.span) {
                     return;
                 }
                 ctx.diagnostic_with_suggestion(
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_function.rs b/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
index 2eea58efe2b74..2a50b77550c81 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
@@ -65,7 +65,7 @@ impl Rule for NoEmptyFunction {
         let AstKind::FunctionBody(fb) = node.kind() else {
             return;
         };
-        if fb.is_empty() && !ctx.semantic().trivias().has_comments_between(fb.span) {
+        if fb.is_empty() && !ctx.semantic().has_comments_between(fb.span) {
             let (kind, fn_name) = get_function_name_and_kind(node, ctx);
             ctx.diagnostic(no_empty_function_diagnostic(fb.span, kind, fn_name));
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs b/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
index 2ac6e0d24d6fd..24de7dc61d01a 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
@@ -55,7 +55,7 @@ impl Rule for NoEmptyStaticBlock {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::StaticBlock(static_block) = node.kind() {
             if static_block.body.is_empty() {
-                if ctx.semantic().trivias().has_comments_between(static_block.span) {
+                if ctx.semantic().has_comments_between(static_block.span) {
                     return;
                 }
                 ctx.diagnostic(no_empty_static_block_diagnostic(static_block.span));
diff --git a/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs b/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
index 8fce6e0fdd48a..4476fe38b9711 100644
--- a/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
@@ -381,7 +381,6 @@ impl NoFallthrough {
         let semantic = ctx.semantic();
         let is_fallthrough_comment_in_range = |range: Range<u32>| {
             let comment = semantic
-                .trivias()
                 .comments_range(range)
                 .map(|comment| {
                     &semantic.source_text()[comment.span.start as usize..comment.span.end as usize]
diff --git a/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs b/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
index 7a32b33668fd5..5729c450ec1cb 100644
--- a/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
@@ -33,7 +33,7 @@ declare_oxc_lint!(
 
 impl Rule for NoIrregularWhitespace {
     fn run_once(&self, ctx: &LintContext) {
-        let irregular_whitespaces = ctx.semantic().trivias().irregular_whitespaces();
+        let irregular_whitespaces = ctx.semantic().irregular_whitespaces();
         for irregular_whitespace in irregular_whitespaces {
             ctx.diagnostic(no_irregular_whitespace_diagnostic(*irregular_whitespace));
         }
diff --git a/crates/oxc_linter/src/rules/eslint/sort_imports.rs b/crates/oxc_linter/src/rules/eslint/sort_imports.rs
index b5473af98bb80..7e8b4408f19bb 100644
--- a/crates/oxc_linter/src/rules/eslint/sort_imports.rs
+++ b/crates/oxc_linter/src/rules/eslint/sort_imports.rs
@@ -302,7 +302,7 @@ impl SortImports {
         // import { /* comment */ a, b, c, d } from 'foo.js'
         // ```
         // I use ImportStatement's span to check if there are comments between the specifiers.
-        let is_fixable = !ctx.semantic().trivias().has_comments_between(current.span);
+        let is_fixable = !ctx.semantic().has_comments_between(current.span);
 
         if is_fixable {
             // Safe to index because we know that `specifiers` is at least 2 element long
diff --git a/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs b/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
index d4552c1ea7dee..089b017666a4e 100644
--- a/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
+++ b/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
@@ -59,9 +59,9 @@ impl Rule for NoCommentedOutTests {
             static ref RE: Regex =
             Regex::new(r#"(?mu)^\s*[xf]?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\("#).unwrap();
         }
-        let comments = ctx.semantic().trivias().comments();
+        let comments = ctx.semantic().comments();
         let source_text = ctx.semantic().source_text();
-        let commented_tests = comments.filter_map(|comment| {
+        let commented_tests = comments.iter().filter_map(|comment| {
             let text = comment.span.source_text(source_text);
             if RE.is_match(text) {
                 Some(comment.span)
diff --git a/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs b/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
index 8bfc9b8c918e8..cafcf4514b6c8 100644
--- a/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
+++ b/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
@@ -155,7 +155,7 @@ impl Rule for BanTsComment {
     }
 
     fn run_once(&self, ctx: &LintContext) {
-        let comments = ctx.semantic().trivias().comments();
+        let comments = ctx.semantic().comments();
         for comm in comments {
             let raw = ctx.source_range(comm.span);
             if let Some(captures) = find_ts_comment_directive(raw, comm.is_line()) {
diff --git a/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs b/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
index be50f9de759e4..6f3a08da1d2d3 100644
--- a/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
+++ b/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
@@ -33,7 +33,7 @@ declare_oxc_lint!(
 
 impl Rule for BanTslintComment {
     fn run_once(&self, ctx: &LintContext) {
-        let comments = ctx.semantic().trivias().comments();
+        let comments = ctx.semantic().comments();
         let source_text_len = ctx.semantic().source_text().len();
 
         for comment in comments {
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs b/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
index d5ef6a106a2d1..82ad8493ab6bd 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
@@ -159,15 +159,12 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                                         }
                                     }
 
-                                    let has_comments = ctx
-                                        .semantic()
-                                        .trivias()
-                                        .has_comments_between(interface_decl.span);
+                                    let has_comments =
+                                        ctx.semantic().has_comments_between(interface_decl.span);
 
                                     if has_comments {
                                         let comments = ctx
                                             .semantic()
-                                            .trivias()
                                             .comments_range(node_start..node_end)
                                             .map(|comment| (*comment, comment.span));
 
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs b/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
index 0eb26802eefa1..d0a138798b47a 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
@@ -48,7 +48,7 @@ declare_oxc_lint!(
 
 impl Rule for PreferTsExpectError {
     fn run_once(&self, ctx: &LintContext) {
-        let comments = ctx.semantic().trivias().comments();
+        let comments = ctx.semantic().comments();
 
         for comment in comments {
             let raw = comment.span.source_text(ctx.semantic().source_text());
diff --git a/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs b/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
index 509bd9217a75e..2adab5bcb3f99 100644
--- a/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
+++ b/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
@@ -114,7 +114,7 @@ impl Rule for TripleSlashReference {
         let comments_range_end = program.body.first().map_or(program.span.end, |v| v.span().start);
         let mut refs_for_import = FxHashMap::default();
 
-        for comment in ctx.semantic().trivias().comments_range(0..comments_range_end) {
+        for comment in ctx.semantic().comments_range(0..comments_range_end) {
             let raw = &ctx.semantic().source_text()
                 [comment.span.start as usize..comment.span.end as usize];
             if let Some((group1, group2)) = get_attr_key_and_value(raw) {
diff --git a/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs b/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
index bc8dafdf9ae6e..17f867bd3ae0b 100644
--- a/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
+++ b/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
@@ -43,7 +43,7 @@ impl Rule for EmptyBraceSpaces {
 
                 if static_block.body.is_empty()
                     && end - start > static_leading_count + 2
-                    && !ctx.semantic().trivias().has_comments_between(static_block.span)
+                    && !ctx.semantic().has_comments_between(static_block.span)
                 {
                     ctx.diagnostic_with_fix(
                         empty_brace_spaces_diagnostic(static_block.span),
@@ -79,7 +79,7 @@ fn remove_empty_braces_spaces(ctx: &LintContext, is_empty_body: bool, span: Span
     let start = span.start;
     let end = span.end;
 
-    if is_empty_body && end - start > 2 && !ctx.semantic().trivias().has_comments_between(span) {
+    if is_empty_body && end - start > 2 && !ctx.semantic().has_comments_between(span) {
         // length of "{}"
         ctx.diagnostic_with_fix(empty_brace_spaces_diagnostic(span), |fixer| {
             fixer.replace(span, "{}")
diff --git a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
index dc928bf8dbc2a..37732d5cfc59c 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
@@ -69,7 +69,7 @@ impl Rule for NoEmptyFile {
 }
 
 fn has_triple_slash_directive(ctx: &LintContext<'_>) -> bool {
-    for comment in ctx.semantic().trivias().comments() {
+    for comment in ctx.semantic().comments() {
         if !comment.is_line() {
             continue;
         }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_magic_array_flat_depth.rs b/crates/oxc_linter/src/rules/unicorn/no_magic_array_flat_depth.rs
index 33f08fb5ea3a0..eccf93ac98b3b 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_magic_array_flat_depth.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_magic_array_flat_depth.rs
@@ -72,12 +72,8 @@ impl Rule for NoMagicArrayFlatDepth {
             return;
         };
 
-        let has_explaining_comment = ctx
-            .semantic()
-            .trivias()
-            .comments_range(arguments_span.start..arguments_span.end)
-            .count()
-            != 0;
+        let has_explaining_comment =
+            ctx.semantic().comments_range(arguments_span.start..arguments_span.end).count() != 0;
 
         if has_explaining_comment {
             return;
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_undefined.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_undefined.rs
index 56a01a718b7ce..c5ea0e8b7f7f6 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_undefined.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_undefined.rs
@@ -184,7 +184,6 @@ impl Rule for NoUselessUndefined {
                             |fixer| {
                                 let delete_span = if let Some(comment) = ctx
                                     .semantic()
-                                    .trivias()
                                     .comments_range(ret_stmt.span.start..ret_stmt.span.end)
                                     .last()
                                 {
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
index 1820efb090099..43bcdfb0e1d76 100644
--- a/crates/oxc_linter/src/service/runtime.rs
+++ b/crates/oxc_linter/src/service/runtime.rs
@@ -202,18 +202,13 @@ impl Runtime {
             return ret.errors.into_iter().map(|err| Message::new(err, None)).collect();
         };
 
-        let program = allocator.alloc(ret.program);
-
-        let trivias = ret.trivias;
-
         // Build the module record to unblock other threads from waiting for too long.
         // The semantic model is not built at this stage.
         let semantic_builder = SemanticBuilder::new()
             .with_cfg(true)
-            .with_trivias(trivias)
             .with_build_jsdoc(true)
             .with_check_syntax_error(check_syntax_errors)
-            .build_module_record(path, program);
+            .build_module_record(path, &ret.program);
         let module_record = semantic_builder.module_record();
 
         if self.resolver.is_some() {
@@ -284,13 +279,16 @@ impl Runtime {
             }
         }
 
+        let program = allocator.alloc(ret.program);
         let semantic_ret = semantic_builder.build(program);
 
         if !semantic_ret.errors.is_empty() {
             return semantic_ret.errors.into_iter().map(|err| Message::new(err, None)).collect();
         };
 
-        self.linter.run(path, Rc::new(semantic_ret.semantic))
+        let mut semantic = semantic_ret.semantic;
+        semantic.set_irregular_whitespaces(ret.irregular_whitespaces);
+        self.linter.run(path, Rc::new(semantic))
     }
 
     pub(super) fn init_cache_state(&self, path: &Path) -> bool {
diff --git a/crates/oxc_linter/src/utils/tree_shaking.rs b/crates/oxc_linter/src/utils/tree_shaking.rs
index 0f6f83dd5f738..0dded6cdf9634 100644
--- a/crates/oxc_linter/src/utils/tree_shaking.rs
+++ b/crates/oxc_linter/src/utils/tree_shaking.rs
@@ -223,7 +223,7 @@ fn flatten_member_expr_if_possible(function_name: &FunctionName) -> CompactStr {
 ///
 /// <https://rollupjs.org/configuration-options/#pure>
 pub fn has_pure_notation(span: Span, ctx: &LintContext) -> bool {
-    let Some(comment) = ctx.semantic().trivias().comments_range(..span.start).next_back() else {
+    let Some(comment) = ctx.semantic().comments_range(..span.start).next_back() else {
         return false;
     };
     let raw = comment.span.source_text(ctx.semantic().source_text());
@@ -263,7 +263,7 @@ pub fn has_comment_about_side_effect_check(span: Span, ctx: &LintContext) -> boo
 /// let e = 2
 /// ```
 pub fn get_leading_tree_shaking_comment<'a>(span: Span, ctx: &LintContext<'a>) -> Option<&'a str> {
-    let comment = ctx.semantic().trivias().comments_range(..span.start).next_back()?;
+    let comment = ctx.semantic().comments_range(..span.start).next_back()?;
 
     let comment_text = comment.span.source_text(ctx.source_text());
 
diff --git a/crates/oxc_parser/examples/parser.rs b/crates/oxc_parser/examples/parser.rs
index fe3f863988168..7e43ee125c94d 100644
--- a/crates/oxc_parser/examples/parser.rs
+++ b/crates/oxc_parser/examples/parser.rs
@@ -34,7 +34,7 @@ fn main() -> Result<(), String> {
 
     if show_comments {
         println!("Comments:");
-        for comment in ret.trivias.comments() {
+        for comment in ret.program.comments {
             let s = comment.real_span().source_text(&source_text);
             println!("{s}");
         }
diff --git a/crates/oxc_parser/examples/parser_tsx.rs b/crates/oxc_parser/examples/parser_tsx.rs
index 4ba88838e19cb..27507f39422e1 100644
--- a/crates/oxc_parser/examples/parser_tsx.rs
+++ b/crates/oxc_parser/examples/parser_tsx.rs
@@ -30,11 +30,11 @@ export const Counter: React.FC = () => {
         program,  // AST
         errors,   // Syntax errors
         panicked, // Parser encountered an error it couldn't recover from
-        trivias,  // Comments, whitespace, etc.
+        ..
     } = Parser::new(&allocator, source_text, source_type).parse();
 
     assert!(!panicked);
     assert!(errors.is_empty());
     assert!(!program.body.is_empty());
-    assert_eq!(trivias.comments().count(), 1);
+    assert_eq!(program.comments.len(), 1);
 }
diff --git a/crates/oxc_parser/src/lexer/trivia_builder.rs b/crates/oxc_parser/src/lexer/trivia_builder.rs
index acbe2294c88d5..e3449a6fa82c6 100644
--- a/crates/oxc_parser/src/lexer/trivia_builder.rs
+++ b/crates/oxc_parser/src/lexer/trivia_builder.rs
@@ -1,7 +1,4 @@
-use oxc_ast::{
-    ast::{Comment, CommentKind, CommentPosition},
-    Trivias,
-};
+use oxc_ast::ast::{Comment, CommentKind, CommentPosition};
 use oxc_span::Span;
 
 use super::{Kind, Token};
@@ -13,7 +10,7 @@ pub struct TriviaBuilder {
     // filtered out at insertion time.
     pub(crate) comments: Vec<Comment>,
 
-    irregular_whitespaces: Vec<Span>,
+    pub(crate) irregular_whitespaces: Vec<Span>,
 
     // states
     /// index of processed comments
@@ -39,10 +36,6 @@ impl Default for TriviaBuilder {
 }
 
 impl TriviaBuilder {
-    pub fn build(self) -> Trivias {
-        Trivias::new(self.comments.into_boxed_slice(), self.irregular_whitespaces)
-    }
-
     pub fn add_irregular_whitespace(&mut self, start: u32, end: u32) {
         self.irregular_whitespaces.push(Span::new(start, end));
     }
@@ -122,7 +115,7 @@ mod test {
         let allocator = Allocator::default();
         let source_type = SourceType::default();
         let ret = Parser::new(&allocator, source_text, source_type).parse();
-        ret.trivias.comments().copied().collect::<Vec<_>>()
+        ret.program.comments.iter().copied().collect::<Vec<_>>()
     }
 
     #[test]
diff --git a/crates/oxc_parser/src/lib.rs b/crates/oxc_parser/src/lib.rs
index ee6d242b9ccb5..fe76fff88538d 100644
--- a/crates/oxc_parser/src/lib.rs
+++ b/crates/oxc_parser/src/lib.rs
@@ -88,7 +88,7 @@ use context::{Context, StatementContext};
 use oxc_allocator::Allocator;
 use oxc_ast::{
     ast::{Expression, Program},
-    AstBuilder, Trivias,
+    AstBuilder,
 };
 use oxc_diagnostics::{OxcDiagnostic, Result};
 use oxc_span::{ModuleKind, SourceType, Span};
@@ -156,8 +156,8 @@ pub struct ParserReturn<'a> {
     /// [`SemanticBuilder::with_check_syntax_error`](https://docs.rs/oxc_semantic/latest/oxc_semantic/struct.SemanticBuilder.html#method.with_check_syntax_error).
     pub errors: Vec<OxcDiagnostic>,
 
-    /// Comments and whitespace
-    pub trivias: Trivias,
+    /// Irregular whitespaces for `Oxlint`
+    pub irregular_whitespaces: Box<[Span]>,
 
     /// Whether the parser panicked and terminated early.
     ///
@@ -425,8 +425,9 @@ impl<'a> ParserImpl<'a> {
             errors.extend(self.lexer.errors);
             errors.extend(self.errors);
         }
-        let trivias = self.lexer.trivia_builder.build();
-        ParserReturn { program, errors, trivias, panicked }
+        let irregular_whitespaces =
+            self.lexer.trivia_builder.irregular_whitespaces.into_boxed_slice();
+        ParserReturn { program, errors, irregular_whitespaces, panicked }
     }
 
     pub fn parse_expression(mut self) -> std::result::Result<Expression<'a>, Vec<OxcDiagnostic>> {
@@ -623,7 +624,7 @@ mod test {
         ];
         for (source, kind) in sources {
             let ret = Parser::new(&allocator, source, source_type).parse();
-            let comments = ret.trivias.comments().collect::<Vec<_>>();
+            let comments = &ret.program.comments;
             assert_eq!(comments.len(), 1, "{source}");
             assert_eq!(comments.first().unwrap().kind, kind, "{source}");
         }
diff --git a/crates/oxc_prettier/examples/prettier.rs b/crates/oxc_prettier/examples/prettier.rs
index 26b849d0756b0..038819de2d6c3 100644
--- a/crates/oxc_prettier/examples/prettier.rs
+++ b/crates/oxc_prettier/examples/prettier.rs
@@ -28,7 +28,6 @@ fn main() -> std::io::Result<()> {
     let output = Prettier::new(
         &allocator,
         &source_text,
-        ret.trivias,
         PrettierOptions { semi, trailing_comma: TrailingComma::All, ..PrettierOptions::default() },
     )
     .build(&ret.program);
diff --git a/crates/oxc_prettier/src/lib.rs b/crates/oxc_prettier/src/lib.rs
index aad776e8b775e..5475ecee1b36f 100644
--- a/crates/oxc_prettier/src/lib.rs
+++ b/crates/oxc_prettier/src/lib.rs
@@ -17,7 +17,7 @@ mod utils;
 use std::vec;
 
 use oxc_allocator::Allocator;
-use oxc_ast::{ast::Program, AstKind, Trivias};
+use oxc_ast::{ast::Program, AstKind};
 use oxc_span::Span;
 use oxc_syntax::identifier::is_line_terminator;
 
@@ -54,8 +54,6 @@ pub struct Prettier<'a> {
 
     options: PrettierOptions,
 
-    trivias: Trivias,
-
     /// The stack of AST Nodes
     /// See <https://github.com/prettier/prettier/blob/main/src/common/ast-path.js>
     stack: Vec<AstKind<'a>>,
@@ -73,17 +71,11 @@ impl<'a> DocBuilder<'a> for Prettier<'a> {
 
 impl<'a> Prettier<'a> {
     #[allow(clippy::needless_pass_by_value)]
-    pub fn new(
-        allocator: &'a Allocator,
-        source_text: &'a str,
-        trivias: Trivias,
-        options: PrettierOptions,
-    ) -> Self {
+    pub fn new(allocator: &'a Allocator, source_text: &'a str, options: PrettierOptions) -> Self {
         Self {
             allocator,
             source_text,
             options,
-            trivias,
             stack: vec![],
             group_id_builder: GroupIdBuilder::default(),
             args: PrettierArgs::default(),
diff --git a/crates/oxc_semantic/examples/cfg.rs b/crates/oxc_semantic/examples/cfg.rs
index e3a94b4ca3451..c97fc89bfc0e9 100644
--- a/crates/oxc_semantic/examples/cfg.rs
+++ b/crates/oxc_semantic/examples/cfg.rs
@@ -55,11 +55,8 @@ fn main() -> std::io::Result<()> {
     std::fs::write(ast_file_path, format!("{:#?}", &program))?;
     println!("Wrote AST to: {}", &ast_file_name);
 
-    let semantic = SemanticBuilder::new()
-        .with_check_syntax_error(true)
-        .with_trivias(parser_ret.trivias)
-        .with_cfg(true)
-        .build(program);
+    let semantic =
+        SemanticBuilder::new().with_check_syntax_error(true).with_cfg(true).build(program);
 
     if !semantic.errors.is_empty() {
         let error_message: String = semantic
diff --git a/crates/oxc_semantic/examples/simple.rs b/crates/oxc_semantic/examples/simple.rs
index 29609e2a079bd..a8d2a10af0d6c 100644
--- a/crates/oxc_semantic/examples/simple.rs
+++ b/crates/oxc_semantic/examples/simple.rs
@@ -38,8 +38,6 @@ fn main() -> std::io::Result<()> {
         .build_module_record(path, program)
         // Enable additional syntax checks not performed by the parser
         .with_check_syntax_error(true)
-        // Inform Semantic about comments found while parsing
-        .with_trivias(parser_ret.trivias)
         .build(program);
 
     if !semantic.errors.is_empty() {
diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs
index 45aa581730d40..000e1a34c92db 100644
--- a/crates/oxc_semantic/src/builder.rs
+++ b/crates/oxc_semantic/src/builder.rs
@@ -9,7 +9,7 @@ use std::{
 use rustc_hash::FxHashMap;
 
 #[allow(clippy::wildcard_imports)]
-use oxc_ast::{ast::*, AstKind, Trivias, Visit};
+use oxc_ast::{ast::*, AstKind, Visit};
 use oxc_cfg::{
     ControlFlowGraphBuilder, CtxCursor, CtxFlags, EdgeType, ErrorEdgeKind,
     IterationInstructionKind, ReturnInstructionKind,
@@ -66,8 +66,6 @@ pub struct SemanticBuilder<'a> {
     /// source type of the parsed program
     pub(crate) source_type: SourceType,
 
-    trivias: Trivias,
-
     /// Semantic early errors such as redeclaration errors.
     errors: RefCell<Vec<OxcDiagnostic>>,
 
@@ -130,11 +128,9 @@ impl<'a> SemanticBuilder<'a> {
         let scope = ScopeTree::default();
         let current_scope_id = scope.root_scope_id();
 
-        let trivias = Trivias::default();
         Self {
             source_text: "",
             source_type: SourceType::default(),
-            trivias: trivias.clone(),
             errors: RefCell::new(vec![]),
             current_node_id: NodeId::new(0),
             current_node_flags: NodeFlags::empty(),
@@ -161,12 +157,6 @@ impl<'a> SemanticBuilder<'a> {
         }
     }
 
-    #[must_use]
-    pub fn with_trivias(mut self, trivias: Trivias) -> Self {
-        self.trivias = trivias;
-        self
-    }
-
     /// Enable/disable additional syntax checks.
     ///
     /// Set this to `true` to enable additional syntax checks. Without these,
@@ -181,7 +171,6 @@ impl<'a> SemanticBuilder<'a> {
     }
 
     /// Enable/disable JSDoc parsing.
-    /// `with_trivias` must be called prior to this call.
     #[must_use]
     pub fn with_build_jsdoc(mut self, yes: bool) -> Self {
         self.build_jsdoc = yes;
@@ -260,7 +249,7 @@ impl<'a> SemanticBuilder<'a> {
         self.source_text = program.source_text;
         self.source_type = program.source_type;
         if self.build_jsdoc {
-            self.jsdoc = JSDocBuilder::new(self.source_text, &self.trivias);
+            self.jsdoc = JSDocBuilder::new(self.source_text, &program.comments);
         }
         if self.source_type.is_typescript_definition() {
             let scope_id = self.scope.add_scope(None, NodeId::DUMMY, ScopeFlags::Top);
@@ -311,6 +300,8 @@ impl<'a> SemanticBuilder<'a> {
             }
         }
 
+        let comments = self.alloc(&program.comments);
+
         debug_assert_eq!(self.unresolved_references.scope_depth(), 1);
         self.scope.root_unresolved_references = self
             .unresolved_references
@@ -324,7 +315,8 @@ impl<'a> SemanticBuilder<'a> {
         let semantic = Semantic {
             source_text: self.source_text,
             source_type: self.source_type,
-            trivias: self.trivias,
+            comments,
+            irregular_whitespaces: [].into(),
             nodes: self.nodes,
             scopes: self.scope,
             symbols: self.symbols,
diff --git a/crates/oxc_semantic/src/jsdoc/builder.rs b/crates/oxc_semantic/src/jsdoc/builder.rs
index 3f655d47daa85..f7cbcc7cbae0e 100644
--- a/crates/oxc_semantic/src/jsdoc/builder.rs
+++ b/crates/oxc_semantic/src/jsdoc/builder.rs
@@ -1,6 +1,6 @@
 use rustc_hash::FxHashMap;
 
-use oxc_ast::{ast::Comment, AstKind, Trivias};
+use oxc_ast::{ast::Comment, AstKind};
 use oxc_span::{GetSpan, Span};
 
 use crate::jsdoc::JSDocFinder;
@@ -14,9 +14,9 @@ pub struct JSDocBuilder<'a> {
 }
 
 impl<'a> JSDocBuilder<'a> {
-    pub fn new(source_text: &'a str, trivias: &Trivias) -> Self {
+    pub fn new(source_text: &'a str, comments: &[Comment]) -> Self {
         let mut not_attached_docs: FxHashMap<u32, Vec<_>> = FxHashMap::default();
-        for comment in trivias.comments().filter(|comment| comment.is_jsdoc(source_text)) {
+        for comment in comments.iter().filter(|comment| comment.is_jsdoc(source_text)) {
             not_attached_docs
                 .entry(comment.attached_to)
                 .or_default()
@@ -208,11 +208,7 @@ mod test {
         let source_type = source_type.unwrap_or_default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new()
-            .with_trivias(ret.trivias)
-            .with_build_jsdoc(true)
-            .build(program)
-            .semantic;
+        let semantic = SemanticBuilder::new().with_build_jsdoc(true).build(program).semantic;
         semantic
     }
 
diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
index ddd8d3c757e55..d10bb473c00fb 100644
--- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
+++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc.rs
@@ -46,11 +46,7 @@ mod test {
         let source_type = SourceType::default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new()
-            .with_trivias(ret.trivias)
-            .with_build_jsdoc(true)
-            .build(program)
-            .semantic;
+        let semantic = SemanticBuilder::new().with_build_jsdoc(true).build(program).semantic;
         semantic
     }
 
diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
index de79328e0a4ca..2567f4f42f662 100644
--- a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
+++ b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
@@ -195,11 +195,7 @@ mod test {
         let source_type = SourceType::default();
         let ret = Parser::new(allocator, source_text, source_type).parse();
         let program = allocator.alloc(ret.program);
-        let semantic = SemanticBuilder::new()
-            .with_trivias(ret.trivias)
-            .with_build_jsdoc(true)
-            .build(program)
-            .semantic;
+        let semantic = SemanticBuilder::new().with_build_jsdoc(true).build(program).semantic;
         semantic
     }
 
diff --git a/crates/oxc_semantic/src/lib.rs b/crates/oxc_semantic/src/lib.rs
index 65db5557fb02b..54bd7ebae3f88 100644
--- a/crates/oxc_semantic/src/lib.rs
+++ b/crates/oxc_semantic/src/lib.rs
@@ -5,9 +5,12 @@
 #![doc = include_str!("../examples/simple.rs")]
 //! ```
 
+use std::ops::RangeBounds;
 use std::sync::Arc;
 
-use oxc_ast::{ast::IdentifierReference, AstKind, Trivias};
+use oxc_ast::{
+    ast::IdentifierReference, comments_range, has_comments_between, AstKind, Comment, CommentsRange,
+};
 use oxc_cfg::ControlFlowGraph;
 use oxc_span::{GetSpan, SourceType, Span};
 pub use oxc_syntax::{
@@ -76,7 +79,8 @@ pub struct Semantic<'a> {
     classes: ClassTable,
 
     /// Parsed comments.
-    trivias: Trivias,
+    comments: &'a oxc_allocator::Vec<'a, Comment>,
+    irregular_whitespaces: Box<[Span]>,
 
     module_record: Arc<ModuleRecord>,
 
@@ -127,9 +131,28 @@ impl<'a> Semantic<'a> {
         &mut self.scopes
     }
 
+    pub fn set_irregular_whitespaces(&mut self, irregular_whitespaces: Box<[Span]>) {
+        self.irregular_whitespaces = irregular_whitespaces;
+    }
+
     /// Trivias (comments) found while parsing
-    pub fn trivias(&self) -> &Trivias {
-        &self.trivias
+    pub fn comments(&self) -> &[Comment] {
+        self.comments
+    }
+
+    pub fn comments_range<R>(&self, range: R) -> CommentsRange<'_>
+    where
+        R: RangeBounds<u32>,
+    {
+        comments_range(self.comments, range)
+    }
+
+    pub fn has_comments_between(&self, span: Span) -> bool {
+        has_comments_between(self.comments, span)
+    }
+
+    pub fn irregular_whitespaces(&self) -> &[Span] {
+        &self.irregular_whitespaces
     }
 
     /// Parsed [`JSDoc`] comments.
diff --git a/crates/oxc_semantic/tests/integration/util/mod.rs b/crates/oxc_semantic/tests/integration/util/mod.rs
index 505739d46f3f2..77e9e50253872 100644
--- a/crates/oxc_semantic/tests/integration/util/mod.rs
+++ b/crates/oxc_semantic/tests/integration/util/mod.rs
@@ -169,7 +169,6 @@ impl<'a> SemanticTester<'a> {
         let program = self.allocator.alloc(parse.program);
         SemanticBuilder::new()
             .with_check_syntax_error(true)
-            .with_trivias(parse.trivias)
             .with_cfg(self.cfg)
             .with_scope_tree_child_ids(self.scope_tree_child_ids)
             .build(program)
diff --git a/crates/oxc_transformer/examples/transformer.rs b/crates/oxc_transformer/examples/transformer.rs
index a99222b468304..b851b6890561a 100644
--- a/crates/oxc_transformer/examples/transformer.rs
+++ b/crates/oxc_transformer/examples/transformer.rs
@@ -38,7 +38,6 @@ fn main() {
     println!("{source_text}\n");
 
     let mut program = ret.program;
-    let trivias = ret.trivias;
 
     let ret = SemanticBuilder::new()
         // Estimate transformer will triple scopes, symbols, references
@@ -65,8 +64,11 @@ fn main() {
         TransformOptions::enable_all()
     };
 
-    let ret = Transformer::new(&allocator, path, trivias.clone(), transform_options)
-        .build_with_symbols_and_scopes(symbols, scopes, &mut program);
+    let ret = Transformer::new(&allocator, path, transform_options).build_with_symbols_and_scopes(
+        symbols,
+        scopes,
+        &mut program,
+    );
 
     if !ret.errors.is_empty() {
         println!("Transformer Errors:");
diff --git a/crates/oxc_transformer/src/context.rs b/crates/oxc_transformer/src/context.rs
index aba1ec3c57b13..6a90318f1d2f9 100644
--- a/crates/oxc_transformer/src/context.rs
+++ b/crates/oxc_transformer/src/context.rs
@@ -4,7 +4,6 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use oxc_ast::Trivias;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::SourceType;
 
@@ -19,8 +18,6 @@ use crate::{
 pub struct TransformCtx<'a> {
     errors: RefCell<Vec<OxcDiagnostic>>,
 
-    pub trivias: Trivias,
-
     /// <https://babeljs.io/docs/options#filename>
     pub filename: String,
 
@@ -41,7 +38,7 @@ pub struct TransformCtx<'a> {
 }
 
 impl<'a> TransformCtx<'a> {
-    pub fn new(source_path: &Path, trivias: Trivias, options: &TransformOptions) -> Self {
+    pub fn new(source_path: &Path, options: &TransformOptions) -> Self {
         let filename = source_path
             .file_stem() // omit file extension
             .map_or_else(|| String::from("unknown"), |name| name.to_string_lossy().to_string());
@@ -56,7 +53,6 @@ impl<'a> TransformCtx<'a> {
             source_path,
             source_type: SourceType::default(),
             source_text: "",
-            trivias,
             module_imports: ModuleImportsStore::new(),
             var_declarations: VarDeclarationsStore::new(),
             top_level_statements: TopLevelStatementsStore::new(),
diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs
index ea92aa0d89628..5e94ac6226a42 100644
--- a/crates/oxc_transformer/src/lib.rs
+++ b/crates/oxc_transformer/src/lib.rs
@@ -38,7 +38,7 @@ use es2019::ES2019;
 use es2020::ES2020;
 use es2021::ES2021;
 use oxc_allocator::{Allocator, Vec};
-use oxc_ast::{ast::*, Trivias};
+use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_semantic::{ScopeTree, SymbolTable};
 use oxc_span::SPAN;
@@ -69,13 +69,8 @@ pub struct Transformer<'a> {
 }
 
 impl<'a> Transformer<'a> {
-    pub fn new(
-        allocator: &'a Allocator,
-        source_path: &Path,
-        trivias: Trivias,
-        options: TransformOptions,
-    ) -> Self {
-        let ctx = TransformCtx::new(source_path, trivias, &options);
+    pub fn new(allocator: &'a Allocator, source_path: &Path, options: TransformOptions) -> Self {
+        let ctx = TransformCtx::new(source_path, &options);
         Self { ctx, options, allocator }
     }
 
@@ -90,7 +85,7 @@ impl<'a> Transformer<'a> {
 
         self.ctx.source_type = program.source_type;
         self.ctx.source_text = program.source_text;
-        react::update_options_with_comments(&mut self.options, &self.ctx);
+        react::update_options_with_comments(&program.comments, &mut self.options, &self.ctx);
 
         let mut transformer = TransformerImpl {
             x0_typescript: TypeScript::new(&self.options.typescript, &self.ctx),
diff --git a/crates/oxc_transformer/src/react/comments.rs b/crates/oxc_transformer/src/react/comments.rs
index 0470ba2cc97fd..6212c73394782 100644
--- a/crates/oxc_transformer/src/react/comments.rs
+++ b/crates/oxc_transformer/src/react/comments.rs
@@ -16,8 +16,12 @@ use crate::{JsxRuntime, TransformCtx, TransformOptions};
 /// otherwise `JSDoc` could be used instead.
 ///
 /// This behavior is aligned with Babel.
-pub(crate) fn update_options_with_comments(options: &mut TransformOptions, ctx: &TransformCtx) {
-    for comment in ctx.trivias.comments() {
+pub(crate) fn update_options_with_comments(
+    comments: &[Comment],
+    options: &mut TransformOptions,
+    ctx: &TransformCtx,
+) {
+    for comment in comments {
         update_options_with_comment(options, comment, ctx.source_text);
     }
 }
diff --git a/crates/oxc_wasm/src/lib.rs b/crates/oxc_wasm/src/lib.rs
index 65ebccc4c63f7..4f533bb99b32d 100644
--- a/crates/oxc_wasm/src/lib.rs
+++ b/crates/oxc_wasm/src/lib.rs
@@ -11,7 +11,7 @@ use std::{
 
 use oxc::{
     allocator::Allocator,
-    ast::{ast::Program, CommentKind, Trivias, Visit},
+    ast::{ast::Program, Comment as OxcComment, CommentKind, Visit},
     codegen::{CodeGenerator, CodegenOptions},
     diagnostics::Error,
     minifier::{CompressOptions, Minifier, MinifierOptions},
@@ -188,12 +188,12 @@ impl Oxc {
                 .preserve_parens
                 .unwrap_or(default_parser_options.preserve_parens),
         };
-        let ParserReturn { mut program, errors, trivias, .. } =
+        let ParserReturn { mut program, errors, .. } =
             Parser::new(&allocator, source_text, source_type)
                 .with_options(oxc_parser_options)
                 .parse();
 
-        self.comments = Self::map_comments(source_text, &trivias);
+        self.comments = Self::map_comments(source_text, &program.comments);
         self.ir = format!("{:#?}", program.body);
         self.ast = program.serialize(&self.serializer)?;
 
@@ -203,7 +203,6 @@ impl Oxc {
             semantic_builder = semantic_builder.with_excess_capacity(2.0);
         }
         let semantic_ret = semantic_builder
-            .with_trivias(trivias.clone())
             .with_check_syntax_error(true)
             .with_cfg(true)
             .build_module_record(&path, &program)
@@ -221,7 +220,7 @@ impl Oxc {
             );
         }
 
-        self.run_linter(&run_options, &path, &trivias, &program);
+        self.run_linter(&run_options, &path, &program);
 
         self.run_prettier(&run_options, source_text, source_type);
 
@@ -241,7 +240,7 @@ impl Oxc {
                 targets: Targets::from_query("chrome 51"),
                 ..EnvOptions::default()
             }) {
-                let result = Transformer::new(&allocator, &path, trivias.clone(), options)
+                let result = Transformer::new(&allocator, &path, options)
                     .build_with_symbols_and_scopes(symbols, scopes, &mut program);
                 if !result.errors.is_empty() {
                     self.save_diagnostics(
@@ -289,18 +288,11 @@ impl Oxc {
         Ok(())
     }
 
-    fn run_linter(
-        &mut self,
-        run_options: &OxcRunOptions,
-        path: &Path,
-        trivias: &Trivias,
-        program: &Program,
-    ) {
+    fn run_linter(&mut self, run_options: &OxcRunOptions, path: &Path, program: &Program) {
         // Only lint if there are no syntax errors
         if run_options.lint.unwrap_or_default() && self.diagnostics.borrow().is_empty() {
             let semantic_ret = SemanticBuilder::new()
                 .with_cfg(true)
-                .with_trivias(trivias.clone())
                 .build_module_record(path, program)
                 .build(program);
             let semantic = Rc::new(semantic_ret.semantic);
@@ -324,12 +316,7 @@ impl Oxc {
                 .with_options(ParseOptions { preserve_parens: false, ..ParseOptions::default() })
                 .parse();
 
-            let mut prettier = Prettier::new(
-                &allocator,
-                source_text,
-                ret.trivias.clone(),
-                PrettierOptions::default(),
-            );
+            let mut prettier = Prettier::new(&allocator, source_text, PrettierOptions::default());
 
             if run_options.prettier_format.unwrap_or_default() {
                 self.prettier_formatted_text = prettier.build(&ret.program);
@@ -339,13 +326,8 @@ impl Oxc {
                 let prettier_doc = prettier.doc(&ret.program).to_string();
                 self.prettier_ir_text = {
                     let ret = Parser::new(&allocator, &prettier_doc, SourceType::default()).parse();
-                    Prettier::new(
-                        &allocator,
-                        &prettier_doc,
-                        ret.trivias,
-                        PrettierOptions::default(),
-                    )
-                    .build(&ret.program)
+                    Prettier::new(&allocator, &prettier_doc, PrettierOptions::default())
+                        .build(&ret.program)
                 };
             }
         }
@@ -415,9 +397,9 @@ impl Oxc {
         self.diagnostics.borrow_mut().extend(diagnostics);
     }
 
-    fn map_comments(source_text: &str, trivias: &Trivias) -> Vec<Comment> {
-        trivias
-            .comments()
+    fn map_comments(source_text: &str, comments: &[OxcComment]) -> Vec<Comment> {
+        comments
+            .iter()
             .map(|comment| Comment {
                 r#type: match comment.kind {
                     CommentKind::Line => CommentType::Line,
diff --git a/napi/parser/src/lib.rs b/napi/parser/src/lib.rs
index 6744e534c4d8d..3f9efe1209460 100644
--- a/napi/parser/src/lib.rs
+++ b/napi/parser/src/lib.rs
@@ -73,8 +73,9 @@ fn parse_with_return<'a>(source_text: &'a str, options: &ParserOptions) -> Parse
     };
 
     let comments = ret
-        .trivias
-        .comments()
+        .program
+        .comments
+        .iter()
         .map(|comment| Comment {
             r#type: match comment.kind {
                 CommentKind::Line => "Line",
diff --git a/napi/transform/src/isolated_declaration.rs b/napi/transform/src/isolated_declaration.rs
index bda6c65a9744e..72867b8200858 100644
--- a/napi/transform/src/isolated_declaration.rs
+++ b/napi/transform/src/isolated_declaration.rs
@@ -33,19 +33,14 @@ pub fn isolated_declaration(
 
     let transformed_ret = IsolatedDeclarations::new(
         &allocator,
-        &source_text,
-        &ret.trivias,
         oxc::isolated_declarations::IsolatedDeclarationsOptions {
             strip_internal: options.strip_internal.unwrap_or(false),
         },
     )
     .build(&ret.program);
 
-    let mut codegen = CodeGenerator::new().enable_comment(
-        &source_text,
-        ret.trivias.clone(),
-        CommentOptions { preserve_annotate_comments: false },
-    );
+    let mut codegen = CodeGenerator::new()
+        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: false });
     if options.sourcemap == Some(true) {
         codegen = codegen.enable_source_map(&filename, &source_text);
     }
diff --git a/tasks/benchmark/benches/isolated_declarations.rs b/tasks/benchmark/benches/isolated_declarations.rs
index 3c44c84b563fd..91d02286fc43c 100644
--- a/tasks/benchmark/benches/isolated_declarations.rs
+++ b/tasks/benchmark/benches/isolated_declarations.rs
@@ -18,12 +18,10 @@ fn bench_isolated_declarations(criterion: &mut Criterion) {
     group.bench_with_input(id, &file.source_text, |b, source_text| {
         b.iter_with_large_drop(|| {
             let allocator = Allocator::default();
-            let ParserReturn { program, trivias, .. } =
+            let ParserReturn { program, .. } =
                 Parser::new(&allocator, source_text, source_type).parse();
             IsolatedDeclarations::new(
                 &allocator,
-                source_text,
-                &trivias,
                 IsolatedDeclarationsOptions { strip_internal: true },
             )
             .build(&program);
diff --git a/tasks/benchmark/benches/linter.rs b/tasks/benchmark/benches/linter.rs
index d3f25a9b97e6c..7fa52aee27bd3 100644
--- a/tasks/benchmark/benches/linter.rs
+++ b/tasks/benchmark/benches/linter.rs
@@ -29,7 +29,6 @@ fn bench_linter(criterion: &mut Criterion) {
                 let ret = Parser::new(&allocator, source_text, source_type).parse();
                 let program = allocator.alloc(ret.program);
                 let semantic_ret = SemanticBuilder::new()
-                    .with_trivias(ret.trivias)
                     .with_build_jsdoc(true)
                     .with_cfg(true)
                     .build_module_record(Path::new(""), program)
diff --git a/tasks/benchmark/benches/prettier.rs b/tasks/benchmark/benches/prettier.rs
index ef0a295f929dd..73037a8c09485 100644
--- a/tasks/benchmark/benches/prettier.rs
+++ b/tasks/benchmark/benches/prettier.rs
@@ -17,13 +17,8 @@ fn bench_prettier(criterion: &mut Criterion) {
                     let allocator1 = Allocator::default();
                     let allocator2 = Allocator::default();
                     let ret = Parser::new(&allocator1, source_text, source_type).parse();
-                    let _ = Prettier::new(
-                        &allocator2,
-                        source_text,
-                        ret.trivias,
-                        PrettierOptions::default(),
-                    )
-                    .build(&ret.program);
+                    let _ = Prettier::new(&allocator2, source_text, PrettierOptions::default())
+                        .build(&ret.program);
                 });
             },
         );
diff --git a/tasks/benchmark/benches/semantic.rs b/tasks/benchmark/benches/semantic.rs
index bc8823e1d8556..7ee1189ddc611 100644
--- a/tasks/benchmark/benches/semantic.rs
+++ b/tasks/benchmark/benches/semantic.rs
@@ -24,7 +24,6 @@ fn bench_semantic(criterion: &mut Criterion) {
                     // code would have no errors. One of our benchmarks `cal.com.tsx` has a lot of errors,
                     // but that's atypical, so don't want to include it in benchmark time.
                     let ret = SemanticBuilder::new()
-                        .with_trivias(ret.trivias.clone())
                         .with_build_jsdoc(true)
                         .build_module_record(Path::new(""), program)
                         .build(program);
diff --git a/tasks/benchmark/benches/transformer.rs b/tasks/benchmark/benches/transformer.rs
index b83698f667c0c..0116ad32b9954 100644
--- a/tasks/benchmark/benches/transformer.rs
+++ b/tasks/benchmark/benches/transformer.rs
@@ -26,7 +26,7 @@ fn bench_transformer(criterion: &mut Criterion) {
                 allocator.reset();
 
                 // Create fresh AST + semantic data for each iteration
-                let ParserReturn { trivias, program, .. } =
+                let ParserReturn { program, .. } =
                     Parser::new(&allocator, source_text, source_type).parse();
                 let program = allocator.alloc(program);
                 let (symbols, scopes) = SemanticBuilder::new()
@@ -36,28 +36,19 @@ fn bench_transformer(criterion: &mut Criterion) {
                     .semantic
                     .into_symbol_table_and_scope_tree();
 
-                // Clone `trivias` (which is an `Arc`). We keep a 2nd copy, so the value is not dropped
-                // when `Transformer` is dropped inside the measured section.
-                // We clone `trivias` here rather than in `routine` to avoid the cloning being included
-                // in measure.
-                let trivias_copy = trivias.clone();
-
                 // `enable_all` enables all transforms except arrow functions transform
                 let mut options = TransformOptions::enable_all();
                 options.es2015.arrow_function = Some(ArrowFunctionsOptions { spec: true });
 
                 runner.run(|| {
-                    let ret =
-                        Transformer::new(&allocator, Path::new(&file.file_name), trivias, options)
-                            .build_with_symbols_and_scopes(symbols, scopes, program);
+                    let ret = Transformer::new(&allocator, Path::new(&file.file_name), options)
+                        .build_with_symbols_and_scopes(symbols, scopes, program);
 
                     // Return the `TransformerReturn`, so it's dropped outside of the measured section.
                     // `TransformerReturn` contains `ScopeTree` and `SymbolTable` which are costly to drop.
                     // That's not central to transformer, so we don't want it included in this measure.
                     ret
                 });
-
-                drop(trivias_copy);
             });
         });
     }
diff --git a/tasks/coverage/src/driver.rs b/tasks/coverage/src/driver.rs
index aac49759cc9a2..58819f50b1758 100644
--- a/tasks/coverage/src/driver.rs
+++ b/tasks/coverage/src/driver.rs
@@ -4,7 +4,7 @@ use rustc_hash::FxHashSet;
 
 use oxc::{
     allocator::Allocator,
-    ast::{ast::Program, Trivias},
+    ast::{ast::Program, Comment},
     codegen::{CodegenOptions, CodegenReturn},
     diagnostics::OxcDiagnostic,
     minifier::CompressOptions,
@@ -67,9 +67,9 @@ impl CompilerInterface for Driver {
     }
 
     fn after_parse(&mut self, parser_return: &mut ParserReturn) -> ControlFlow<()> {
-        let ParserReturn { program, trivias, panicked, errors } = parser_return;
+        let ParserReturn { program, panicked, errors, .. } = parser_return;
         self.panicked = *panicked;
-        if self.check_comments(trivias) {
+        if self.check_comments(&program.comments) {
             return ControlFlow::Break(());
         }
         if (errors.is_empty() || !*panicked) && program.source_type.is_unambiguous() {
@@ -145,9 +145,9 @@ impl Driver {
         self.compile(source_text, source_type, &path);
     }
 
-    fn check_comments(&mut self, trivias: &Trivias) -> bool {
+    fn check_comments(&mut self, comments: &[Comment]) -> bool {
         let mut uniq: FxHashSet<Span> = FxHashSet::default();
-        for comment in trivias.comments() {
+        for comment in comments {
             if !uniq.insert(comment.span) {
                 self.errors
                     .push(OxcDiagnostic::error("Duplicate Comment").with_label(comment.span));
diff --git a/tasks/coverage/src/tools/prettier.rs b/tasks/coverage/src/tools/prettier.rs
index 605c800626e3f..9cfadbf1123b3 100644
--- a/tasks/coverage/src/tools/prettier.rs
+++ b/tasks/coverage/src/tools/prettier.rs
@@ -21,14 +21,14 @@ fn get_result(source_text: &str, source_type: SourceType) -> TestResult {
 
     let allocator = Allocator::default();
     let parse_options = ParseOptions { preserve_parens: false, ..ParseOptions::default() };
-    let ParserReturn { program, trivias, .. } =
+    let ParserReturn { program, .. } =
         Parser::new(&allocator, source_text, source_type).with_options(parse_options).parse();
-    let source_text1 = Prettier::new(&allocator, source_text, trivias, options).build(&program);
+    let source_text1 = Prettier::new(&allocator, source_text, options).build(&program);
 
     let allocator = Allocator::default();
-    let ParserReturn { program, trivias, .. } =
+    let ParserReturn { program, .. } =
         Parser::new(&allocator, &source_text1, source_type).with_options(parse_options).parse();
-    let source_text2 = Prettier::new(&allocator, &source_text1, trivias, options).build(&program);
+    let source_text2 = Prettier::new(&allocator, &source_text1, options).build(&program);
 
     if source_text1 == source_text2 {
         TestResult::Passed
diff --git a/tasks/coverage/src/typescript/transpile_runner.rs b/tasks/coverage/src/typescript/transpile_runner.rs
index c04325b015cc0..1f292cb589786 100644
--- a/tasks/coverage/src/typescript/transpile_runner.rs
+++ b/tasks/coverage/src/typescript/transpile_runner.rs
@@ -178,13 +178,9 @@ fn transpile(path: &Path, source_text: &str) -> (String, Vec<OxcDiagnostic>) {
     let allocator = Allocator::default();
     let source_type = SourceType::from_path(path).unwrap();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let ret = IsolatedDeclarations::new(
-        &allocator,
-        source_text,
-        &ret.trivias,
-        IsolatedDeclarationsOptions { strip_internal: true },
-    )
-    .build(&ret.program);
+    let ret =
+        IsolatedDeclarations::new(&allocator, IsolatedDeclarationsOptions { strip_internal: true })
+            .build(&ret.program);
     let printed = CodeGenerator::new().build(&ret.program).code;
     (printed, ret.errors)
 }
diff --git a/tasks/prettier_conformance/src/lib.rs b/tasks/prettier_conformance/src/lib.rs
index c04dce386e3e3..31d4153c05057 100644
--- a/tasks/prettier_conformance/src/lib.rs
+++ b/tasks/prettier_conformance/src/lib.rs
@@ -389,7 +389,7 @@ impl TestRunner {
         let ret = Parser::new(&allocator, source_text, source_type)
             .with_options(ParseOptions { preserve_parens: false, ..ParseOptions::default() })
             .parse();
-        Prettier::new(&allocator, source_text, ret.trivias, prettier_options).build(&ret.program)
+        Prettier::new(&allocator, source_text, prettier_options).build(&ret.program)
     }
 }
 
diff --git a/tasks/transform_conformance/src/driver.rs b/tasks/transform_conformance/src/driver.rs
index 56778147f253d..107328276d8f2 100644
--- a/tasks/transform_conformance/src/driver.rs
+++ b/tasks/transform_conformance/src/driver.rs
@@ -1,7 +1,7 @@
 use std::{mem, ops::ControlFlow, path::Path};
 
 use oxc::{
-    ast::{ast::Program, Trivias},
+    ast::ast::Program,
     codegen::{CodeGenerator, CodegenOptions, CodegenReturn},
     diagnostics::OxcDiagnostic,
     mangler::Mangler,
@@ -61,7 +61,6 @@ impl CompilerInterface for Driver {
         &self,
         program: &Program<'_>,
         _source_path: &Path,
-        _trivias: &Trivias,
         mangler: Option<Mangler>,
         options: CodegenOptions,
     ) -> CodegenReturn {

From cb8f4210c303fba3328045f5b37a77253823da21 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 06:27:33 +0000
Subject: [PATCH 16/24] refactor(prettier)!: remove `source_text` argument from
 constructor (#6448)

---
 crates/oxc_prettier/examples/prettier.rs | 1 -
 crates/oxc_prettier/src/lib.rs           | 7 ++++---
 crates/oxc_wasm/src/lib.rs               | 5 ++---
 tasks/benchmark/benches/prettier.rs      | 4 ++--
 tasks/coverage/src/tools/prettier.rs     | 4 ++--
 tasks/prettier_conformance/src/lib.rs    | 2 +-
 6 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/crates/oxc_prettier/examples/prettier.rs b/crates/oxc_prettier/examples/prettier.rs
index 038819de2d6c3..45ff38236c56b 100644
--- a/crates/oxc_prettier/examples/prettier.rs
+++ b/crates/oxc_prettier/examples/prettier.rs
@@ -27,7 +27,6 @@ fn main() -> std::io::Result<()> {
         .parse();
     let output = Prettier::new(
         &allocator,
-        &source_text,
         PrettierOptions { semi, trailing_comma: TrailingComma::All, ..PrettierOptions::default() },
     )
     .build(&ret.program);
diff --git a/crates/oxc_prettier/src/lib.rs b/crates/oxc_prettier/src/lib.rs
index 5475ecee1b36f..74d093c221c2e 100644
--- a/crates/oxc_prettier/src/lib.rs
+++ b/crates/oxc_prettier/src/lib.rs
@@ -71,10 +71,10 @@ impl<'a> DocBuilder<'a> for Prettier<'a> {
 
 impl<'a> Prettier<'a> {
     #[allow(clippy::needless_pass_by_value)]
-    pub fn new(allocator: &'a Allocator, source_text: &'a str, options: PrettierOptions) -> Self {
+    pub fn new(allocator: &'a Allocator, options: PrettierOptions) -> Self {
         Self {
             allocator,
-            source_text,
+            source_text: "",
             options,
             stack: vec![],
             group_id_builder: GroupIdBuilder::default(),
@@ -83,8 +83,9 @@ impl<'a> Prettier<'a> {
     }
 
     pub fn build(&mut self, program: &Program<'a>) -> String {
+        self.source_text = program.source_text;
         let doc = program.format(self);
-        Printer::new(doc, self.source_text, self.options, self.allocator).build()
+        Printer::new(doc, program.source_text, self.options, self.allocator).build()
     }
 
     pub fn doc(mut self, program: &Program<'a>) -> Doc<'a> {
diff --git a/crates/oxc_wasm/src/lib.rs b/crates/oxc_wasm/src/lib.rs
index 4f533bb99b32d..abea67d29ccfb 100644
--- a/crates/oxc_wasm/src/lib.rs
+++ b/crates/oxc_wasm/src/lib.rs
@@ -316,7 +316,7 @@ impl Oxc {
                 .with_options(ParseOptions { preserve_parens: false, ..ParseOptions::default() })
                 .parse();
 
-            let mut prettier = Prettier::new(&allocator, source_text, PrettierOptions::default());
+            let mut prettier = Prettier::new(&allocator, PrettierOptions::default());
 
             if run_options.prettier_format.unwrap_or_default() {
                 self.prettier_formatted_text = prettier.build(&ret.program);
@@ -326,8 +326,7 @@ impl Oxc {
                 let prettier_doc = prettier.doc(&ret.program).to_string();
                 self.prettier_ir_text = {
                     let ret = Parser::new(&allocator, &prettier_doc, SourceType::default()).parse();
-                    Prettier::new(&allocator, &prettier_doc, PrettierOptions::default())
-                        .build(&ret.program)
+                    Prettier::new(&allocator, PrettierOptions::default()).build(&ret.program)
                 };
             }
         }
diff --git a/tasks/benchmark/benches/prettier.rs b/tasks/benchmark/benches/prettier.rs
index 73037a8c09485..0c0961b36f1ea 100644
--- a/tasks/benchmark/benches/prettier.rs
+++ b/tasks/benchmark/benches/prettier.rs
@@ -17,8 +17,8 @@ fn bench_prettier(criterion: &mut Criterion) {
                     let allocator1 = Allocator::default();
                     let allocator2 = Allocator::default();
                     let ret = Parser::new(&allocator1, source_text, source_type).parse();
-                    let _ = Prettier::new(&allocator2, source_text, PrettierOptions::default())
-                        .build(&ret.program);
+                    let _ =
+                        Prettier::new(&allocator2, PrettierOptions::default()).build(&ret.program);
                 });
             },
         );
diff --git a/tasks/coverage/src/tools/prettier.rs b/tasks/coverage/src/tools/prettier.rs
index 9cfadbf1123b3..36f7ad2f20404 100644
--- a/tasks/coverage/src/tools/prettier.rs
+++ b/tasks/coverage/src/tools/prettier.rs
@@ -23,12 +23,12 @@ fn get_result(source_text: &str, source_type: SourceType) -> TestResult {
     let parse_options = ParseOptions { preserve_parens: false, ..ParseOptions::default() };
     let ParserReturn { program, .. } =
         Parser::new(&allocator, source_text, source_type).with_options(parse_options).parse();
-    let source_text1 = Prettier::new(&allocator, source_text, options).build(&program);
+    let source_text1 = Prettier::new(&allocator, options).build(&program);
 
     let allocator = Allocator::default();
     let ParserReturn { program, .. } =
         Parser::new(&allocator, &source_text1, source_type).with_options(parse_options).parse();
-    let source_text2 = Prettier::new(&allocator, &source_text1, options).build(&program);
+    let source_text2 = Prettier::new(&allocator, options).build(&program);
 
     if source_text1 == source_text2 {
         TestResult::Passed
diff --git a/tasks/prettier_conformance/src/lib.rs b/tasks/prettier_conformance/src/lib.rs
index 31d4153c05057..d7f37b06a3c40 100644
--- a/tasks/prettier_conformance/src/lib.rs
+++ b/tasks/prettier_conformance/src/lib.rs
@@ -389,7 +389,7 @@ impl TestRunner {
         let ret = Parser::new(&allocator, source_text, source_type)
             .with_options(ParseOptions { preserve_parens: false, ..ParseOptions::default() })
             .parse();
-        Prettier::new(&allocator, source_text, prettier_options).build(&ret.program)
+        Prettier::new(&allocator, prettier_options).build(&ret.program)
     }
 }
 

From 85d93ed713203de4722426e47489c97f299fcb33 Mon Sep 17 00:00:00 2001
From: overlookmotel <557937+overlookmotel@users.noreply.github.com>
Date: Fri, 11 Oct 2024 07:09:56 +0000
Subject: [PATCH 17/24] fix(transformer): arrow function transform: correctly
 resolve `this` in class accessor properties (#6386)

Correctly resolve scope of `this` in class accessor properties.

The omission of this case became clear from examining Babel's `environmentVisitor`:

https://github.com/babel/babel/blob/f343c499b07341ddb1a8e90add60e5ef45011664/packages/babel-traverse/src/visitors.ts#L398-L436
---
 crates/oxc_transformer/src/es2015/arrow_functions.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/crates/oxc_transformer/src/es2015/arrow_functions.rs b/crates/oxc_transformer/src/es2015/arrow_functions.rs
index d0370e508ccb9..d931b9095dce3 100644
--- a/crates/oxc_transformer/src/es2015/arrow_functions.rs
+++ b/crates/oxc_transformer/src/es2015/arrow_functions.rs
@@ -15,6 +15,9 @@
 //!   Babel gets this wrong: <https://babeljs.io/repl#?code_lz=GYVwdgxgLglg9mABMOcAUAPRBeRaCUOAfIlABYwDOhA3gL5A&presets=&externalPlugins=%40babel%2Fplugin-transform-arrow-functions%407.24.7>
 //! * Error on arrow functions in class properties.
 //!   <https://babeljs.io/repl#?code_lz=MYGwhgzhAEDC0G8BQ1oDMD2HoF5oAoBKXAPmgBcALASwgG4kBfJIA&presets=&externalPlugins=%40babel%2Fplugin-transform-arrow-functions%407.24.7>
+//!   or we can support it:
+//!     `class C { x = () => this; }`
+//!     -> `class C { x = (function(_this) { return () => _this; })(this); }`
 //! * Error on `super` in arrow functions.
 //!   <https://babeljs.io/repl#?code_lz=MYGwhgzhAEBiD29oG8C-AoUkYCEwCdoBTADwBciA7AExgSWXWmgFsiyALeagCgEoUTZtHzsArvkrR-0ALwA-aBDEAHIvgB0AM0QBuIRgxA&presets=&externalPlugins=%40babel%2Fplugin-transform-arrow-functions%407.24.7>
 //!
@@ -296,6 +299,7 @@ impl<'a> ArrowFunctions<'a> {
         // * `extends` clause
         // * Computed method key
         // * Computed property key
+        // * Computed accessor property key (but `this` in this position is not legal TS)
         //
         // ```js
         // // All these `this` refer to global `this`
@@ -304,6 +308,8 @@ impl<'a> ArrowFunctions<'a> {
         //     static [this] = 123;
         //     [this]() {}
         //     static [this]() {}
+        //     accessor [this] = 123;
+        //     static accessor [this] = 123;
         // }
         // ```
         //
@@ -323,6 +329,8 @@ impl<'a> ArrowFunctions<'a> {
         //     static e() { this }
         //     #f() { this }
         //     g(x = this) {}
+        //     accessor h = this;
+        //     static accessor i = this;
         //     static { this }
         // }
         // ```
@@ -337,8 +345,11 @@ impl<'a> ArrowFunctions<'a> {
                 | Ancestor::FunctionBody(_)
                 // Class property body
                 | Ancestor::PropertyDefinitionValue(_)
+                // Class accessor property body
+                | Ancestor::AccessorPropertyValue(_)
                 // Class static block
                 | Ancestor::StaticBlockBody(_) => return None,
+                // Arrow function
                 Ancestor::ArrowFunctionExpressionParams(func) => {
                     return Some(func.scope_id().get().unwrap())
                 }

From 06ea1216af4f64cec39bd21f746b452a28f8e6da Mon Sep 17 00:00:00 2001
From: 7086cmd <54303040+7086cmd@users.noreply.github.com>
Date: Fri, 11 Oct 2024 08:33:23 +0000
Subject: [PATCH 18/24] feat(minifier): fold for statement (#6450)

---
 .../ast_passes/peephole_remove_dead_code.rs   | 61 +++++++++++++++++++
 tasks/minsize/minsize.snap                    |  2 +-
 2 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
index 05c1a364743f2..9852ed60348ba 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
@@ -30,6 +30,7 @@ impl<'a> Traverse<'a> for PeepholeRemoveDeadCode {
     fn enter_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
         if let Some(new_stmt) = match stmt {
             Statement::IfStatement(if_stmt) => self.try_fold_if(if_stmt, ctx),
+            Statement::ForStatement(for_stmt) => self.try_fold_for(for_stmt, ctx),
             _ => None,
         } {
             *stmt = new_stmt;
@@ -162,6 +163,35 @@ impl<'a> PeepholeRemoveDeadCode {
         }
     }
 
+    fn try_fold_for(
+        &mut self,
+        for_stmt: &mut ForStatement<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) -> Option<Statement<'a>> {
+        let test_boolean =
+            for_stmt.test.as_ref().map_or(Tri::Unknown, |test| ctx.get_boolean_value(test));
+        match test_boolean {
+            Tri::False => {
+                // Remove the entire `for` statement.
+                // Check vars in statement
+                let mut keep_var = KeepVar::new(ctx.ast);
+                keep_var.visit_statement(&for_stmt.body);
+                Some(
+                    keep_var
+                        .get_variable_declaration_statement()
+                        .unwrap_or_else(|| ctx.ast.statement_empty(SPAN)),
+                )
+            }
+            Tri::True => {
+                // Remove the test expression.
+                for_stmt.test = None;
+                self.changed = true;
+                None
+            }
+            Tri::Unknown => None,
+        }
+    }
+
     /// Try folding conditional expression (?:) if the condition results of the condition is known.
     fn try_fold_conditional_expression(
         expr: &mut ConditionalExpression<'a>,
@@ -229,4 +259,35 @@ mod test {
         fold_same("b: { var x = 1; } x = 2;");
         fold_same("a: b: { var x = 1; } x = 2;");
     }
+
+    #[test]
+    fn test_fold_useless_for() {
+        fold("for(;false;) { foo() }", "");
+        fold("for(;void 0;) { foo() }", "");
+        fold("for(;undefined;) { foo() }", "");
+        fold("for(;true;) foo() ", "for(;;) foo() ");
+        fold_same("for(;;) foo()");
+        fold("for(;false;) { var a = 0; }", "var a");
+        fold("for(;false;) { const a = 0; }", "");
+        fold("for(;false;) { let a = 0; }", "");
+
+        // Make sure it plays nice with minimizing
+        fold("for(;false;) { foo(); continue }", "");
+
+        // fold("l1:for(;false;) {  }", "");
+
+        // TODO handle single block statement
+        fold_same("for(;a;) { foo(); }");
+    }
+
+    #[test]
+    fn test_minimize_loop_with_constant_condition_vanilla_for() {
+        fold("for(;true;) foo()", "for(;;) foo()");
+        fold("for(;0;) foo()", "");
+        fold("for(;0.0;) foo()", "");
+        fold("for(;NaN;) foo()", "");
+        fold("for(;null;) foo()", "");
+        fold("for(;undefined;) foo()", "");
+        fold("for(;'';) foo()", "");
+    }
 }
diff --git a/tasks/minsize/minsize.snap b/tasks/minsize/minsize.snap
index ed47e975fb5fc..1229296e2990f 100644
--- a/tasks/minsize/minsize.snap
+++ b/tasks/minsize/minsize.snap
@@ -22,5 +22,5 @@ Original   | Minified   | esbuild    | Gzip       | esbuild
 
 6.69 MB    | 2.44 MB    | 2.31 MB    | 498.88 kB  | 488.28 kB  | antd.js   
 
-10.95 MB   | 3.59 MB    | 3.49 MB    | 913.92 kB  | 915.50 kB  | typescript.js
+10.95 MB   | 3.59 MB    | 3.49 MB    | 913.91 kB  | 915.50 kB  | typescript.js
 

From 073b02af147954a0c773c9a471de522192679546 Mon Sep 17 00:00:00 2001
From: overlookmotel <557937+overlookmotel@users.noreply.github.com>
Date: Fri, 11 Oct 2024 09:57:28 +0000
Subject: [PATCH 19/24] refactor(ast): type params field before params in TS
 function declaration types (#6391)

Our convention is that AST type fields are ordered in order they appear in source. Move `type_parameters` fields in TS function declaration types to before `this_param` and formal parameters.
---
 crates/oxc_ast/src/ast/ts.rs                  |  26 +-
 .../oxc_ast/src/generated/assert_layouts.rs   |  72 +--
 crates/oxc_ast/src/generated/ast_builder.rs   | 264 +++++-----
 .../oxc_ast/src/generated/derive_clone_in.rs  |  10 +-
 .../src/generated/derive_content_eq.rs        |  16 +-
 .../src/generated/derive_content_hash.rs      |  10 +-
 crates/oxc_ast/src/generated/visit.rs         |  28 +-
 crates/oxc_ast/src/generated/visit_mut.rs     |  28 +-
 crates/oxc_isolated_declarations/src/types.rs |  12 +-
 crates/oxc_parser/src/ts/types.rs             |  14 +-
 .../function/constructor-generics2.snap       |   4 +-
 .../function/function-generics2.snap          |   4 +-
 .../signatures/call-generics.snap             |   4 +-
 .../signatures/construct-generics.snap        |   4 +-
 .../signatures/method-generics.snap           |   4 +-
 crates/oxc_traverse/src/generated/ancestor.rs | 462 +++++++++---------
 crates/oxc_traverse/src/generated/walk.rs     |  86 ++--
 tasks/coverage/snapshots/semantic_babel.snap  |   4 +-
 .../snapshots/semantic_typescript.snap        |  98 ++--
 .../snapshots/babel.snap.md                   |   2 +-
 20 files changed, 576 insertions(+), 576 deletions(-)

diff --git a/crates/oxc_ast/src/ast/ts.rs b/crates/oxc_ast/src/ast/ts.rs
index 9601204ca0fc0..1555888052394 100644
--- a/crates/oxc_ast/src/ast/ts.rs
+++ b/crates/oxc_ast/src/ast/ts.rs
@@ -1147,10 +1147,10 @@ pub struct TSIndexSignature<'a> {
 pub struct TSCallSignatureDeclaration<'a> {
     #[serde(flatten)]
     pub span: Span,
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub this_param: Option<TSThisParameter<'a>>,
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
 }
 
 #[ast]
@@ -1188,10 +1188,10 @@ pub struct TSMethodSignature<'a> {
     pub computed: bool,
     pub optional: bool,
     pub kind: TSMethodSignatureKind,
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub this_param: Option<Box<'a, TSThisParameter<'a>>>,
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     #[serde(skip)]
     #[clone_in(default)]
     pub scope_id: Cell<Option<ScopeId>>,
@@ -1207,9 +1207,9 @@ pub struct TSMethodSignature<'a> {
 pub struct TSConstructSignatureDeclaration<'a> {
     #[serde(flatten)]
     pub span: Span,
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     #[serde(skip)]
     #[clone_in(default)]
     pub scope_id: Cell<Option<ScopeId>>,
@@ -1562,10 +1562,17 @@ pub enum TSImportAttributeName<'a> {
 pub struct TSFunctionType<'a> {
     #[serde(flatten)]
     pub span: Span,
+    /// Generic type parameters
+    ///
+    /// ```ts
+    /// type T = <U>(x: U) => U;
+    /// //        ^
+    /// ```
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     /// `this` parameter
     ///
     /// ```ts
-    /// type T = (this: string, a: number) => void
+    /// type T = (this: string, a: number) => void;
     /// //        ^^^^^^^^^^^^
     /// ```
     pub this_param: Option<Box<'a, TSThisParameter<'a>>>,
@@ -1573,17 +1580,10 @@ pub struct TSFunctionType<'a> {
     pub params: Box<'a, FormalParameters<'a>>,
     /// Return type of the function.
     /// ```ts
-    /// type T = () => void
+    /// type T = () => void;
     /// //             ^^^^
     /// ```
     pub return_type: Box<'a, TSTypeAnnotation<'a>>,
-    /// Generic type parameters
-    ///
-    /// ```ts
-    /// type T = <T>(x: T) => T
-    /// //        ^
-    /// ```
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
 }
 
 #[ast(visit)]
@@ -1595,9 +1595,9 @@ pub struct TSConstructorType<'a> {
     #[serde(flatten)]
     pub span: Span,
     pub r#abstract: bool,
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Box<'a, TSTypeAnnotation<'a>>,
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
 }
 
 /// TypeScript Mapped Type
diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs
index 956e4b8e48802..df250fa8229ab 100644
--- a/crates/oxc_ast/src/generated/assert_layouts.rs
+++ b/crates/oxc_ast/src/generated/assert_layouts.rs
@@ -1042,10 +1042,10 @@ const _: () = {
     assert!(size_of::<TSCallSignatureDeclaration>() == 64usize);
     assert!(align_of::<TSCallSignatureDeclaration>() == 8usize);
     assert!(offset_of!(TSCallSignatureDeclaration, span) == 0usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, this_param) == 8usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, params) == 40usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 48usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 56usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 8usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, this_param) == 16usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, params) == 48usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 56usize);
 
     assert!(size_of::<TSMethodSignatureKind>() == 1usize);
     assert!(align_of::<TSMethodSignatureKind>() == 1usize);
@@ -1057,18 +1057,18 @@ const _: () = {
     assert!(offset_of!(TSMethodSignature, computed) == 24usize);
     assert!(offset_of!(TSMethodSignature, optional) == 25usize);
     assert!(offset_of!(TSMethodSignature, kind) == 26usize);
-    assert!(offset_of!(TSMethodSignature, this_param) == 32usize);
-    assert!(offset_of!(TSMethodSignature, params) == 40usize);
-    assert!(offset_of!(TSMethodSignature, return_type) == 48usize);
-    assert!(offset_of!(TSMethodSignature, type_parameters) == 56usize);
+    assert!(offset_of!(TSMethodSignature, type_parameters) == 32usize);
+    assert!(offset_of!(TSMethodSignature, this_param) == 40usize);
+    assert!(offset_of!(TSMethodSignature, params) == 48usize);
+    assert!(offset_of!(TSMethodSignature, return_type) == 56usize);
     assert!(offset_of!(TSMethodSignature, scope_id) == 64usize);
 
     assert!(size_of::<TSConstructSignatureDeclaration>() == 40usize);
     assert!(align_of::<TSConstructSignatureDeclaration>() == 8usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, span) == 0usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, params) == 8usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 16usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 24usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 8usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, params) == 16usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 24usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 32usize);
 
     assert!(size_of::<TSIndexSignatureName>() == 32usize);
@@ -1163,18 +1163,18 @@ const _: () = {
     assert!(size_of::<TSFunctionType>() == 40usize);
     assert!(align_of::<TSFunctionType>() == 8usize);
     assert!(offset_of!(TSFunctionType, span) == 0usize);
-    assert!(offset_of!(TSFunctionType, this_param) == 8usize);
-    assert!(offset_of!(TSFunctionType, params) == 16usize);
-    assert!(offset_of!(TSFunctionType, return_type) == 24usize);
-    assert!(offset_of!(TSFunctionType, type_parameters) == 32usize);
+    assert!(offset_of!(TSFunctionType, type_parameters) == 8usize);
+    assert!(offset_of!(TSFunctionType, this_param) == 16usize);
+    assert!(offset_of!(TSFunctionType, params) == 24usize);
+    assert!(offset_of!(TSFunctionType, return_type) == 32usize);
 
     assert!(size_of::<TSConstructorType>() == 40usize);
     assert!(align_of::<TSConstructorType>() == 8usize);
     assert!(offset_of!(TSConstructorType, span) == 0usize);
     assert!(offset_of!(TSConstructorType, r#abstract) == 8usize);
-    assert!(offset_of!(TSConstructorType, params) == 16usize);
-    assert!(offset_of!(TSConstructorType, return_type) == 24usize);
-    assert!(offset_of!(TSConstructorType, type_parameters) == 32usize);
+    assert!(offset_of!(TSConstructorType, type_parameters) == 16usize);
+    assert!(offset_of!(TSConstructorType, params) == 24usize);
+    assert!(offset_of!(TSConstructorType, return_type) == 32usize);
 
     assert!(size_of::<TSMappedType>() == 56usize);
     assert!(align_of::<TSMappedType>() == 8usize);
@@ -2601,10 +2601,10 @@ const _: () = {
     assert!(size_of::<TSCallSignatureDeclaration>() == 44usize);
     assert!(align_of::<TSCallSignatureDeclaration>() == 4usize);
     assert!(offset_of!(TSCallSignatureDeclaration, span) == 0usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, this_param) == 8usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, params) == 32usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 36usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 40usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 8usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, this_param) == 12usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, params) == 36usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 40usize);
 
     assert!(size_of::<TSMethodSignatureKind>() == 1usize);
     assert!(align_of::<TSMethodSignatureKind>() == 1usize);
@@ -2616,18 +2616,18 @@ const _: () = {
     assert!(offset_of!(TSMethodSignature, computed) == 16usize);
     assert!(offset_of!(TSMethodSignature, optional) == 17usize);
     assert!(offset_of!(TSMethodSignature, kind) == 18usize);
-    assert!(offset_of!(TSMethodSignature, this_param) == 20usize);
-    assert!(offset_of!(TSMethodSignature, params) == 24usize);
-    assert!(offset_of!(TSMethodSignature, return_type) == 28usize);
-    assert!(offset_of!(TSMethodSignature, type_parameters) == 32usize);
+    assert!(offset_of!(TSMethodSignature, type_parameters) == 20usize);
+    assert!(offset_of!(TSMethodSignature, this_param) == 24usize);
+    assert!(offset_of!(TSMethodSignature, params) == 28usize);
+    assert!(offset_of!(TSMethodSignature, return_type) == 32usize);
     assert!(offset_of!(TSMethodSignature, scope_id) == 36usize);
 
     assert!(size_of::<TSConstructSignatureDeclaration>() == 24usize);
     assert!(align_of::<TSConstructSignatureDeclaration>() == 4usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, span) == 0usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, params) == 8usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 12usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 16usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 8usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, params) == 12usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 16usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 20usize);
 
     assert!(size_of::<TSIndexSignatureName>() == 20usize);
@@ -2722,18 +2722,18 @@ const _: () = {
     assert!(size_of::<TSFunctionType>() == 24usize);
     assert!(align_of::<TSFunctionType>() == 4usize);
     assert!(offset_of!(TSFunctionType, span) == 0usize);
-    assert!(offset_of!(TSFunctionType, this_param) == 8usize);
-    assert!(offset_of!(TSFunctionType, params) == 12usize);
-    assert!(offset_of!(TSFunctionType, return_type) == 16usize);
-    assert!(offset_of!(TSFunctionType, type_parameters) == 20usize);
+    assert!(offset_of!(TSFunctionType, type_parameters) == 8usize);
+    assert!(offset_of!(TSFunctionType, this_param) == 12usize);
+    assert!(offset_of!(TSFunctionType, params) == 16usize);
+    assert!(offset_of!(TSFunctionType, return_type) == 20usize);
 
     assert!(size_of::<TSConstructorType>() == 24usize);
     assert!(align_of::<TSConstructorType>() == 4usize);
     assert!(offset_of!(TSConstructorType, span) == 0usize);
     assert!(offset_of!(TSConstructorType, r#abstract) == 8usize);
-    assert!(offset_of!(TSConstructorType, params) == 12usize);
-    assert!(offset_of!(TSConstructorType, return_type) == 16usize);
-    assert!(offset_of!(TSConstructorType, type_parameters) == 20usize);
+    assert!(offset_of!(TSConstructorType, type_parameters) == 12usize);
+    assert!(offset_of!(TSConstructorType, params) == 16usize);
+    assert!(offset_of!(TSConstructorType, return_type) == 20usize);
 
     assert!(size_of::<TSMappedType>() == 36usize);
     assert!(align_of::<TSMappedType>() == 4usize);
diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
index 34d309007df04..334cb53823b6a 100644
--- a/crates/oxc_ast/src/generated/ast_builder.rs
+++ b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -8781,29 +8781,29 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// - span: The [`Span`] covering this node
     /// - r#abstract
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_type_constructor_type<T1, T2, T3>(
         self,
         span: Span,
         r#abstract: bool,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> TSType<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         TSType::TSConstructorType(self.alloc(self.ts_constructor_type(
             span,
             r#abstract,
+            type_parameters,
             params,
             return_type,
-            type_parameters,
         )))
     }
 
@@ -8822,31 +8822,31 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters: Generic type parameters
     /// - this_param: `this` parameter
     /// - params: Function parameters. Akin to [`Function::params`].
     /// - return_type: Return type of the function.
-    /// - type_parameters: Generic type parameters
     #[inline]
     pub fn ts_type_function_type<T1, T2, T3, T4>(
         self,
         span: Span,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> TSType<'a>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         TSType::TSFunctionType(self.alloc(self.ts_function_type(
             span,
+            type_parameters,
             this_param,
             params,
             return_type,
-            type_parameters,
         )))
     }
 
@@ -10799,30 +10799,30 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_signature_call_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
+        type_parameters: T1,
         this_param: Option<TSThisParameter<'a>>,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        params: T2,
+        return_type: T3,
     ) -> TSSignature<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSSignature::TSCallSignatureDeclaration(self.alloc(self.ts_call_signature_declaration(
             span,
+            type_parameters,
             this_param,
             params,
             return_type,
-            type_parameters,
         )))
     }
 
@@ -10841,24 +10841,24 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_signature_construct_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> TSSignature<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSSignature::TSConstructSignatureDeclaration(self.alloc(
-            self.ts_construct_signature_declaration(span, params, return_type, type_parameters),
+            self.ts_construct_signature_declaration(span, type_parameters, params, return_type),
         ))
     }
 
@@ -10884,10 +10884,10 @@ impl<'a> AstBuilder<'a> {
     /// - computed
     /// - optional
     /// - kind
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_signature_method_signature<T1, T2, T3, T4>(
         self,
@@ -10896,16 +10896,16 @@ impl<'a> AstBuilder<'a> {
         computed: bool,
         optional: bool,
         kind: TSMethodSignatureKind,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> TSSignature<'a>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSSignature::TSMethodSignature(self.alloc(self.ts_method_signature(
             span,
@@ -10913,10 +10913,10 @@ impl<'a> AstBuilder<'a> {
             computed,
             optional,
             kind,
+            type_parameters,
             this_param,
             params,
             return_type,
-            type_parameters,
         )))
     }
 
@@ -10989,30 +10989,30 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_call_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
+        type_parameters: T1,
         this_param: Option<TSThisParameter<'a>>,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        params: T2,
+        return_type: T3,
     ) -> TSCallSignatureDeclaration<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSCallSignatureDeclaration {
             span,
+            type_parameters: type_parameters.into_in(self.allocator),
             this_param,
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
-            type_parameters: type_parameters.into_in(self.allocator),
         }
     }
 
@@ -11022,31 +11022,31 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn alloc_ts_call_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
+        type_parameters: T1,
         this_param: Option<TSThisParameter<'a>>,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        params: T2,
+        return_type: T3,
     ) -> Box<'a, TSCallSignatureDeclaration<'a>>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         Box::new_in(
             self.ts_call_signature_declaration(
                 span,
+                type_parameters,
                 this_param,
                 params,
                 return_type,
-                type_parameters,
             ),
             self.allocator,
         )
@@ -11062,10 +11062,10 @@ impl<'a> AstBuilder<'a> {
     /// - computed
     /// - optional
     /// - kind
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_method_signature<T1, T2, T3, T4>(
         self,
@@ -11074,16 +11074,16 @@ impl<'a> AstBuilder<'a> {
         computed: bool,
         optional: bool,
         kind: TSMethodSignatureKind,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> TSMethodSignature<'a>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSMethodSignature {
             span,
@@ -11091,10 +11091,10 @@ impl<'a> AstBuilder<'a> {
             computed,
             optional,
             kind,
+            type_parameters: type_parameters.into_in(self.allocator),
             this_param: this_param.into_in(self.allocator),
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
-            type_parameters: type_parameters.into_in(self.allocator),
             scope_id: Default::default(),
         }
     }
@@ -11109,10 +11109,10 @@ impl<'a> AstBuilder<'a> {
     /// - computed
     /// - optional
     /// - kind
+    /// - type_parameters
     /// - this_param
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn alloc_ts_method_signature<T1, T2, T3, T4>(
         self,
@@ -11121,16 +11121,16 @@ impl<'a> AstBuilder<'a> {
         computed: bool,
         optional: bool,
         kind: TSMethodSignatureKind,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> Box<'a, TSMethodSignature<'a>>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         Box::new_in(
             self.ts_method_signature(
@@ -11139,10 +11139,10 @@ impl<'a> AstBuilder<'a> {
                 computed,
                 optional,
                 kind,
+                type_parameters,
                 this_param,
                 params,
                 return_type,
-                type_parameters,
             ),
             self.allocator,
         )
@@ -11154,27 +11154,27 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_construct_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> TSConstructSignatureDeclaration<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         TSConstructSignatureDeclaration {
             span,
+            type_parameters: type_parameters.into_in(self.allocator),
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
-            type_parameters: type_parameters.into_in(self.allocator),
             scope_id: Default::default(),
         }
     }
@@ -11185,24 +11185,24 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn alloc_ts_construct_signature_declaration<T1, T2, T3>(
         self,
         span: Span,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> Box<'a, TSConstructSignatureDeclaration<'a>>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
     {
         Box::new_in(
-            self.ts_construct_signature_declaration(span, params, return_type, type_parameters),
+            self.ts_construct_signature_declaration(span, type_parameters, params, return_type),
             self.allocator,
         )
     }
@@ -11972,31 +11972,31 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters: Generic type parameters
     /// - this_param: `this` parameter
     /// - params: Function parameters. Akin to [`Function::params`].
     /// - return_type: Return type of the function.
-    /// - type_parameters: Generic type parameters
     #[inline]
     pub fn ts_function_type<T1, T2, T3, T4>(
         self,
         span: Span,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> TSFunctionType<'a>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         TSFunctionType {
             span,
+            type_parameters: type_parameters.into_in(self.allocator),
             this_param: this_param.into_in(self.allocator),
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
-            type_parameters: type_parameters.into_in(self.allocator),
         }
     }
 
@@ -12006,27 +12006,27 @@ impl<'a> AstBuilder<'a> {
     ///
     /// ## Parameters
     /// - span: The [`Span`] covering this node
+    /// - type_parameters: Generic type parameters
     /// - this_param: `this` parameter
     /// - params: Function parameters. Akin to [`Function::params`].
     /// - return_type: Return type of the function.
-    /// - type_parameters: Generic type parameters
     #[inline]
     pub fn alloc_ts_function_type<T1, T2, T3, T4>(
         self,
         span: Span,
-        this_param: T1,
-        params: T2,
-        return_type: T3,
-        type_parameters: T4,
+        type_parameters: T1,
+        this_param: T2,
+        params: T3,
+        return_type: T4,
     ) -> Box<'a, TSFunctionType<'a>>
     where
-        T1: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
-        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T4: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSThisParameter<'a>>>>,
+        T3: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T4: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         Box::new_in(
-            self.ts_function_type(span, this_param, params, return_type, type_parameters),
+            self.ts_function_type(span, type_parameters, this_param, params, return_type),
             self.allocator,
         )
     }
@@ -12038,29 +12038,29 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// - span: The [`Span`] covering this node
     /// - r#abstract
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn ts_constructor_type<T1, T2, T3>(
         self,
         span: Span,
         r#abstract: bool,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> TSConstructorType<'a>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         TSConstructorType {
             span,
             r#abstract,
+            type_parameters: type_parameters.into_in(self.allocator),
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
-            type_parameters: type_parameters.into_in(self.allocator),
         }
     }
 
@@ -12071,25 +12071,25 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// - span: The [`Span`] covering this node
     /// - r#abstract
+    /// - type_parameters
     /// - params
     /// - return_type
-    /// - type_parameters
     #[inline]
     pub fn alloc_ts_constructor_type<T1, T2, T3>(
         self,
         span: Span,
         r#abstract: bool,
-        params: T1,
-        return_type: T2,
-        type_parameters: T3,
+        type_parameters: T1,
+        params: T2,
+        return_type: T3,
     ) -> Box<'a, TSConstructorType<'a>>
     where
-        T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
-        T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>,
+        T3: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,
     {
         Box::new_in(
-            self.ts_constructor_type(span, r#abstract, params, return_type, type_parameters),
+            self.ts_constructor_type(span, r#abstract, type_parameters, params, return_type),
             self.allocator,
         )
     }
diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs
index 59b5f3ffc83b8..e60a6643d3b87 100644
--- a/crates/oxc_ast/src/generated/derive_clone_in.rs
+++ b/crates/oxc_ast/src/generated/derive_clone_in.rs
@@ -3383,10 +3383,10 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSCallSignatureDeclaration<
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
         TSCallSignatureDeclaration {
             span: CloneIn::clone_in(&self.span, allocator),
+            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             this_param: CloneIn::clone_in(&self.this_param, allocator),
             params: CloneIn::clone_in(&self.params, allocator),
             return_type: CloneIn::clone_in(&self.return_type, allocator),
-            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
         }
     }
 }
@@ -3411,10 +3411,10 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSMethodSignature<'old_allo
             computed: CloneIn::clone_in(&self.computed, allocator),
             optional: CloneIn::clone_in(&self.optional, allocator),
             kind: CloneIn::clone_in(&self.kind, allocator),
+            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             this_param: CloneIn::clone_in(&self.this_param, allocator),
             params: CloneIn::clone_in(&self.params, allocator),
             return_type: CloneIn::clone_in(&self.return_type, allocator),
-            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             scope_id: Default::default(),
         }
     }
@@ -3425,9 +3425,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSConstructSignatureDeclara
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
         TSConstructSignatureDeclaration {
             span: CloneIn::clone_in(&self.span, allocator),
+            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             params: CloneIn::clone_in(&self.params, allocator),
             return_type: CloneIn::clone_in(&self.return_type, allocator),
-            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             scope_id: Default::default(),
         }
     }
@@ -3646,10 +3646,10 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSFunctionType<'old_alloc>
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
         TSFunctionType {
             span: CloneIn::clone_in(&self.span, allocator),
+            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             this_param: CloneIn::clone_in(&self.this_param, allocator),
             params: CloneIn::clone_in(&self.params, allocator),
             return_type: CloneIn::clone_in(&self.return_type, allocator),
-            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
         }
     }
 }
@@ -3660,9 +3660,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSConstructorType<'old_allo
         TSConstructorType {
             span: CloneIn::clone_in(&self.span, allocator),
             r#abstract: CloneIn::clone_in(&self.r#abstract, allocator),
+            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
             params: CloneIn::clone_in(&self.params, allocator),
             return_type: CloneIn::clone_in(&self.return_type, allocator),
-            type_parameters: CloneIn::clone_in(&self.type_parameters, allocator),
         }
     }
 }
diff --git a/crates/oxc_ast/src/generated/derive_content_eq.rs b/crates/oxc_ast/src/generated/derive_content_eq.rs
index e06196f26fe12..2ea7edb1e6cdb 100644
--- a/crates/oxc_ast/src/generated/derive_content_eq.rs
+++ b/crates/oxc_ast/src/generated/derive_content_eq.rs
@@ -3460,10 +3460,10 @@ impl<'a> ContentEq for TSIndexSignature<'a> {
 
 impl<'a> ContentEq for TSCallSignatureDeclaration<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        ContentEq::content_eq(&self.this_param, &other.this_param)
+        ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
+            && ContentEq::content_eq(&self.this_param, &other.this_param)
             && ContentEq::content_eq(&self.params, &other.params)
             && ContentEq::content_eq(&self.return_type, &other.return_type)
-            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
     }
 }
 
@@ -3479,18 +3479,18 @@ impl<'a> ContentEq for TSMethodSignature<'a> {
             && ContentEq::content_eq(&self.computed, &other.computed)
             && ContentEq::content_eq(&self.optional, &other.optional)
             && ContentEq::content_eq(&self.kind, &other.kind)
+            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
             && ContentEq::content_eq(&self.this_param, &other.this_param)
             && ContentEq::content_eq(&self.params, &other.params)
             && ContentEq::content_eq(&self.return_type, &other.return_type)
-            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
     }
 }
 
 impl<'a> ContentEq for TSConstructSignatureDeclaration<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        ContentEq::content_eq(&self.params, &other.params)
+        ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
+            && ContentEq::content_eq(&self.params, &other.params)
             && ContentEq::content_eq(&self.return_type, &other.return_type)
-            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
     }
 }
 
@@ -3662,19 +3662,19 @@ impl<'a> ContentEq for TSImportAttributeName<'a> {
 
 impl<'a> ContentEq for TSFunctionType<'a> {
     fn content_eq(&self, other: &Self) -> bool {
-        ContentEq::content_eq(&self.this_param, &other.this_param)
+        ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
+            && ContentEq::content_eq(&self.this_param, &other.this_param)
             && ContentEq::content_eq(&self.params, &other.params)
             && ContentEq::content_eq(&self.return_type, &other.return_type)
-            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
     }
 }
 
 impl<'a> ContentEq for TSConstructorType<'a> {
     fn content_eq(&self, other: &Self) -> bool {
         ContentEq::content_eq(&self.r#abstract, &other.r#abstract)
+            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
             && ContentEq::content_eq(&self.params, &other.params)
             && ContentEq::content_eq(&self.return_type, &other.return_type)
-            && ContentEq::content_eq(&self.type_parameters, &other.type_parameters)
     }
 }
 
diff --git a/crates/oxc_ast/src/generated/derive_content_hash.rs b/crates/oxc_ast/src/generated/derive_content_hash.rs
index 6d8311d4ff484..e7f5d3196c4de 100644
--- a/crates/oxc_ast/src/generated/derive_content_hash.rs
+++ b/crates/oxc_ast/src/generated/derive_content_hash.rs
@@ -1851,10 +1851,10 @@ impl<'a> ContentHash for TSIndexSignature<'a> {
 
 impl<'a> ContentHash for TSCallSignatureDeclaration<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&self.type_parameters, state);
         ContentHash::content_hash(&self.this_param, state);
         ContentHash::content_hash(&self.params, state);
         ContentHash::content_hash(&self.return_type, state);
-        ContentHash::content_hash(&self.type_parameters, state);
     }
 }
 
@@ -1870,18 +1870,18 @@ impl<'a> ContentHash for TSMethodSignature<'a> {
         ContentHash::content_hash(&self.computed, state);
         ContentHash::content_hash(&self.optional, state);
         ContentHash::content_hash(&self.kind, state);
+        ContentHash::content_hash(&self.type_parameters, state);
         ContentHash::content_hash(&self.this_param, state);
         ContentHash::content_hash(&self.params, state);
         ContentHash::content_hash(&self.return_type, state);
-        ContentHash::content_hash(&self.type_parameters, state);
     }
 }
 
 impl<'a> ContentHash for TSConstructSignatureDeclaration<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&self.type_parameters, state);
         ContentHash::content_hash(&self.params, state);
         ContentHash::content_hash(&self.return_type, state);
-        ContentHash::content_hash(&self.type_parameters, state);
     }
 }
 
@@ -2025,19 +2025,19 @@ impl<'a> ContentHash for TSImportAttributeName<'a> {
 
 impl<'a> ContentHash for TSFunctionType<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
+        ContentHash::content_hash(&self.type_parameters, state);
         ContentHash::content_hash(&self.this_param, state);
         ContentHash::content_hash(&self.params, state);
         ContentHash::content_hash(&self.return_type, state);
-        ContentHash::content_hash(&self.type_parameters, state);
     }
 }
 
 impl<'a> ContentHash for TSConstructorType<'a> {
     fn content_hash<H: Hasher>(&self, state: &mut H) {
         ContentHash::content_hash(&self.r#abstract, state);
+        ContentHash::content_hash(&self.type_parameters, state);
         ContentHash::content_hash(&self.params, state);
         ContentHash::content_hash(&self.return_type, state);
-        ContentHash::content_hash(&self.type_parameters, state);
     }
 }
 
diff --git a/crates/oxc_ast/src/generated/visit.rs b/crates/oxc_ast/src/generated/visit.rs
index 203a40dea87ec..0f973a526d429 100644
--- a/crates/oxc_ast/src/generated/visit.rs
+++ b/crates/oxc_ast/src/generated/visit.rs
@@ -1925,11 +1925,11 @@ pub mod walk {
     #[inline]
     pub fn walk_ts_constructor_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSConstructorType<'a>) {
         // NOTE: AstKind doesn't exists!
-        visitor.visit_formal_parameters(&it.params);
-        visitor.visit_ts_type_annotation(&it.return_type);
         if let Some(type_parameters) = &it.type_parameters {
             visitor.visit_ts_type_parameter_declaration(type_parameters);
         }
+        visitor.visit_formal_parameters(&it.params);
+        visitor.visit_ts_type_annotation(&it.return_type);
     }
 
     #[inline]
@@ -2090,14 +2090,14 @@ pub mod walk {
     #[inline]
     pub fn walk_ts_function_type<'a, V: Visit<'a>>(visitor: &mut V, it: &TSFunctionType<'a>) {
         // NOTE: AstKind doesn't exists!
+        if let Some(type_parameters) = &it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
         visitor.visit_formal_parameters(&it.params);
         visitor.visit_ts_type_annotation(&it.return_type);
-        if let Some(type_parameters) = &it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
     }
 
     #[inline]
@@ -2423,6 +2423,9 @@ pub mod walk {
         it: &TSCallSignatureDeclaration<'a>,
     ) {
         // NOTE: AstKind doesn't exists!
+        if let Some(type_parameters) = &it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
@@ -2430,9 +2433,6 @@ pub mod walk {
         if let Some(return_type) = &it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
     }
 
     #[inline]
@@ -2443,13 +2443,13 @@ pub mod walk {
         let kind = AstKind::TSConstructSignatureDeclaration(visitor.alloc(it));
         visitor.enter_node(kind);
         visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
+        if let Some(type_parameters) = &it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         visitor.visit_formal_parameters(&it.params);
         if let Some(return_type) = &it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
         visitor.leave_scope();
         visitor.leave_node(kind);
     }
@@ -2460,6 +2460,9 @@ pub mod walk {
         visitor.enter_node(kind);
         visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
         visitor.visit_property_key(&it.key);
+        if let Some(type_parameters) = &it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
@@ -2467,9 +2470,6 @@ pub mod walk {
         if let Some(return_type) = &it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
         visitor.leave_scope();
         visitor.leave_node(kind);
     }
diff --git a/crates/oxc_ast/src/generated/visit_mut.rs b/crates/oxc_ast/src/generated/visit_mut.rs
index 24042e90ffcd3..333343110a3fa 100644
--- a/crates/oxc_ast/src/generated/visit_mut.rs
+++ b/crates/oxc_ast/src/generated/visit_mut.rs
@@ -1971,11 +1971,11 @@ pub mod walk_mut {
         it: &mut TSConstructorType<'a>,
     ) {
         // NOTE: AstType doesn't exists!
-        visitor.visit_formal_parameters(&mut it.params);
-        visitor.visit_ts_type_annotation(&mut it.return_type);
         if let Some(type_parameters) = &mut it.type_parameters {
             visitor.visit_ts_type_parameter_declaration(type_parameters);
         }
+        visitor.visit_formal_parameters(&mut it.params);
+        visitor.visit_ts_type_annotation(&mut it.return_type);
     }
 
     #[inline]
@@ -2157,14 +2157,14 @@ pub mod walk_mut {
         it: &mut TSFunctionType<'a>,
     ) {
         // NOTE: AstType doesn't exists!
+        if let Some(type_parameters) = &mut it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &mut it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
         visitor.visit_formal_parameters(&mut it.params);
         visitor.visit_ts_type_annotation(&mut it.return_type);
-        if let Some(type_parameters) = &mut it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
     }
 
     #[inline]
@@ -2514,6 +2514,9 @@ pub mod walk_mut {
         it: &mut TSCallSignatureDeclaration<'a>,
     ) {
         // NOTE: AstType doesn't exists!
+        if let Some(type_parameters) = &mut it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &mut it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
@@ -2521,9 +2524,6 @@ pub mod walk_mut {
         if let Some(return_type) = &mut it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &mut it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
     }
 
     #[inline]
@@ -2534,13 +2534,13 @@ pub mod walk_mut {
         let kind = AstType::TSConstructSignatureDeclaration;
         visitor.enter_node(kind);
         visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
+        if let Some(type_parameters) = &mut it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         visitor.visit_formal_parameters(&mut it.params);
         if let Some(return_type) = &mut it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &mut it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
         visitor.leave_scope();
         visitor.leave_node(kind);
     }
@@ -2554,6 +2554,9 @@ pub mod walk_mut {
         visitor.enter_node(kind);
         visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
         visitor.visit_property_key(&mut it.key);
+        if let Some(type_parameters) = &mut it.type_parameters {
+            visitor.visit_ts_type_parameter_declaration(type_parameters);
+        }
         if let Some(this_param) = &mut it.this_param {
             visitor.visit_ts_this_parameter(this_param);
         }
@@ -2561,9 +2564,6 @@ pub mod walk_mut {
         if let Some(return_type) = &mut it.return_type {
             visitor.visit_ts_type_annotation(return_type);
         }
-        if let Some(type_parameters) = &mut it.type_parameters {
-            visitor.visit_ts_type_parameter_declaration(type_parameters);
-        }
         visitor.leave_scope();
         visitor.leave_node(kind);
     }
diff --git a/crates/oxc_isolated_declarations/src/types.rs b/crates/oxc_isolated_declarations/src/types.rs
index e01da5a121075..8ee3b0daa5574 100644
--- a/crates/oxc_isolated_declarations/src/types.rs
+++ b/crates/oxc_isolated_declarations/src/types.rs
@@ -30,11 +30,11 @@ impl<'a> IsolatedDeclarations<'a> {
             self.ast.ts_type_function_type(
                 func.span,
                 // SAFETY: `ast.copy` is unsound! We need to fix.
+                unsafe { self.ast.copy(&func.type_parameters) },
+                // SAFETY: `ast.copy` is unsound! We need to fix.
                 unsafe { self.ast.copy(&func.this_param) },
                 params,
                 return_type,
-                // SAFETY: `ast.copy` is unsound! We need to fix.
-                unsafe { self.ast.copy(&func.type_parameters) },
             )
         })
     }
@@ -57,11 +57,11 @@ impl<'a> IsolatedDeclarations<'a> {
         return_type.map(|return_type| {
             self.ast.ts_type_function_type(
                 func.span,
+                // SAFETY: `ast.copy` is unsound! We need to fix.
+                unsafe { self.ast.copy(&func.type_parameters) },
                 NONE,
                 params,
                 return_type,
-                // SAFETY: `ast.copy` is unsound! We need to fix.
-                unsafe { self.ast.copy(&func.type_parameters) },
             )
         })
     }
@@ -107,11 +107,11 @@ impl<'a> IsolatedDeclarations<'a> {
                                 false,
                                 TSMethodSignatureKind::Method,
                                 // SAFETY: `ast.copy` is unsound! We need to fix.
+                                unsafe { self.ast.copy(&function.type_parameters) },
+                                // SAFETY: `ast.copy` is unsound! We need to fix.
                                 unsafe { self.ast.copy(&function.this_param) },
                                 params,
                                 return_type,
-                                // SAFETY: `ast.copy` is unsound! We need to fix.
-                                unsafe { self.ast.copy(&function.type_parameters) },
                             ));
                         }
                     }
diff --git a/crates/oxc_parser/src/ts/types.rs b/crates/oxc_parser/src/ts/types.rs
index 8f09720c159c6..ad0de032bc7c3 100644
--- a/crates/oxc_parser/src/ts/types.rs
+++ b/crates/oxc_parser/src/ts/types.rs
@@ -75,12 +75,12 @@ impl<'a> ParserImpl<'a> {
             self.ast.ts_type_constructor_type(
                 span,
                 r#abstract,
+                type_parameters,
                 params,
                 return_type,
-                type_parameters,
             )
         } else {
-            self.ast.ts_type_function_type(span, this_param, params, return_type, type_parameters)
+            self.ast.ts_type_function_type(span, type_parameters, this_param, params, return_type)
         })
     }
 
@@ -1141,10 +1141,10 @@ impl<'a> ParserImpl<'a> {
         self.bump(Kind::Semicolon);
         Ok(self.ast.ts_signature_call_signature_declaration(
             self.end_span(span),
+            type_parameters,
             this_patam,
             params,
             return_type,
-            type_parameters,
         ))
     }
 
@@ -1162,10 +1162,10 @@ impl<'a> ParserImpl<'a> {
             computed,
             /* optional */ false,
             TSMethodSignatureKind::Get,
+            NONE,
             this_param,
             params,
             return_type,
-            NONE,
         ))
     }
 
@@ -1188,10 +1188,10 @@ impl<'a> ParserImpl<'a> {
             computed,
             /* optional */ false,
             TSMethodSignatureKind::Set,
+            NONE,
             this_param,
             params,
             return_type,
-            NONE,
         ))
     }
 
@@ -1223,10 +1223,10 @@ impl<'a> ParserImpl<'a> {
                 computed,
                 optional,
                 TSMethodSignatureKind::Method,
+                call_signature.type_parameters,
                 call_signature.this_param,
                 call_signature.params,
                 call_signature.return_type,
-                call_signature.type_parameters,
             ))
         } else {
             let type_annotation = self.parse_ts_type_annotation()?;
@@ -1261,9 +1261,9 @@ impl<'a> ParserImpl<'a> {
 
         Ok(self.ast.ts_signature_construct_signature_declaration(
             self.end_span(span),
+            type_parameters,
             params,
             return_type,
-            type_parameters,
         ))
     }
 
diff --git a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/constructor-generics2.snap b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/constructor-generics2.snap
index 4012b3eb57470..1749918540d94 100644
--- a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/constructor-generics2.snap
+++ b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/constructor-generics2.snap
@@ -32,7 +32,7 @@ SCOPES
                 "flags": "ReferenceFlags(Type)",
                 "id": 0,
                 "name": "U",
-                "node_id": 13
+                "node_id": 16
               }
             ]
           }
@@ -53,7 +53,7 @@ SCOPES
             "flags": "ReferenceFlags(Type)",
             "id": 1,
             "name": "T",
-            "node_id": 17
+            "node_id": 20
           }
         ]
       },
diff --git a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/function-generics2.snap b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/function-generics2.snap
index 2fd0c550679f3..de4a69d44cd30 100644
--- a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/function-generics2.snap
+++ b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/function/function-generics2.snap
@@ -32,7 +32,7 @@ SCOPES
                 "flags": "ReferenceFlags(Type)",
                 "id": 0,
                 "name": "U",
-                "node_id": 13
+                "node_id": 16
               }
             ]
           }
@@ -53,7 +53,7 @@ SCOPES
             "flags": "ReferenceFlags(Type)",
             "id": 1,
             "name": "T",
-            "node_id": 17
+            "node_id": 20
           }
         ]
       },
diff --git a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/call-generics.snap b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/call-generics.snap
index 31df0ee0349d6..c9be28f1aea31 100644
--- a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/call-generics.snap
+++ b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/call-generics.snap
@@ -32,7 +32,7 @@ SCOPES
                 "flags": "ReferenceFlags(Type)",
                 "id": 0,
                 "name": "U",
-                "node_id": 14
+                "node_id": 17
               }
             ]
           }
@@ -53,7 +53,7 @@ SCOPES
             "flags": "ReferenceFlags(Type)",
             "id": 1,
             "name": "T",
-            "node_id": 18
+            "node_id": 21
           }
         ]
       },
diff --git a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/construct-generics.snap b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/construct-generics.snap
index 1f8f1002eb336..375e5d4158813 100644
--- a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/construct-generics.snap
+++ b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/construct-generics.snap
@@ -34,7 +34,7 @@ SCOPES
                     "flags": "ReferenceFlags(Type)",
                     "id": 0,
                     "name": "U",
-                    "node_id": 15
+                    "node_id": 18
                   }
                 ]
               }
@@ -61,7 +61,7 @@ SCOPES
             "flags": "ReferenceFlags(Type)",
             "id": 1,
             "name": "T",
-            "node_id": 19
+            "node_id": 22
           }
         ]
       },
diff --git a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/method-generics.snap b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/method-generics.snap
index dcb95e622bb3a..591b725128889 100644
--- a/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/method-generics.snap
+++ b/crates/oxc_semantic/tests/fixtures/typescript-eslint/type-declaration/signatures/method-generics.snap
@@ -34,7 +34,7 @@ SCOPES
                     "flags": "ReferenceFlags(Type)",
                     "id": 1,
                     "name": "U",
-                    "node_id": 21
+                    "node_id": 24
                   }
                 ]
               }
@@ -61,7 +61,7 @@ SCOPES
             "flags": "ReferenceFlags(Type)",
             "id": 0,
             "name": "T",
-            "node_id": 17
+            "node_id": 20
           }
         ]
       },
diff --git a/crates/oxc_traverse/src/generated/ancestor.rs b/crates/oxc_traverse/src/generated/ancestor.rs
index e919a7f582b60..cab875efe5e3e 100644
--- a/crates/oxc_traverse/src/generated/ancestor.rs
+++ b/crates/oxc_traverse/src/generated/ancestor.rs
@@ -258,18 +258,18 @@ pub(crate) enum AncestorType {
     TSPropertySignatureTypeAnnotation = 230,
     TSIndexSignatureParameters = 231,
     TSIndexSignatureTypeAnnotation = 232,
-    TSCallSignatureDeclarationThisParam = 233,
-    TSCallSignatureDeclarationParams = 234,
-    TSCallSignatureDeclarationReturnType = 235,
-    TSCallSignatureDeclarationTypeParameters = 236,
+    TSCallSignatureDeclarationTypeParameters = 233,
+    TSCallSignatureDeclarationThisParam = 234,
+    TSCallSignatureDeclarationParams = 235,
+    TSCallSignatureDeclarationReturnType = 236,
     TSMethodSignatureKey = 237,
-    TSMethodSignatureThisParam = 238,
-    TSMethodSignatureParams = 239,
-    TSMethodSignatureReturnType = 240,
-    TSMethodSignatureTypeParameters = 241,
-    TSConstructSignatureDeclarationParams = 242,
-    TSConstructSignatureDeclarationReturnType = 243,
-    TSConstructSignatureDeclarationTypeParameters = 244,
+    TSMethodSignatureTypeParameters = 238,
+    TSMethodSignatureThisParam = 239,
+    TSMethodSignatureParams = 240,
+    TSMethodSignatureReturnType = 241,
+    TSConstructSignatureDeclarationTypeParameters = 242,
+    TSConstructSignatureDeclarationParams = 243,
+    TSConstructSignatureDeclarationReturnType = 244,
     TSIndexSignatureNameTypeAnnotation = 245,
     TSInterfaceHeritageExpression = 246,
     TSInterfaceHeritageTypeParameters = 247,
@@ -291,13 +291,13 @@ pub(crate) enum AncestorType {
     TSImportAttributesElements = 263,
     TSImportAttributeName = 264,
     TSImportAttributeValue = 265,
-    TSFunctionTypeThisParam = 266,
-    TSFunctionTypeParams = 267,
-    TSFunctionTypeReturnType = 268,
-    TSFunctionTypeTypeParameters = 269,
-    TSConstructorTypeParams = 270,
-    TSConstructorTypeReturnType = 271,
-    TSConstructorTypeTypeParameters = 272,
+    TSFunctionTypeTypeParameters = 266,
+    TSFunctionTypeThisParam = 267,
+    TSFunctionTypeParams = 268,
+    TSFunctionTypeReturnType = 269,
+    TSConstructorTypeTypeParameters = 270,
+    TSConstructorTypeParams = 271,
+    TSConstructorTypeReturnType = 272,
     TSMappedTypeTypeParameter = 273,
     TSMappedTypeNameType = 274,
     TSMappedTypeTypeAnnotation = 275,
@@ -764,33 +764,33 @@ pub enum Ancestor<'a, 't> {
         AncestorType::TSIndexSignatureParameters as u16,
     TSIndexSignatureTypeAnnotation(TSIndexSignatureWithoutTypeAnnotation<'a, 't>) =
         AncestorType::TSIndexSignatureTypeAnnotation as u16,
+    TSCallSignatureDeclarationTypeParameters(
+        TSCallSignatureDeclarationWithoutTypeParameters<'a, 't>,
+    ) = AncestorType::TSCallSignatureDeclarationTypeParameters as u16,
     TSCallSignatureDeclarationThisParam(TSCallSignatureDeclarationWithoutThisParam<'a, 't>) =
         AncestorType::TSCallSignatureDeclarationThisParam as u16,
     TSCallSignatureDeclarationParams(TSCallSignatureDeclarationWithoutParams<'a, 't>) =
         AncestorType::TSCallSignatureDeclarationParams as u16,
     TSCallSignatureDeclarationReturnType(TSCallSignatureDeclarationWithoutReturnType<'a, 't>) =
         AncestorType::TSCallSignatureDeclarationReturnType as u16,
-    TSCallSignatureDeclarationTypeParameters(
-        TSCallSignatureDeclarationWithoutTypeParameters<'a, 't>,
-    ) = AncestorType::TSCallSignatureDeclarationTypeParameters as u16,
     TSMethodSignatureKey(TSMethodSignatureWithoutKey<'a, 't>) =
         AncestorType::TSMethodSignatureKey as u16,
+    TSMethodSignatureTypeParameters(TSMethodSignatureWithoutTypeParameters<'a, 't>) =
+        AncestorType::TSMethodSignatureTypeParameters as u16,
     TSMethodSignatureThisParam(TSMethodSignatureWithoutThisParam<'a, 't>) =
         AncestorType::TSMethodSignatureThisParam as u16,
     TSMethodSignatureParams(TSMethodSignatureWithoutParams<'a, 't>) =
         AncestorType::TSMethodSignatureParams as u16,
     TSMethodSignatureReturnType(TSMethodSignatureWithoutReturnType<'a, 't>) =
         AncestorType::TSMethodSignatureReturnType as u16,
-    TSMethodSignatureTypeParameters(TSMethodSignatureWithoutTypeParameters<'a, 't>) =
-        AncestorType::TSMethodSignatureTypeParameters as u16,
+    TSConstructSignatureDeclarationTypeParameters(
+        TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't>,
+    ) = AncestorType::TSConstructSignatureDeclarationTypeParameters as u16,
     TSConstructSignatureDeclarationParams(TSConstructSignatureDeclarationWithoutParams<'a, 't>) =
         AncestorType::TSConstructSignatureDeclarationParams as u16,
     TSConstructSignatureDeclarationReturnType(
         TSConstructSignatureDeclarationWithoutReturnType<'a, 't>,
     ) = AncestorType::TSConstructSignatureDeclarationReturnType as u16,
-    TSConstructSignatureDeclarationTypeParameters(
-        TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't>,
-    ) = AncestorType::TSConstructSignatureDeclarationTypeParameters as u16,
     TSIndexSignatureNameTypeAnnotation(TSIndexSignatureNameWithoutTypeAnnotation<'a, 't>) =
         AncestorType::TSIndexSignatureNameTypeAnnotation as u16,
     TSInterfaceHeritageExpression(TSInterfaceHeritageWithoutExpression<'a, 't>) =
@@ -832,20 +832,20 @@ pub enum Ancestor<'a, 't> {
         AncestorType::TSImportAttributeName as u16,
     TSImportAttributeValue(TSImportAttributeWithoutValue<'a, 't>) =
         AncestorType::TSImportAttributeValue as u16,
+    TSFunctionTypeTypeParameters(TSFunctionTypeWithoutTypeParameters<'a, 't>) =
+        AncestorType::TSFunctionTypeTypeParameters as u16,
     TSFunctionTypeThisParam(TSFunctionTypeWithoutThisParam<'a, 't>) =
         AncestorType::TSFunctionTypeThisParam as u16,
     TSFunctionTypeParams(TSFunctionTypeWithoutParams<'a, 't>) =
         AncestorType::TSFunctionTypeParams as u16,
     TSFunctionTypeReturnType(TSFunctionTypeWithoutReturnType<'a, 't>) =
         AncestorType::TSFunctionTypeReturnType as u16,
-    TSFunctionTypeTypeParameters(TSFunctionTypeWithoutTypeParameters<'a, 't>) =
-        AncestorType::TSFunctionTypeTypeParameters as u16,
+    TSConstructorTypeTypeParameters(TSConstructorTypeWithoutTypeParameters<'a, 't>) =
+        AncestorType::TSConstructorTypeTypeParameters as u16,
     TSConstructorTypeParams(TSConstructorTypeWithoutParams<'a, 't>) =
         AncestorType::TSConstructorTypeParams as u16,
     TSConstructorTypeReturnType(TSConstructorTypeWithoutReturnType<'a, 't>) =
         AncestorType::TSConstructorTypeReturnType as u16,
-    TSConstructorTypeTypeParameters(TSConstructorTypeWithoutTypeParameters<'a, 't>) =
-        AncestorType::TSConstructorTypeTypeParameters as u16,
     TSMappedTypeTypeParameter(TSMappedTypeWithoutTypeParameter<'a, 't>) =
         AncestorType::TSMappedTypeTypeParameter as u16,
     TSMappedTypeNameType(TSMappedTypeWithoutNameType<'a, 't>) =
@@ -1658,10 +1658,10 @@ impl<'a, 't> Ancestor<'a, 't> {
     pub fn is_ts_call_signature_declaration(self) -> bool {
         matches!(
             self,
-            Self::TSCallSignatureDeclarationThisParam(_)
+            Self::TSCallSignatureDeclarationTypeParameters(_)
+                | Self::TSCallSignatureDeclarationThisParam(_)
                 | Self::TSCallSignatureDeclarationParams(_)
                 | Self::TSCallSignatureDeclarationReturnType(_)
-                | Self::TSCallSignatureDeclarationTypeParameters(_)
         )
     }
 
@@ -1670,10 +1670,10 @@ impl<'a, 't> Ancestor<'a, 't> {
         matches!(
             self,
             Self::TSMethodSignatureKey(_)
+                | Self::TSMethodSignatureTypeParameters(_)
                 | Self::TSMethodSignatureThisParam(_)
                 | Self::TSMethodSignatureParams(_)
                 | Self::TSMethodSignatureReturnType(_)
-                | Self::TSMethodSignatureTypeParameters(_)
         )
     }
 
@@ -1681,9 +1681,9 @@ impl<'a, 't> Ancestor<'a, 't> {
     pub fn is_ts_construct_signature_declaration(self) -> bool {
         matches!(
             self,
-            Self::TSConstructSignatureDeclarationParams(_)
+            Self::TSConstructSignatureDeclarationTypeParameters(_)
+                | Self::TSConstructSignatureDeclarationParams(_)
                 | Self::TSConstructSignatureDeclarationReturnType(_)
-                | Self::TSConstructSignatureDeclarationTypeParameters(_)
         )
     }
 
@@ -1761,10 +1761,10 @@ impl<'a, 't> Ancestor<'a, 't> {
     pub fn is_ts_function_type(self) -> bool {
         matches!(
             self,
-            Self::TSFunctionTypeThisParam(_)
+            Self::TSFunctionTypeTypeParameters(_)
+                | Self::TSFunctionTypeThisParam(_)
                 | Self::TSFunctionTypeParams(_)
                 | Self::TSFunctionTypeReturnType(_)
-                | Self::TSFunctionTypeTypeParameters(_)
         )
     }
 
@@ -1772,9 +1772,9 @@ impl<'a, 't> Ancestor<'a, 't> {
     pub fn is_ts_constructor_type(self) -> bool {
         matches!(
             self,
-            Self::TSConstructorTypeParams(_)
+            Self::TSConstructorTypeTypeParameters(_)
+                | Self::TSConstructorTypeParams(_)
                 | Self::TSConstructorTypeReturnType(_)
-                | Self::TSConstructorTypeTypeParameters(_)
         )
     }
 
@@ -10865,23 +10865,23 @@ impl<'a, 't> TSIndexSignatureWithoutTypeAnnotation<'a, 't> {
 
 pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_SPAN: usize =
     offset_of!(TSCallSignatureDeclaration, span);
+pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS: usize =
+    offset_of!(TSCallSignatureDeclaration, type_parameters);
 pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM: usize =
     offset_of!(TSCallSignatureDeclaration, this_param);
 pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_PARAMS: usize =
     offset_of!(TSCallSignatureDeclaration, params);
 pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_RETURN_TYPE: usize =
     offset_of!(TSCallSignatureDeclaration, return_type);
-pub(crate) const OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS: usize =
-    offset_of!(TSCallSignatureDeclaration, type_parameters);
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSCallSignatureDeclarationWithoutThisParam<'a, 't>(
+pub struct TSCallSignatureDeclarationWithoutTypeParameters<'a, 't>(
     pub(crate) *const TSCallSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSCallSignatureDeclarationWithoutThisParam<'a, 't> {
+impl<'a, 't> TSCallSignatureDeclarationWithoutTypeParameters<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -10889,6 +10889,14 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutThisParam<'a, 't> {
         }
     }
 
+    #[inline]
+    pub fn this_param(self) -> &'t Option<TSThisParameter<'a>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM)
+                as *const Option<TSThisParameter<'a>>)
+        }
+    }
+
     #[inline]
     pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
@@ -10904,24 +10912,16 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutThisParam<'a, 't> {
                 as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
-
-    #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
-        }
-    }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSCallSignatureDeclarationWithoutParams<'a, 't>(
+pub struct TSCallSignatureDeclarationWithoutThisParam<'a, 't>(
     pub(crate) *const TSCallSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSCallSignatureDeclarationWithoutParams<'a, 't> {
+impl<'a, 't> TSCallSignatureDeclarationWithoutThisParam<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -10930,38 +10930,38 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutParams<'a, 't> {
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<TSThisParameter<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM)
-                as *const Option<TSThisParameter<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSCallSignatureDeclarationWithoutReturnType<'a, 't>(
+pub struct TSCallSignatureDeclarationWithoutParams<'a, 't>(
     pub(crate) *const TSCallSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSCallSignatureDeclarationWithoutReturnType<'a, 't> {
+impl<'a, 't> TSCallSignatureDeclarationWithoutParams<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -10970,38 +10970,38 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutReturnType<'a, 't> {
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<TSThisParameter<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM)
-                as *const Option<TSThisParameter<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn this_param(self) -> &'t Option<TSThisParameter<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM)
+                as *const Option<TSThisParameter<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSCallSignatureDeclarationWithoutTypeParameters<'a, 't>(
+pub struct TSCallSignatureDeclarationWithoutReturnType<'a, 't>(
     pub(crate) *const TSCallSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSCallSignatureDeclarationWithoutTypeParameters<'a, 't> {
+impl<'a, 't> TSCallSignatureDeclarationWithoutReturnType<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -11009,6 +11009,14 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutTypeParameters<'a, 't> {
         }
     }
 
+    #[inline]
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn this_param(self) -> &'t Option<TSThisParameter<'a>> {
         unsafe {
@@ -11024,14 +11032,6 @@ impl<'a, 't> TSCallSignatureDeclarationWithoutTypeParameters<'a, 't> {
                 as *const Box<'a, FormalParameters<'a>>)
         }
     }
-
-    #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CALL_SIGNATURE_DECLARATION_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
-        }
-    }
 }
 
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_SPAN: usize = offset_of!(TSMethodSignature, span);
@@ -11041,13 +11041,13 @@ pub(crate) const OFFSET_TS_METHOD_SIGNATURE_COMPUTED: usize =
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_OPTIONAL: usize =
     offset_of!(TSMethodSignature, optional);
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_KIND: usize = offset_of!(TSMethodSignature, kind);
+pub(crate) const OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS: usize =
+    offset_of!(TSMethodSignature, type_parameters);
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM: usize =
     offset_of!(TSMethodSignature, this_param);
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_PARAMS: usize = offset_of!(TSMethodSignature, params);
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_RETURN_TYPE: usize =
     offset_of!(TSMethodSignature, return_type);
-pub(crate) const OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS: usize =
-    offset_of!(TSMethodSignature, type_parameters);
 pub(crate) const OFFSET_TS_METHOD_SIGNATURE_SCOPE_ID: usize =
     offset_of!(TSMethodSignature, scope_id);
 
@@ -11082,6 +11082,14 @@ impl<'a, 't> TSMethodSignatureWithoutKey<'a, 't> {
         }
     }
 
+    #[inline]
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
         unsafe {
@@ -11106,14 +11114,6 @@ impl<'a, 't> TSMethodSignatureWithoutKey<'a, 't> {
         }
     }
 
-    #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
-        }
-    }
-
     #[inline]
     pub fn scope_id(self) -> &'t Cell<Option<ScopeId>> {
         unsafe {
@@ -11125,12 +11125,12 @@ impl<'a, 't> TSMethodSignatureWithoutKey<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSMethodSignatureWithoutThisParam<'a, 't>(
+pub struct TSMethodSignatureWithoutTypeParameters<'a, 't>(
     pub(crate) *const TSMethodSignature<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSMethodSignatureWithoutThisParam<'a, 't> {
+impl<'a, 't> TSMethodSignatureWithoutTypeParameters<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_SPAN) as *const Span) }
@@ -11161,6 +11161,14 @@ impl<'a, 't> TSMethodSignatureWithoutThisParam<'a, 't> {
         }
     }
 
+    #[inline]
+    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM)
+                as *const Option<Box<'a, TSThisParameter<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
@@ -11177,14 +11185,6 @@ impl<'a, 't> TSMethodSignatureWithoutThisParam<'a, 't> {
         }
     }
 
-    #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
-        }
-    }
-
     #[inline]
     pub fn scope_id(self) -> &'t Cell<Option<ScopeId>> {
         unsafe {
@@ -11196,12 +11196,12 @@ impl<'a, 't> TSMethodSignatureWithoutThisParam<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSMethodSignatureWithoutParams<'a, 't>(
+pub struct TSMethodSignatureWithoutThisParam<'a, 't>(
     pub(crate) *const TSMethodSignature<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSMethodSignatureWithoutParams<'a, 't> {
+impl<'a, 't> TSMethodSignatureWithoutThisParam<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_SPAN) as *const Span) }
@@ -11233,26 +11233,26 @@ impl<'a, 't> TSMethodSignatureWithoutParams<'a, 't> {
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM)
-                as *const Option<Box<'a, TSThisParameter<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 
@@ -11267,12 +11267,12 @@ impl<'a, 't> TSMethodSignatureWithoutParams<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSMethodSignatureWithoutReturnType<'a, 't>(
+pub struct TSMethodSignatureWithoutParams<'a, 't>(
     pub(crate) *const TSMethodSignature<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSMethodSignatureWithoutReturnType<'a, 't> {
+impl<'a, 't> TSMethodSignatureWithoutParams<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_SPAN) as *const Span) }
@@ -11304,26 +11304,26 @@ impl<'a, 't> TSMethodSignatureWithoutReturnType<'a, 't> {
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM)
-                as *const Option<Box<'a, TSThisParameter<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM)
+                as *const Option<Box<'a, TSThisParameter<'a>>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 
@@ -11338,12 +11338,12 @@ impl<'a, 't> TSMethodSignatureWithoutReturnType<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSMethodSignatureWithoutTypeParameters<'a, 't>(
+pub struct TSMethodSignatureWithoutReturnType<'a, 't>(
     pub(crate) *const TSMethodSignature<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSMethodSignatureWithoutTypeParameters<'a, 't> {
+impl<'a, 't> TSMethodSignatureWithoutReturnType<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_SPAN) as *const Span) }
@@ -11374,6 +11374,14 @@ impl<'a, 't> TSMethodSignatureWithoutTypeParameters<'a, 't> {
         }
     }
 
+    #[inline]
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
         unsafe {
@@ -11390,14 +11398,6 @@ impl<'a, 't> TSMethodSignatureWithoutTypeParameters<'a, 't> {
         }
     }
 
-    #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_METHOD_SIGNATURE_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
-        }
-    }
-
     #[inline]
     pub fn scope_id(self) -> &'t Cell<Option<ScopeId>> {
         unsafe {
@@ -11409,23 +11409,23 @@ impl<'a, 't> TSMethodSignatureWithoutTypeParameters<'a, 't> {
 
 pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_SPAN: usize =
     offset_of!(TSConstructSignatureDeclaration, span);
+pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS: usize =
+    offset_of!(TSConstructSignatureDeclaration, type_parameters);
 pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS: usize =
     offset_of!(TSConstructSignatureDeclaration, params);
 pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_RETURN_TYPE: usize =
     offset_of!(TSConstructSignatureDeclaration, return_type);
-pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS: usize =
-    offset_of!(TSConstructSignatureDeclaration, type_parameters);
 pub(crate) const OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_SCOPE_ID: usize =
     offset_of!(TSConstructSignatureDeclaration, scope_id);
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructSignatureDeclarationWithoutParams<'a, 't>(
+pub struct TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't>(
     pub(crate) *const TSConstructSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructSignatureDeclarationWithoutParams<'a, 't> {
+impl<'a, 't> TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -11435,18 +11435,18 @@ impl<'a, 't> TSConstructSignatureDeclarationWithoutParams<'a, 't> {
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 
@@ -11461,12 +11461,12 @@ impl<'a, 't> TSConstructSignatureDeclarationWithoutParams<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructSignatureDeclarationWithoutReturnType<'a, 't>(
+pub struct TSConstructSignatureDeclarationWithoutParams<'a, 't>(
     pub(crate) *const TSConstructSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructSignatureDeclarationWithoutReturnType<'a, 't> {
+impl<'a, 't> TSConstructSignatureDeclarationWithoutParams<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -11476,18 +11476,18 @@ impl<'a, 't> TSConstructSignatureDeclarationWithoutReturnType<'a, 't> {
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_RETURN_TYPE)
+                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
         }
     }
 
@@ -11502,12 +11502,12 @@ impl<'a, 't> TSConstructSignatureDeclarationWithoutReturnType<'a, 't> {
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't>(
+pub struct TSConstructSignatureDeclarationWithoutReturnType<'a, 't>(
     pub(crate) *const TSConstructSignatureDeclaration<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't> {
+impl<'a, 't> TSConstructSignatureDeclarationWithoutReturnType<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe {
@@ -11517,18 +11517,18 @@ impl<'a, 't> TSConstructSignatureDeclarationWithoutTypeParameters<'a, 't> {
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Option<Box<'a, TSTypeAnnotation<'a>>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_RETURN_TYPE)
-                as *const Option<Box<'a, TSTypeAnnotation<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
@@ -12186,26 +12186,34 @@ impl<'a, 't> TSImportAttributeWithoutValue<'a, 't> {
 }
 
 pub(crate) const OFFSET_TS_FUNCTION_TYPE_SPAN: usize = offset_of!(TSFunctionType, span);
+pub(crate) const OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS: usize =
+    offset_of!(TSFunctionType, type_parameters);
 pub(crate) const OFFSET_TS_FUNCTION_TYPE_THIS_PARAM: usize = offset_of!(TSFunctionType, this_param);
 pub(crate) const OFFSET_TS_FUNCTION_TYPE_PARAMS: usize = offset_of!(TSFunctionType, params);
 pub(crate) const OFFSET_TS_FUNCTION_TYPE_RETURN_TYPE: usize =
     offset_of!(TSFunctionType, return_type);
-pub(crate) const OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS: usize =
-    offset_of!(TSFunctionType, type_parameters);
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSFunctionTypeWithoutThisParam<'a, 't>(
+pub struct TSFunctionTypeWithoutTypeParameters<'a, 't>(
     pub(crate) *const TSFunctionType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSFunctionTypeWithoutThisParam<'a, 't> {
+impl<'a, 't> TSFunctionTypeWithoutTypeParameters<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_SPAN) as *const Span) }
     }
 
+    #[inline]
+    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_THIS_PARAM)
+                as *const Option<Box<'a, TSThisParameter<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
@@ -12221,105 +12229,105 @@ impl<'a, 't> TSFunctionTypeWithoutThisParam<'a, 't> {
                 as *const Box<'a, TSTypeAnnotation<'a>>)
         }
     }
-
-    #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
-        }
-    }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSFunctionTypeWithoutParams<'a, 't>(
+pub struct TSFunctionTypeWithoutThisParam<'a, 't>(
     pub(crate) *const TSFunctionType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSFunctionTypeWithoutParams<'a, 't> {
+impl<'a, 't> TSFunctionTypeWithoutThisParam<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_SPAN) as *const Span) }
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_THIS_PARAM)
-                as *const Option<Box<'a, TSThisParameter<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_RETURN_TYPE)
-                as *const Box<'a, TSTypeAnnotation<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_RETURN_TYPE)
+                as *const Box<'a, TSTypeAnnotation<'a>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSFunctionTypeWithoutReturnType<'a, 't>(
+pub struct TSFunctionTypeWithoutParams<'a, 't>(
     pub(crate) *const TSFunctionType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSFunctionTypeWithoutReturnType<'a, 't> {
+impl<'a, 't> TSFunctionTypeWithoutParams<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_SPAN) as *const Span) }
     }
 
     #[inline]
-    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_THIS_PARAM)
-                as *const Option<Box<'a, TSThisParameter<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_THIS_PARAM)
+                as *const Option<Box<'a, TSThisParameter<'a>>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_RETURN_TYPE)
+                as *const Box<'a, TSTypeAnnotation<'a>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSFunctionTypeWithoutTypeParameters<'a, 't>(
+pub struct TSFunctionTypeWithoutReturnType<'a, 't>(
     pub(crate) *const TSFunctionType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSFunctionTypeWithoutTypeParameters<'a, 't> {
+impl<'a, 't> TSFunctionTypeWithoutReturnType<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_SPAN) as *const Span) }
     }
 
+    #[inline]
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+        }
+    }
+
     #[inline]
     pub fn this_param(self) -> &'t Option<Box<'a, TSThisParameter<'a>>> {
         unsafe {
@@ -12335,33 +12343,25 @@ impl<'a, 't> TSFunctionTypeWithoutTypeParameters<'a, 't> {
                 as *const Box<'a, FormalParameters<'a>>)
         }
     }
-
-    #[inline]
-    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
-        unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_FUNCTION_TYPE_RETURN_TYPE)
-                as *const Box<'a, TSTypeAnnotation<'a>>)
-        }
-    }
 }
 
 pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_SPAN: usize = offset_of!(TSConstructorType, span);
 pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_ABSTRACT: usize =
     offset_of!(TSConstructorType, r#abstract);
+pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS: usize =
+    offset_of!(TSConstructorType, type_parameters);
 pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS: usize = offset_of!(TSConstructorType, params);
 pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_RETURN_TYPE: usize =
     offset_of!(TSConstructorType, return_type);
-pub(crate) const OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS: usize =
-    offset_of!(TSConstructorType, type_parameters);
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructorTypeWithoutParams<'a, 't>(
+pub struct TSConstructorTypeWithoutTypeParameters<'a, 't>(
     pub(crate) *const TSConstructorType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructorTypeWithoutParams<'a, 't> {
+impl<'a, 't> TSConstructorTypeWithoutTypeParameters<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_SPAN) as *const Span) }
@@ -12373,30 +12373,30 @@ impl<'a, 't> TSConstructorTypeWithoutParams<'a, 't> {
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_RETURN_TYPE)
-                as *const Box<'a, TSTypeAnnotation<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_RETURN_TYPE)
+                as *const Box<'a, TSTypeAnnotation<'a>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructorTypeWithoutReturnType<'a, 't>(
+pub struct TSConstructorTypeWithoutParams<'a, 't>(
     pub(crate) *const TSConstructorType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructorTypeWithoutReturnType<'a, 't> {
+impl<'a, 't> TSConstructorTypeWithoutParams<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_SPAN) as *const Span) }
@@ -12408,30 +12408,30 @@ impl<'a, 't> TSConstructorTypeWithoutReturnType<'a, 't> {
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
+    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
-                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_RETURN_TYPE)
+                as *const Box<'a, TSTypeAnnotation<'a>>)
         }
     }
 }
 
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug)]
-pub struct TSConstructorTypeWithoutTypeParameters<'a, 't>(
+pub struct TSConstructorTypeWithoutReturnType<'a, 't>(
     pub(crate) *const TSConstructorType<'a>,
     pub(crate) PhantomData<&'t ()>,
 );
 
-impl<'a, 't> TSConstructorTypeWithoutTypeParameters<'a, 't> {
+impl<'a, 't> TSConstructorTypeWithoutReturnType<'a, 't> {
     #[inline]
     pub fn span(self) -> &'t Span {
         unsafe { &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_SPAN) as *const Span) }
@@ -12443,18 +12443,18 @@ impl<'a, 't> TSConstructorTypeWithoutTypeParameters<'a, 't> {
     }
 
     #[inline]
-    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
+    pub fn type_parameters(self) -> &'t Option<Box<'a, TSTypeParameterDeclaration<'a>>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS)
-                as *const Box<'a, FormalParameters<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
+                as *const Option<Box<'a, TSTypeParameterDeclaration<'a>>>)
         }
     }
 
     #[inline]
-    pub fn return_type(self) -> &'t Box<'a, TSTypeAnnotation<'a>> {
+    pub fn params(self) -> &'t Box<'a, FormalParameters<'a>> {
         unsafe {
-            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_RETURN_TYPE)
-                as *const Box<'a, TSTypeAnnotation<'a>>)
+            &*((self.0 as *const u8).add(OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS)
+                as *const Box<'a, FormalParameters<'a>>)
         }
     }
 }
diff --git a/crates/oxc_traverse/src/generated/walk.rs b/crates/oxc_traverse/src/generated/walk.rs
index 0eb8f6b2709f0..97a34c9e76ce2 100644
--- a/crates/oxc_traverse/src/generated/walk.rs
+++ b/crates/oxc_traverse/src/generated/walk.rs
@@ -4732,13 +4732,20 @@ pub(crate) unsafe fn walk_ts_call_signature_declaration<'a, Tr: Traverse<'a>>(
     ctx: &mut TraverseCtx<'a>,
 ) {
     traverser.enter_ts_call_signature_declaration(&mut *node, ctx);
-    let pop_token = ctx.push_stack(Ancestor::TSCallSignatureDeclarationThisParam(
-        ancestor::TSCallSignatureDeclarationWithoutThisParam(node, PhantomData),
+    let pop_token = ctx.push_stack(Ancestor::TSCallSignatureDeclarationTypeParameters(
+        ancestor::TSCallSignatureDeclarationWithoutTypeParameters(node, PhantomData),
     ));
+    if let Some(field) = &mut *((node as *mut u8)
+        .add(ancestor::OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+        as *mut Option<Box<TSTypeParameterDeclaration>>)
+    {
+        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
+    }
     if let Some(field) = &mut *((node as *mut u8)
         .add(ancestor::OFFSET_TS_CALL_SIGNATURE_DECLARATION_THIS_PARAM)
         as *mut Option<TSThisParameter>)
     {
+        ctx.retag_stack(AncestorType::TSCallSignatureDeclarationThisParam);
         walk_ts_this_parameter(traverser, field as *mut _, ctx);
     }
     ctx.retag_stack(AncestorType::TSCallSignatureDeclarationParams);
@@ -4755,13 +4762,6 @@ pub(crate) unsafe fn walk_ts_call_signature_declaration<'a, Tr: Traverse<'a>>(
         ctx.retag_stack(AncestorType::TSCallSignatureDeclarationReturnType);
         walk_ts_type_annotation(traverser, (&mut **field) as *mut _, ctx);
     }
-    if let Some(field) = &mut *((node as *mut u8)
-        .add(ancestor::OFFSET_TS_CALL_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-        as *mut Option<Box<TSTypeParameterDeclaration>>)
-    {
-        ctx.retag_stack(AncestorType::TSCallSignatureDeclarationTypeParameters);
-        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
-    }
     ctx.pop_stack(pop_token);
     traverser.exit_ts_call_signature_declaration(&mut *node, ctx);
 }
@@ -4787,6 +4787,13 @@ pub(crate) unsafe fn walk_ts_method_signature<'a, Tr: Traverse<'a>>(
         (node as *mut u8).add(ancestor::OFFSET_TS_METHOD_SIGNATURE_KEY) as *mut PropertyKey,
         ctx,
     );
+    if let Some(field) = &mut *((node as *mut u8)
+        .add(ancestor::OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
+        as *mut Option<Box<TSTypeParameterDeclaration>>)
+    {
+        ctx.retag_stack(AncestorType::TSMethodSignatureTypeParameters);
+        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
+    }
     if let Some(field) = &mut *((node as *mut u8)
         .add(ancestor::OFFSET_TS_METHOD_SIGNATURE_THIS_PARAM)
         as *mut Option<Box<TSThisParameter>>)
@@ -4808,13 +4815,6 @@ pub(crate) unsafe fn walk_ts_method_signature<'a, Tr: Traverse<'a>>(
         ctx.retag_stack(AncestorType::TSMethodSignatureReturnType);
         walk_ts_type_annotation(traverser, (&mut **field) as *mut _, ctx);
     }
-    if let Some(field) = &mut *((node as *mut u8)
-        .add(ancestor::OFFSET_TS_METHOD_SIGNATURE_TYPE_PARAMETERS)
-        as *mut Option<Box<TSTypeParameterDeclaration>>)
-    {
-        ctx.retag_stack(AncestorType::TSMethodSignatureTypeParameters);
-        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
-    }
     ctx.pop_stack(pop_token);
     ctx.set_current_scope_id(previous_scope_id);
     traverser.exit_ts_method_signature(&mut *node, ctx);
@@ -4833,9 +4833,16 @@ pub(crate) unsafe fn walk_ts_construct_signature_declaration<'a, Tr: Traverse<'a
             .get()
             .unwrap(),
     );
-    let pop_token = ctx.push_stack(Ancestor::TSConstructSignatureDeclarationParams(
-        ancestor::TSConstructSignatureDeclarationWithoutParams(node, PhantomData),
+    let pop_token = ctx.push_stack(Ancestor::TSConstructSignatureDeclarationTypeParameters(
+        ancestor::TSConstructSignatureDeclarationWithoutTypeParameters(node, PhantomData),
     ));
+    if let Some(field) = &mut *((node as *mut u8)
+        .add(ancestor::OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
+        as *mut Option<Box<TSTypeParameterDeclaration>>)
+    {
+        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
+    }
+    ctx.retag_stack(AncestorType::TSConstructSignatureDeclarationParams);
     walk_formal_parameters(
         traverser,
         (&mut **((node as *mut u8).add(ancestor::OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_PARAMS)
@@ -4849,13 +4856,6 @@ pub(crate) unsafe fn walk_ts_construct_signature_declaration<'a, Tr: Traverse<'a
         ctx.retag_stack(AncestorType::TSConstructSignatureDeclarationReturnType);
         walk_ts_type_annotation(traverser, (&mut **field) as *mut _, ctx);
     }
-    if let Some(field) = &mut *((node as *mut u8)
-        .add(ancestor::OFFSET_TS_CONSTRUCT_SIGNATURE_DECLARATION_TYPE_PARAMETERS)
-        as *mut Option<Box<TSTypeParameterDeclaration>>)
-    {
-        ctx.retag_stack(AncestorType::TSConstructSignatureDeclarationTypeParameters);
-        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
-    }
     ctx.pop_stack(pop_token);
     ctx.set_current_scope_id(previous_scope_id);
     traverser.exit_ts_construct_signature_declaration(&mut *node, ctx);
@@ -5229,12 +5229,19 @@ pub(crate) unsafe fn walk_ts_function_type<'a, Tr: Traverse<'a>>(
     ctx: &mut TraverseCtx<'a>,
 ) {
     traverser.enter_ts_function_type(&mut *node, ctx);
-    let pop_token = ctx.push_stack(Ancestor::TSFunctionTypeThisParam(
-        ancestor::TSFunctionTypeWithoutThisParam(node, PhantomData),
+    let pop_token = ctx.push_stack(Ancestor::TSFunctionTypeTypeParameters(
+        ancestor::TSFunctionTypeWithoutTypeParameters(node, PhantomData),
     ));
+    if let Some(field) = &mut *((node as *mut u8)
+        .add(ancestor::OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
+        as *mut Option<Box<TSTypeParameterDeclaration>>)
+    {
+        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
+    }
     if let Some(field) = &mut *((node as *mut u8).add(ancestor::OFFSET_TS_FUNCTION_TYPE_THIS_PARAM)
         as *mut Option<Box<TSThisParameter>>)
     {
+        ctx.retag_stack(AncestorType::TSFunctionTypeThisParam);
         walk_ts_this_parameter(traverser, (&mut **field) as *mut _, ctx);
     }
     ctx.retag_stack(AncestorType::TSFunctionTypeParams);
@@ -5251,13 +5258,6 @@ pub(crate) unsafe fn walk_ts_function_type<'a, Tr: Traverse<'a>>(
             as *mut Box<TSTypeAnnotation>)) as *mut _,
         ctx,
     );
-    if let Some(field) = &mut *((node as *mut u8)
-        .add(ancestor::OFFSET_TS_FUNCTION_TYPE_TYPE_PARAMETERS)
-        as *mut Option<Box<TSTypeParameterDeclaration>>)
-    {
-        ctx.retag_stack(AncestorType::TSFunctionTypeTypeParameters);
-        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
-    }
     ctx.pop_stack(pop_token);
     traverser.exit_ts_function_type(&mut *node, ctx);
 }
@@ -5268,9 +5268,16 @@ pub(crate) unsafe fn walk_ts_constructor_type<'a, Tr: Traverse<'a>>(
     ctx: &mut TraverseCtx<'a>,
 ) {
     traverser.enter_ts_constructor_type(&mut *node, ctx);
-    let pop_token = ctx.push_stack(Ancestor::TSConstructorTypeParams(
-        ancestor::TSConstructorTypeWithoutParams(node, PhantomData),
+    let pop_token = ctx.push_stack(Ancestor::TSConstructorTypeTypeParameters(
+        ancestor::TSConstructorTypeWithoutTypeParameters(node, PhantomData),
     ));
+    if let Some(field) = &mut *((node as *mut u8)
+        .add(ancestor::OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
+        as *mut Option<Box<TSTypeParameterDeclaration>>)
+    {
+        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
+    }
+    ctx.retag_stack(AncestorType::TSConstructorTypeParams);
     walk_formal_parameters(
         traverser,
         (&mut **((node as *mut u8).add(ancestor::OFFSET_TS_CONSTRUCTOR_TYPE_PARAMS)
@@ -5284,13 +5291,6 @@ pub(crate) unsafe fn walk_ts_constructor_type<'a, Tr: Traverse<'a>>(
             as *mut Box<TSTypeAnnotation>)) as *mut _,
         ctx,
     );
-    if let Some(field) = &mut *((node as *mut u8)
-        .add(ancestor::OFFSET_TS_CONSTRUCTOR_TYPE_TYPE_PARAMETERS)
-        as *mut Option<Box<TSTypeParameterDeclaration>>)
-    {
-        ctx.retag_stack(AncestorType::TSConstructorTypeTypeParameters);
-        walk_ts_type_parameter_declaration(traverser, (&mut **field) as *mut _, ctx);
-    }
     ctx.pop_stack(pop_token);
     traverser.exit_ts_constructor_type(&mut *node, ctx);
 }
diff --git a/tasks/coverage/snapshots/semantic_babel.snap b/tasks/coverage/snapshots/semantic_babel.snap
index afebc9bdd3519..b00d9cc6e50ed 100644
--- a/tasks/coverage/snapshots/semantic_babel.snap
+++ b/tasks/coverage/snapshots/semantic_babel.snap
@@ -247,7 +247,7 @@ semantic error: Bindings mismatch:
 after transform: ScopeId(1): ["M"]
 rebuilt        : ScopeId(1): []
 Symbol reference IDs mismatch for "AbstractClass":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(3)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "ConcreteClass":
 after transform: SymbolId(2): [ReferenceId(4), ReferenceId(6)]
@@ -258,7 +258,7 @@ semantic error: Bindings mismatch:
 after transform: ScopeId(1): ["M"]
 rebuilt        : ScopeId(1): []
 Symbol reference IDs mismatch for "AbstractClass":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(3)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "ConcreteClass":
 after transform: SymbolId(2): [ReferenceId(4), ReferenceId(6)]
diff --git a/tasks/coverage/snapshots/semantic_typescript.snap b/tasks/coverage/snapshots/semantic_typescript.snap
index 190ac592bf944..fe765d7a0ce3a 100644
--- a/tasks/coverage/snapshots/semantic_typescript.snap
+++ b/tasks/coverage/snapshots/semantic_typescript.snap
@@ -5131,7 +5131,7 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6)]
 rebuilt        : ScopeId(0): [ScopeId(1)]
 Symbol reference IDs mismatch for "DEFAULT_TABS_TAG":
-after transform: SymbolId(2): [ReferenceId(11), ReferenceId(17)]
+after transform: SymbolId(2): [ReferenceId(11), ReferenceId(15)]
 rebuilt        : SymbolId(0): []
 Reference symbol mismatch for "TabGroup":
 after transform: SymbolId(10) "TabGroup"
@@ -5148,7 +5148,7 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7), ScopeId(8)]
 rebuilt        : ScopeId(0): [ScopeId(1)]
 Symbol reference IDs mismatch for "DEFAULT_TABS_TAG":
-after transform: SymbolId(6): [ReferenceId(17), ReferenceId(23)]
+after transform: SymbolId(6): [ReferenceId(17), ReferenceId(21)]
 rebuilt        : SymbolId(0): []
 Reference symbol mismatch for "TabGroup":
 after transform: SymbolId(14) "TabGroup"
@@ -9023,13 +9023,13 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(7), ReferenceId(13)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(5), ReferenceId(11)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(2)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(10)]
+after transform: SymbolId(2): [ReferenceId(8)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/compiler/declarationEmitTypeParameterNameShadowedInternally.ts
@@ -21454,7 +21454,7 @@ Bindings mismatch:
 after transform: ScopeId(7): ["S"]
 rebuilt        : ScopeId(3): []
 Symbol reference IDs mismatch for "Table":
-after transform: SymbolId(4): [ReferenceId(14), ReferenceId(16), ReferenceId(21), ReferenceId(25)]
+after transform: SymbolId(4): [ReferenceId(14), ReferenceId(17), ReferenceId(22), ReferenceId(25)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Unresolved references mismatch:
 after transform: ["Array", "Pick", "Record"]
@@ -24652,7 +24652,7 @@ Bindings mismatch:
 after transform: ScopeId(7): ["T"]
 rebuilt        : ScopeId(5): []
 Symbol reference IDs mismatch for "FeatureRunner":
-after transform: SymbolId(3): [ReferenceId(0)]
+after transform: SymbolId(3): [ReferenceId(1)]
 rebuilt        : SymbolId(0): []
 Unresolved references mismatch:
 after transform: ["Promise", "const"]
@@ -55502,7 +55502,7 @@ Bindings mismatch:
 after transform: ScopeId(4): ["T", "a", "x"]
 rebuilt        : ScopeId(3): ["a", "x"]
 Unresolved reference IDs mismatch for "Date":
-after transform: [ReferenceId(0), ReferenceId(6), ReferenceId(7), ReferenceId(10), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(24)]
+after transform: [ReferenceId(0), ReferenceId(6), ReferenceId(7), ReferenceId(10), ReferenceId(13), ReferenceId(16), ReferenceId(18), ReferenceId(24)]
 rebuilt        : [ReferenceId(12)]
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeParameters/typeParameterLists/propertyAccessOnTypeParameterWithConstraints2.ts
@@ -55519,7 +55519,7 @@ Bindings mismatch:
 after transform: ScopeId(9): ["T", "U", "a", "x", "y"]
 rebuilt        : ScopeId(8): ["a", "x", "y"]
 Symbol reference IDs mismatch for "A":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(2), ReferenceId(13), ReferenceId(16), ReferenceId(18), ReferenceId(19), ReferenceId(23), ReferenceId(27), ReferenceId(28), ReferenceId(31), ReferenceId(32), ReferenceId(36), ReferenceId(37), ReferenceId(39), ReferenceId(40), ReferenceId(49), ReferenceId(50)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(2), ReferenceId(13), ReferenceId(16), ReferenceId(18), ReferenceId(19), ReferenceId(23), ReferenceId(26), ReferenceId(27), ReferenceId(29), ReferenceId(30), ReferenceId(33), ReferenceId(34), ReferenceId(39), ReferenceId(40), ReferenceId(49), ReferenceId(50)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "B":
 after transform: SymbolId(1): [ReferenceId(12), ReferenceId(15), ReferenceId(17), ReferenceId(22), ReferenceId(42)]
@@ -55539,7 +55539,7 @@ Bindings mismatch:
 after transform: ScopeId(9): ["T", "U", "a", "x"]
 rebuilt        : ScopeId(8): ["a", "x"]
 Symbol reference IDs mismatch for "A":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(12), ReferenceId(15), ReferenceId(18), ReferenceId(22), ReferenceId(27), ReferenceId(32), ReferenceId(39)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(12), ReferenceId(15), ReferenceId(18), ReferenceId(22), ReferenceId(26), ReferenceId(30), ReferenceId(39)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "B":
 after transform: SymbolId(1): [ReferenceId(13), ReferenceId(16), ReferenceId(17), ReferenceId(23), ReferenceId(36), ReferenceId(38), ReferenceId(46)]
@@ -55822,10 +55822,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(41), ReferenceId(59), ReferenceId(65), ReferenceId(73), ReferenceId(80), ReferenceId(88), ReferenceId(90), ReferenceId(95), ReferenceId(97), ReferenceId(108)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(40), ReferenceId(56), ReferenceId(61), ReferenceId(67), ReferenceId(75), ReferenceId(85), ReferenceId(90), ReferenceId(92), ReferenceId(99), ReferenceId(107)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(39), ReferenceId(60), ReferenceId(66), ReferenceId(74), ReferenceId(81), ReferenceId(84), ReferenceId(93), ReferenceId(101)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(38), ReferenceId(57), ReferenceId(62), ReferenceId(68), ReferenceId(76), ReferenceId(82), ReferenceId(95), ReferenceId(97)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(28)]
@@ -55842,13 +55842,13 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(15), ReferenceId(19), ReferenceId(26), ReferenceId(34), ReferenceId(40), ReferenceId(46), ReferenceId(61), ReferenceId(66)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(12), ReferenceId(19), ReferenceId(23), ReferenceId(31), ReferenceId(38), ReferenceId(44), ReferenceId(58), ReferenceId(66)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(13), ReferenceId(30), ReferenceId(37), ReferenceId(62)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(14), ReferenceId(27), ReferenceId(35), ReferenceId(59)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(43)]
+after transform: SymbolId(2): [ReferenceId(41)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance5.ts
@@ -55859,10 +55859,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(56), ReferenceId(62), ReferenceId(70), ReferenceId(77), ReferenceId(85), ReferenceId(87), ReferenceId(92), ReferenceId(94)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(53), ReferenceId(58), ReferenceId(64), ReferenceId(72), ReferenceId(82), ReferenceId(87), ReferenceId(89), ReferenceId(96)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(57), ReferenceId(63), ReferenceId(71), ReferenceId(78), ReferenceId(81), ReferenceId(90), ReferenceId(98)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(54), ReferenceId(59), ReferenceId(65), ReferenceId(73), ReferenceId(79), ReferenceId(92), ReferenceId(94)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(28)]
@@ -55879,10 +55879,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(18)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(41), ReferenceId(59), ReferenceId(65), ReferenceId(73), ReferenceId(80), ReferenceId(88), ReferenceId(90), ReferenceId(95), ReferenceId(97), ReferenceId(108)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(40), ReferenceId(56), ReferenceId(61), ReferenceId(67), ReferenceId(75), ReferenceId(85), ReferenceId(90), ReferenceId(92), ReferenceId(99), ReferenceId(107)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(39), ReferenceId(60), ReferenceId(66), ReferenceId(74), ReferenceId(81), ReferenceId(84), ReferenceId(93), ReferenceId(101)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(38), ReferenceId(57), ReferenceId(62), ReferenceId(68), ReferenceId(76), ReferenceId(82), ReferenceId(95), ReferenceId(97)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(28)]
@@ -55899,13 +55899,13 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(18)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(15), ReferenceId(19), ReferenceId(26), ReferenceId(29), ReferenceId(36), ReferenceId(44), ReferenceId(50), ReferenceId(53), ReferenceId(71), ReferenceId(76), ReferenceId(85), ReferenceId(87), ReferenceId(91), ReferenceId(94)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(12), ReferenceId(19), ReferenceId(23), ReferenceId(27), ReferenceId(35), ReferenceId(41), ReferenceId(48), ReferenceId(51), ReferenceId(68), ReferenceId(76), ReferenceId(83), ReferenceId(86), ReferenceId(88), ReferenceId(92)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(13), ReferenceId(32), ReferenceId(34), ReferenceId(40), ReferenceId(47), ReferenceId(72)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(14), ReferenceId(30), ReferenceId(33), ReferenceId(37), ReferenceId(45), ReferenceId(69)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(56)]
+after transform: SymbolId(2): [ReferenceId(54)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/constructSignatureAssignabilityInInheritance5.ts
@@ -55916,10 +55916,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(56), ReferenceId(62), ReferenceId(70), ReferenceId(77), ReferenceId(85), ReferenceId(87), ReferenceId(92), ReferenceId(94)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(53), ReferenceId(58), ReferenceId(64), ReferenceId(72), ReferenceId(82), ReferenceId(87), ReferenceId(89), ReferenceId(96)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(57), ReferenceId(63), ReferenceId(71), ReferenceId(78), ReferenceId(81), ReferenceId(90), ReferenceId(98)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(54), ReferenceId(59), ReferenceId(65), ReferenceId(73), ReferenceId(79), ReferenceId(92), ReferenceId(94)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(28)]
@@ -56475,10 +56475,10 @@ Bindings mismatch:
 after transform: ScopeId(78): ["T", "x"]
 rebuilt        : ScopeId(42): ["x"]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(24), ReferenceId(26), ReferenceId(28), ReferenceId(34), ReferenceId(37), ReferenceId(44), ReferenceId(56), ReferenceId(103), ReferenceId(108), ReferenceId(110), ReferenceId(117), ReferenceId(123), ReferenceId(125), ReferenceId(133), ReferenceId(141), ReferenceId(143), ReferenceId(145), ReferenceId(153), ReferenceId(160), ReferenceId(162), ReferenceId(164), ReferenceId(183), ReferenceId(187), ReferenceId(195), ReferenceId(197), ReferenceId(202), ReferenceId(216), ReferenceId(220), ReferenceId(245)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(24), ReferenceId(26), ReferenceId(28), ReferenceId(34), ReferenceId(37), ReferenceId(44), ReferenceId(55), ReferenceId(103), ReferenceId(108), ReferenceId(110), ReferenceId(117), ReferenceId(123), ReferenceId(125), ReferenceId(133), ReferenceId(141), ReferenceId(143), ReferenceId(145), ReferenceId(153), ReferenceId(160), ReferenceId(162), ReferenceId(164), ReferenceId(183), ReferenceId(187), ReferenceId(195), ReferenceId(197), ReferenceId(202), ReferenceId(216), ReferenceId(220), ReferenceId(245)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(9), ReferenceId(13), ReferenceId(15), ReferenceId(18), ReferenceId(20), ReferenceId(22), ReferenceId(25), ReferenceId(27), ReferenceId(29), ReferenceId(31), ReferenceId(32), ReferenceId(41), ReferenceId(46), ReferenceId(48), ReferenceId(54), ReferenceId(104), ReferenceId(109), ReferenceId(118), ReferenceId(124), ReferenceId(126), ReferenceId(134), ReferenceId(142), ReferenceId(144), ReferenceId(146), ReferenceId(154), ReferenceId(161), ReferenceId(163), ReferenceId(165), ReferenceId(172), ReferenceId(175), ReferenceId(176), ReferenceId(200), ReferenceId(206), ReferenceId(214), ReferenceId(222), ReferenceId(224)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(9), ReferenceId(13), ReferenceId(15), ReferenceId(18), ReferenceId(20), ReferenceId(22), ReferenceId(25), ReferenceId(27), ReferenceId(29), ReferenceId(31), ReferenceId(32), ReferenceId(41), ReferenceId(46), ReferenceId(48), ReferenceId(53), ReferenceId(104), ReferenceId(109), ReferenceId(118), ReferenceId(124), ReferenceId(126), ReferenceId(134), ReferenceId(142), ReferenceId(144), ReferenceId(146), ReferenceId(154), ReferenceId(161), ReferenceId(163), ReferenceId(165), ReferenceId(172), ReferenceId(175), ReferenceId(176), ReferenceId(200), ReferenceId(206), ReferenceId(214), ReferenceId(222), ReferenceId(224)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(39), ReferenceId(204)]
@@ -56560,13 +56560,13 @@ Bindings mismatch:
 after transform: ScopeId(54): ["T", "x"]
 rebuilt        : ScopeId(32): ["x"]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(1): [ReferenceId(0), ReferenceId(2), ReferenceId(4), ReferenceId(6), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(16), ReferenceId(17), ReferenceId(19), ReferenceId(22), ReferenceId(35), ReferenceId(41), ReferenceId(50), ReferenceId(57), ReferenceId(59), ReferenceId(67), ReferenceId(74), ReferenceId(76), ReferenceId(78), ReferenceId(89), ReferenceId(90), ReferenceId(101), ReferenceId(109), ReferenceId(117), ReferenceId(119), ReferenceId(136)]
+after transform: SymbolId(1): [ReferenceId(0), ReferenceId(2), ReferenceId(4), ReferenceId(6), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(16), ReferenceId(17), ReferenceId(19), ReferenceId(22), ReferenceId(33), ReferenceId(39), ReferenceId(50), ReferenceId(57), ReferenceId(59), ReferenceId(67), ReferenceId(74), ReferenceId(76), ReferenceId(78), ReferenceId(89), ReferenceId(90), ReferenceId(101), ReferenceId(109), ReferenceId(117), ReferenceId(119), ReferenceId(136)]
 rebuilt        : SymbolId(2): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(2): [ReferenceId(1), ReferenceId(5), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(26), ReferenceId(32), ReferenceId(51), ReferenceId(58), ReferenceId(68), ReferenceId(75), ReferenceId(77), ReferenceId(79), ReferenceId(86), ReferenceId(97), ReferenceId(113)]
+after transform: SymbolId(2): [ReferenceId(1), ReferenceId(5), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(26), ReferenceId(30), ReferenceId(51), ReferenceId(58), ReferenceId(68), ReferenceId(75), ReferenceId(77), ReferenceId(79), ReferenceId(86), ReferenceId(97), ReferenceId(113)]
 rebuilt        : SymbolId(3): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(3): [ReferenceId(7), ReferenceId(24), ReferenceId(38), ReferenceId(52), ReferenceId(60), ReferenceId(111), ReferenceId(115)]
+after transform: SymbolId(3): [ReferenceId(7), ReferenceId(24), ReferenceId(36), ReferenceId(52), ReferenceId(60), ReferenceId(111), ReferenceId(115)]
 rebuilt        : SymbolId(4): []
 Unresolved references mismatch:
 after transform: ["Array", "foo10", "foo11", "foo12", "foo15", "foo16", "foo17", "foo2", "foo3", "foo7", "foo8"]
@@ -56637,13 +56637,13 @@ Bindings mismatch:
 after transform: ScopeId(46): ["T", "x"]
 rebuilt        : ScopeId(24): ["x"]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(15), ReferenceId(19), ReferenceId(26), ReferenceId(34), ReferenceId(40), ReferenceId(46), ReferenceId(96), ReferenceId(101), ReferenceId(114), ReferenceId(118), ReferenceId(137), ReferenceId(141)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(12), ReferenceId(19), ReferenceId(23), ReferenceId(31), ReferenceId(38), ReferenceId(44), ReferenceId(96), ReferenceId(101), ReferenceId(114), ReferenceId(118), ReferenceId(137), ReferenceId(141)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(13), ReferenceId(30), ReferenceId(37), ReferenceId(97), ReferenceId(103)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(14), ReferenceId(27), ReferenceId(35), ReferenceId(97), ReferenceId(103)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(43)]
+after transform: SymbolId(2): [ReferenceId(41)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignatures.ts
@@ -56672,10 +56672,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7), ScopeId(8), ScopeId(9), ScopeId(10), ScopeId(11), ScopeId(12), ScopeId(13), ScopeId(14), ScopeId(15), ScopeId(16), ScopeId(17), ScopeId(18), ScopeId(19), ScopeId(20), ScopeId(21), ScopeId(22), ScopeId(23), ScopeId(24), ScopeId(25), ScopeId(26), ScopeId(27), ScopeId(28), ScopeId(29), ScopeId(30), ScopeId(31), ScopeId(32), ScopeId(33), ScopeId(36), ScopeId(37), ScopeId(40), ScopeId(41), ScopeId(44), ScopeId(45), ScopeId(52)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(24), ReferenceId(26), ReferenceId(28), ReferenceId(34), ReferenceId(37), ReferenceId(44), ReferenceId(56), ReferenceId(106), ReferenceId(108), ReferenceId(110), ReferenceId(121), ReferenceId(123), ReferenceId(125), ReferenceId(139), ReferenceId(141), ReferenceId(143), ReferenceId(145), ReferenceId(158), ReferenceId(160), ReferenceId(162), ReferenceId(164), ReferenceId(186), ReferenceId(187), ReferenceId(195), ReferenceId(200), ReferenceId(202), ReferenceId(214), ReferenceId(220), ReferenceId(246)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(24), ReferenceId(26), ReferenceId(28), ReferenceId(34), ReferenceId(37), ReferenceId(44), ReferenceId(55), ReferenceId(103), ReferenceId(108), ReferenceId(110), ReferenceId(117), ReferenceId(123), ReferenceId(125), ReferenceId(133), ReferenceId(141), ReferenceId(143), ReferenceId(145), ReferenceId(153), ReferenceId(160), ReferenceId(162), ReferenceId(164), ReferenceId(183), ReferenceId(187), ReferenceId(195), ReferenceId(197), ReferenceId(202), ReferenceId(216), ReferenceId(220), ReferenceId(245)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(9), ReferenceId(13), ReferenceId(15), ReferenceId(18), ReferenceId(20), ReferenceId(22), ReferenceId(25), ReferenceId(27), ReferenceId(29), ReferenceId(31), ReferenceId(32), ReferenceId(41), ReferenceId(46), ReferenceId(48), ReferenceId(54), ReferenceId(107), ReferenceId(109), ReferenceId(122), ReferenceId(124), ReferenceId(126), ReferenceId(140), ReferenceId(142), ReferenceId(144), ReferenceId(146), ReferenceId(159), ReferenceId(161), ReferenceId(163), ReferenceId(165), ReferenceId(174), ReferenceId(175), ReferenceId(176), ReferenceId(198), ReferenceId(206), ReferenceId(218), ReferenceId(222), ReferenceId(224)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(9), ReferenceId(13), ReferenceId(15), ReferenceId(18), ReferenceId(20), ReferenceId(22), ReferenceId(25), ReferenceId(27), ReferenceId(29), ReferenceId(31), ReferenceId(32), ReferenceId(41), ReferenceId(46), ReferenceId(48), ReferenceId(53), ReferenceId(104), ReferenceId(109), ReferenceId(118), ReferenceId(124), ReferenceId(126), ReferenceId(134), ReferenceId(142), ReferenceId(144), ReferenceId(146), ReferenceId(154), ReferenceId(161), ReferenceId(163), ReferenceId(165), ReferenceId(172), ReferenceId(175), ReferenceId(176), ReferenceId(200), ReferenceId(206), ReferenceId(214), ReferenceId(222), ReferenceId(224)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(39), ReferenceId(204)]
@@ -56715,13 +56715,13 @@ Scope children mismatch:
 after transform: ScopeId(36): [ScopeId(37), ScopeId(38), ScopeId(39), ScopeId(40)]
 rebuilt        : ScopeId(6): []
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(1): [ReferenceId(0), ReferenceId(2), ReferenceId(4), ReferenceId(6), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(16), ReferenceId(17), ReferenceId(19), ReferenceId(22), ReferenceId(35), ReferenceId(41), ReferenceId(55), ReferenceId(58), ReferenceId(60), ReferenceId(73), ReferenceId(75), ReferenceId(77), ReferenceId(79), ReferenceId(90), ReferenceId(91), ReferenceId(102), ReferenceId(110), ReferenceId(116), ReferenceId(118), ReferenceId(139)]
+after transform: SymbolId(1): [ReferenceId(0), ReferenceId(2), ReferenceId(4), ReferenceId(6), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(16), ReferenceId(17), ReferenceId(19), ReferenceId(22), ReferenceId(33), ReferenceId(39), ReferenceId(51), ReferenceId(58), ReferenceId(60), ReferenceId(68), ReferenceId(75), ReferenceId(77), ReferenceId(79), ReferenceId(90), ReferenceId(91), ReferenceId(102), ReferenceId(110), ReferenceId(118), ReferenceId(120), ReferenceId(137)]
 rebuilt        : SymbolId(2): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(2): [ReferenceId(1), ReferenceId(5), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(26), ReferenceId(32), ReferenceId(56), ReferenceId(59), ReferenceId(74), ReferenceId(76), ReferenceId(78), ReferenceId(80), ReferenceId(89), ReferenceId(101), ReferenceId(114)]
+after transform: SymbolId(2): [ReferenceId(1), ReferenceId(5), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(26), ReferenceId(30), ReferenceId(52), ReferenceId(59), ReferenceId(69), ReferenceId(76), ReferenceId(78), ReferenceId(80), ReferenceId(87), ReferenceId(98), ReferenceId(114)]
 rebuilt        : SymbolId(3): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(3): [ReferenceId(7), ReferenceId(24), ReferenceId(38), ReferenceId(57), ReferenceId(61), ReferenceId(112), ReferenceId(121)]
+after transform: SymbolId(3): [ReferenceId(7), ReferenceId(24), ReferenceId(36), ReferenceId(53), ReferenceId(61), ReferenceId(112), ReferenceId(116)]
 rebuilt        : SymbolId(4): []
 Unresolved references mismatch:
 after transform: ["Array", "foo10", "foo11", "foo12", "foo15", "foo16", "foo17", "foo2", "foo3", "foo7", "foo8"]
@@ -56735,13 +56735,13 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7), ScopeId(8), ScopeId(9), ScopeId(10), ScopeId(11), ScopeId(12), ScopeId(13), ScopeId(14), ScopeId(15), ScopeId(16), ScopeId(17), ScopeId(18), ScopeId(19), ScopeId(20), ScopeId(21), ScopeId(22), ScopeId(23), ScopeId(26), ScopeId(27), ScopeId(34)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(15), ReferenceId(19), ReferenceId(26), ReferenceId(34), ReferenceId(40), ReferenceId(46), ReferenceId(99), ReferenceId(104), ReferenceId(114), ReferenceId(118), ReferenceId(140), ReferenceId(144)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(12), ReferenceId(19), ReferenceId(23), ReferenceId(31), ReferenceId(38), ReferenceId(44), ReferenceId(96), ReferenceId(101), ReferenceId(114), ReferenceId(118), ReferenceId(137), ReferenceId(141)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(13), ReferenceId(30), ReferenceId(37), ReferenceId(100), ReferenceId(102)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(14), ReferenceId(27), ReferenceId(35), ReferenceId(97), ReferenceId(103)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(43)]
+after transform: SymbolId(2): [ReferenceId(41)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignatures5.ts
@@ -56752,10 +56752,10 @@ Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6), ScopeId(7)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4)]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(56), ReferenceId(62), ReferenceId(70), ReferenceId(77), ReferenceId(85), ReferenceId(87), ReferenceId(92), ReferenceId(94)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3), ReferenceId(5), ReferenceId(6), ReferenceId(8), ReferenceId(10), ReferenceId(12), ReferenceId(14), ReferenceId(16), ReferenceId(18), ReferenceId(20), ReferenceId(24), ReferenceId(26), ReferenceId(32), ReferenceId(53), ReferenceId(58), ReferenceId(64), ReferenceId(72), ReferenceId(82), ReferenceId(87), ReferenceId(89), ReferenceId(96)]
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(57), ReferenceId(63), ReferenceId(71), ReferenceId(78), ReferenceId(81), ReferenceId(90), ReferenceId(98)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(4), ReferenceId(7), ReferenceId(9), ReferenceId(11), ReferenceId(13), ReferenceId(15), ReferenceId(17), ReferenceId(19), ReferenceId(21), ReferenceId(22), ReferenceId(23), ReferenceId(30), ReferenceId(34), ReferenceId(36), ReferenceId(54), ReferenceId(59), ReferenceId(65), ReferenceId(73), ReferenceId(79), ReferenceId(92), ReferenceId(94)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
 after transform: SymbolId(2): [ReferenceId(28)]
@@ -57264,7 +57264,7 @@ Bindings mismatch:
 after transform: ScopeId(20): ["T", "U", "x", "y"]
 rebuilt        : ScopeId(11): ["x", "y"]
 Symbol reference IDs mismatch for "One":
-after transform: SymbolId(0): [ReferenceId(5), ReferenceId(31)]
+after transform: SymbolId(0): [ReferenceId(5), ReferenceId(29)]
 rebuilt        : SymbolId(0): []
 Symbol reference IDs mismatch for "Two":
 after transform: SymbolId(1): [ReferenceId(9), ReferenceId(33), ReferenceId(39), ReferenceId(40), ReferenceId(42), ReferenceId(43), ReferenceId(62), ReferenceId(63), ReferenceId(87), ReferenceId(88), ReferenceId(93), ReferenceId(94), ReferenceId(99), ReferenceId(100), ReferenceId(103), ReferenceId(104)]
@@ -57646,7 +57646,7 @@ Bindings mismatch:
 after transform: ScopeId(18): ["T", "U", "x", "y"]
 rebuilt        : ScopeId(9): ["x", "y"]
 Symbol reference IDs mismatch for "One":
-after transform: SymbolId(0): [ReferenceId(27)]
+after transform: SymbolId(0): [ReferenceId(25)]
 rebuilt        : SymbolId(0): []
 Symbol reference IDs mismatch for "Two":
 after transform: SymbolId(1): [ReferenceId(5), ReferenceId(29), ReferenceId(33), ReferenceId(34), ReferenceId(36), ReferenceId(37), ReferenceId(67), ReferenceId(68), ReferenceId(73), ReferenceId(74), ReferenceId(79), ReferenceId(80), ReferenceId(83), ReferenceId(84)]
@@ -58331,13 +58331,13 @@ Bindings mismatch:
 after transform: ScopeId(17): ["T", "U", "x"]
 rebuilt        : ScopeId(17): ["x"]
 Symbol reference IDs mismatch for "Base":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(5), ReferenceId(12), ReferenceId(17), ReferenceId(22), ReferenceId(29), ReferenceId(56), ReferenceId(61), ReferenceId(90), ReferenceId(118), ReferenceId(121), ReferenceId(124)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(5), ReferenceId(12), ReferenceId(17), ReferenceId(22), ReferenceId(29), ReferenceId(56), ReferenceId(61), ReferenceId(90), ReferenceId(116), ReferenceId(120), ReferenceId(124)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "Derived":
-after transform: SymbolId(1): [ReferenceId(1), ReferenceId(3), ReferenceId(13), ReferenceId(18), ReferenceId(23), ReferenceId(30), ReferenceId(39), ReferenceId(47), ReferenceId(52), ReferenceId(57), ReferenceId(62), ReferenceId(91), ReferenceId(103), ReferenceId(111), ReferenceId(114), ReferenceId(119), ReferenceId(122), ReferenceId(125)]
+after transform: SymbolId(1): [ReferenceId(1), ReferenceId(3), ReferenceId(13), ReferenceId(18), ReferenceId(23), ReferenceId(30), ReferenceId(39), ReferenceId(47), ReferenceId(52), ReferenceId(57), ReferenceId(62), ReferenceId(91), ReferenceId(100), ReferenceId(108), ReferenceId(113), ReferenceId(117), ReferenceId(121), ReferenceId(125)]
 rebuilt        : SymbolId(1): [ReferenceId(1)]
 Symbol reference IDs mismatch for "Derived2":
-after transform: SymbolId(2): [ReferenceId(4), ReferenceId(43), ReferenceId(48), ReferenceId(53), ReferenceId(107), ReferenceId(112), ReferenceId(115)]
+after transform: SymbolId(2): [ReferenceId(4), ReferenceId(43), ReferenceId(48), ReferenceId(53), ReferenceId(104), ReferenceId(109), ReferenceId(114)]
 rebuilt        : SymbolId(2): []
 
 tasks/coverage/typescript/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments3.ts
@@ -58662,13 +58662,13 @@ Scope children mismatch:
 after transform: ScopeId(9): [ScopeId(10), ScopeId(12)]
 rebuilt        : ScopeId(9): []
 Symbol reference IDs mismatch for "C":
-after transform: SymbolId(0): [ReferenceId(8), ReferenceId(18), ReferenceId(19), ReferenceId(40), ReferenceId(50), ReferenceId(56)]
+after transform: SymbolId(0): [ReferenceId(8), ReferenceId(18), ReferenceId(19), ReferenceId(40), ReferenceId(50), ReferenceId(51)]
 rebuilt        : SymbolId(0): []
 Symbol reference IDs mismatch for "D":
 after transform: SymbolId(1): [ReferenceId(10), ReferenceId(27), ReferenceId(42), ReferenceId(58)]
 rebuilt        : SymbolId(1): []
 Symbol reference IDs mismatch for "X":
-after transform: SymbolId(2): [ReferenceId(1), ReferenceId(3), ReferenceId(7), ReferenceId(9), ReferenceId(20), ReferenceId(22), ReferenceId(34), ReferenceId(36), ReferenceId(39), ReferenceId(41), ReferenceId(51), ReferenceId(53)]
+after transform: SymbolId(2): [ReferenceId(1), ReferenceId(3), ReferenceId(7), ReferenceId(9), ReferenceId(20), ReferenceId(22), ReferenceId(34), ReferenceId(36), ReferenceId(39), ReferenceId(41), ReferenceId(52), ReferenceId(54)]
 rebuilt        : SymbolId(2): [ReferenceId(1), ReferenceId(2), ReferenceId(18), ReferenceId(19)]
 Symbol reference IDs mismatch for "G":
 after transform: SymbolId(5): [ReferenceId(11)]
diff --git a/tasks/transform_conformance/snapshots/babel.snap.md b/tasks/transform_conformance/snapshots/babel.snap.md
index 8d878e09a434f..03d01105d3653 100644
--- a/tasks/transform_conformance/snapshots/babel.snap.md
+++ b/tasks/transform_conformance/snapshots/babel.snap.md
@@ -2296,7 +2296,7 @@ Bindings mismatch:
 after transform: ScopeId(1): ["M"]
 rebuilt        : ScopeId(1): []
 Symbol reference IDs mismatch for "AbstractClass":
-after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(3)]
+after transform: SymbolId(0): [ReferenceId(0), ReferenceId(1), ReferenceId(3)]
 rebuilt        : SymbolId(0): [ReferenceId(0)]
 Symbol reference IDs mismatch for "ConcreteClass":
 after transform: SymbolId(2): [ReferenceId(4), ReferenceId(6)]

From e81181261dcbe75adc7e2d1604e5659da5bebaaa Mon Sep 17 00:00:00 2001
From: dalaoshu <laipichan@qq.com>
Date: Fri, 11 Oct 2024 21:16:17 +0800
Subject: [PATCH 20/24] fix(linter): error diagnostic message based on
 parameter length of valid-expect (#6455)

---
 .../oxc_linter/src/rules/jest/valid_expect.rs | 12 ++--
 .../src/snapshots/valid_expect.snap           | 68 +++++++++----------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/crates/oxc_linter/src/rules/jest/valid_expect.rs b/crates/oxc_linter/src/rules/jest/valid_expect.rs
index 711a6e7cab513..be2923a731d75 100644
--- a/crates/oxc_linter/src/rules/jest/valid_expect.rs
+++ b/crates/oxc_linter/src/rules/jest/valid_expect.rs
@@ -159,21 +159,21 @@ impl ValidExpect {
             return;
         };
 
-        if call_expr.arguments.len() < self.min_args {
+        if call_expr.arguments.len() > self.max_args {
             let error = format!(
                 "Expect takes at most {} argument{} ",
-                self.min_args,
-                if self.min_args > 1 { "s" } else { "" }
+                self.max_args,
+                if self.max_args > 1 { "s" } else { "" }
             );
             let help = "Remove the extra arguments.";
             ctx.diagnostic(valid_expect_diagnostic(error, help, call_expr.span));
             return;
         }
-        if call_expr.arguments.len() > self.max_args {
+        if call_expr.arguments.len() < self.min_args {
             let error = format!(
                 "Expect requires at least {} argument{} ",
-                self.max_args,
-                if self.max_args > 1 { "s" } else { "" }
+                self.min_args,
+                if self.min_args > 1 { "s" } else { "" }
             );
             let help = "Add the missing arguments.";
             ctx.diagnostic(valid_expect_diagnostic(error, help, call_expr.span));
diff --git a/crates/oxc_linter/src/snapshots/valid_expect.snap b/crates/oxc_linter/src/snapshots/valid_expect.snap
index 4e2f9791f5727..7ac7d89bc3f1c 100644
--- a/crates/oxc_linter/src/snapshots/valid_expect.snap
+++ b/crates/oxc_linter/src/snapshots/valid_expect.snap
@@ -1,63 +1,63 @@
 ---
 source: crates/oxc_linter/src/tester.rs
 ---
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toBe(2);
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toBe(true);
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toEqual('something');
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something', 'else').toEqual('something');
    · ───────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something', 'else', 'entirely').toEqual('something');
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something', 'else', 'entirely').toEqual('something');
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something', 'else', 'entirely').toEqual('something');
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something').toEqual('something');
    · ───────────────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 3 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect('something', 'else').toEqual('something');
    · ───────────────────────────
@@ -498,63 +498,63 @@ source: crates/oxc_linter/src/tester.rs
    ╰────
   help: Did you forget add a matcher(e.g. `toBe`, `toBeDefined`)
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toBe(2);
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toBe(true);
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect().toEqual("something");
    · ────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 1 argument
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something", "else").toEqual("something");
    · ───────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something", "else", "entirely").toEqual("something");
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something", "else", "entirely").toEqual("something");
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something", "else", "entirely").toEqual("something");
    · ───────────────────────────────────────
    ╰────
-  help: Add the missing arguments.
+  help: Remove the extra arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 2 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect requires at least 2 arguments
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something").toEqual("something");
    · ───────────────────
    ╰────
-  help: Remove the extra arguments.
+  help: Add the missing arguments.
 
-  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 3 arguments
+  ⚠ eslint-plugin-vitest(valid-expect): Expect takes at most 1 argument
    ╭─[valid_expect.tsx:1:1]
  1 │ expect("something", "else").toEqual("something");
    · ───────────────────────────

From 3677ef81e94757ab991451c715136ebe15cd2f5e Mon Sep 17 00:00:00 2001
From: 7086cmd <54303040+7086cmd@users.noreply.github.com>
Date: Fri, 11 Oct 2024 13:40:44 +0000
Subject: [PATCH 21/24] feat(minifier): dce ExpressionStatements with no side
 effect (#6457)

Not sure about the performance. Just have a try.
---
 .../ast_passes/peephole_remove_dead_code.rs   | 54 +++++++++++++++++++
 .../src/node_util/is_literal_value.rs         |  3 +-
 .../tests/ast_passes/dead_code_elimination.rs |  2 +-
 3 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
index 9852ed60348ba..f62ed6a008ab7 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_remove_dead_code.rs
@@ -3,6 +3,7 @@ use oxc_ast::{ast::*, Visit};
 use oxc_span::SPAN;
 use oxc_traverse::{Ancestor, Traverse, TraverseCtx};
 
+use crate::node_util::IsLiteralValue;
 use crate::{keep_var::KeepVar, node_util::NodeUtil, tri::Tri, CompressorPass};
 
 /// Remove Dead Code from the AST.
@@ -31,6 +32,9 @@ impl<'a> Traverse<'a> for PeepholeRemoveDeadCode {
         if let Some(new_stmt) = match stmt {
             Statement::IfStatement(if_stmt) => self.try_fold_if(if_stmt, ctx),
             Statement::ForStatement(for_stmt) => self.try_fold_for(for_stmt, ctx),
+            Statement::ExpressionStatement(expr_stmt) => {
+                Self::try_fold_expression_stmt(expr_stmt, ctx)
+            }
             _ => None,
         } {
             *stmt = new_stmt;
@@ -192,6 +196,27 @@ impl<'a> PeepholeRemoveDeadCode {
         }
     }
 
+    fn try_fold_expression_stmt(
+        stmt: &mut ExpressionStatement<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) -> Option<Statement<'a>> {
+        // We need to check if it is in arrow function with `expression: true`.
+        // This is the only scenario where we can't remove it even if `ExpressionStatement`.
+        // TODO find a better way to handle this.
+
+        stmt.expression
+            .is_literal_value(false)
+            .then(|| {
+                if let Ancestor::ArrowFunctionExpressionBody(body) = ctx.ancestry.ancestor(1) {
+                    if *body.expression() {
+                        return None;
+                    }
+                }
+                Some(ctx.ast.statement_empty(SPAN))
+            })
+            .unwrap_or(None)
+    }
+
     /// Try folding conditional expression (?:) if the condition results of the condition is known.
     fn try_fold_conditional_expression(
         expr: &mut ConditionalExpression<'a>,
@@ -290,4 +315,33 @@ mod test {
         fold("for(;undefined;) foo()", "");
         fold("for(;'';) foo()", "");
     }
+
+    #[test]
+    fn test_object_literal() {
+        fold("({})", "");
+        fold("({a:1})", "");
+        // fold("({a:foo()})", "foo()");
+        // fold("({'a':foo()})", "foo()");
+        // Object-spread may trigger getters.
+        fold_same("({...a})");
+        fold_same("({...foo()})");
+    }
+
+    #[test]
+    fn test_array_literal() {
+        fold("([])", "");
+        fold("([1])", "");
+        // fold("([a])", "a");
+        // fold("([foo()])", "foo()");
+    }
+
+    #[test]
+    #[ignore]
+    fn test_array_literal_containing_spread() {
+        fold_same("([...c])");
+        fold("([4, ...c, a])", "([...c])");
+        fold("([foo(), ...c, bar()])", "(foo(), [...c], bar())");
+        fold("([...a, b, ...c])", "([...a], [...c])");
+        fold_same("([...b, ...c])"); // It would also be fine if the spreads were split apart.
+    }
 }
diff --git a/crates/oxc_minifier/src/node_util/is_literal_value.rs b/crates/oxc_minifier/src/node_util/is_literal_value.rs
index 996a02ed4f31c..78a830e2d62de 100644
--- a/crates/oxc_minifier/src/node_util/is_literal_value.rs
+++ b/crates/oxc_minifier/src/node_util/is_literal_value.rs
@@ -66,7 +66,8 @@ impl<'a, 'b> IsLiteralValue<'a, 'b> for ObjectProperty<'a> {
 impl<'a, 'b> IsLiteralValue<'a, 'b> for PropertyKey<'a> {
     fn is_literal_value(&self, include_functions: bool) -> bool {
         match self {
-            Self::StaticIdentifier(_) | Self::PrivateIdentifier(_) => false,
+            Self::StaticIdentifier(_) => true,
+            Self::PrivateIdentifier(_) => false,
             match_expression!(Self) => self.to_expression().is_literal_value(include_functions),
         }
     }
diff --git a/crates/oxc_minifier/tests/ast_passes/dead_code_elimination.rs b/crates/oxc_minifier/tests/ast_passes/dead_code_elimination.rs
index fc5e9975cfdac..e030cd6997cf8 100644
--- a/crates/oxc_minifier/tests/ast_passes/dead_code_elimination.rs
+++ b/crates/oxc_minifier/tests/ast_passes/dead_code_elimination.rs
@@ -112,7 +112,7 @@ fn dce_conditional_expression() {
 
 #[test]
 fn dce_logical_expression() {
-    test("false && bar()", "false");
+    test("false && bar()", "");
     test("true && bar()", "bar()");
 
     test("const foo = false && bar()", "const foo = false");

From 7645e5c34ba16afd02b13c694a6ec41a2586dd79 Mon Sep 17 00:00:00 2001
From: Boshen <1430279+Boshen@users.noreply.github.com>
Date: Fri, 11 Oct 2024 13:53:28 +0000
Subject: [PATCH 22/24] refactor(codegen)!: remove CommentOptions API (#6451)

---
 crates/oxc/src/compiler.rs                    |   8 +-
 crates/oxc_codegen/examples/codegen.rs        |   3 +-
 crates/oxc_codegen/src/comment.rs             |  53 ++++-----
 crates/oxc_codegen/src/gen.rs                 |  11 +-
 crates/oxc_codegen/src/lib.rs                 | 109 ++++++++----------
 crates/oxc_codegen/tests/integration/main.rs  |   3 +-
 .../oxc_codegen/tests/integration/tester.rs   |   7 +-
 .../examples/isolated_declarations.rs         |   7 +-
 crates/oxc_isolated_declarations/tests/mod.rs |   7 +-
 crates/oxc_linter/src/fixer/mod.rs            |   1 -
 napi/minify/src/lib.rs                        |   1 -
 napi/transform/src/isolated_declaration.rs    |   5 +-
 tasks/transform_conformance/src/driver.rs     |  18 +--
 tasks/transform_conformance/src/test_case.rs  |  16 +--
 14 files changed, 100 insertions(+), 149 deletions(-)

diff --git a/crates/oxc/src/compiler.rs b/crates/oxc/src/compiler.rs
index a0c30aea74920..8e789d05b36f7 100644
--- a/crates/oxc/src/compiler.rs
+++ b/crates/oxc/src/compiler.rs
@@ -2,7 +2,7 @@ use std::{mem, ops::ControlFlow, path::Path};
 
 use oxc_allocator::Allocator;
 use oxc_ast::ast::Program;
-use oxc_codegen::{CodeGenerator, CodegenOptions, CodegenReturn, CommentOptions};
+use oxc_codegen::{CodeGenerator, CodegenOptions, CodegenReturn};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_isolated_declarations::{IsolatedDeclarations, IsolatedDeclarationsOptions};
 use oxc_mangler::{MangleOptions, Mangler};
@@ -283,11 +283,7 @@ pub trait CompilerInterface {
         mangler: Option<Mangler>,
         options: CodegenOptions,
     ) -> CodegenReturn {
-        let comment_options = CommentOptions { preserve_annotate_comments: true };
-        let mut codegen = CodeGenerator::new()
-            .with_options(options)
-            .with_mangler(mangler)
-            .enable_comment(program, comment_options);
+        let mut codegen = CodeGenerator::new().with_options(options).with_mangler(mangler);
         if self.enable_sourcemap() {
             codegen = codegen
                 .enable_source_map(source_path.to_string_lossy().as_ref(), program.source_text);
diff --git a/crates/oxc_codegen/examples/codegen.rs b/crates/oxc_codegen/examples/codegen.rs
index 895a7f3eeb41d..3edfcfbaabf37 100644
--- a/crates/oxc_codegen/examples/codegen.rs
+++ b/crates/oxc_codegen/examples/codegen.rs
@@ -2,7 +2,7 @@
 use std::{env, path::Path};
 
 use oxc_allocator::Allocator;
-use oxc_codegen::{CodeGenerator, CodegenOptions, CommentOptions};
+use oxc_codegen::{CodeGenerator, CodegenOptions};
 use oxc_parser::{Parser, ParserReturn};
 use oxc_span::SourceType;
 use pico_args::Arguments;
@@ -61,7 +61,6 @@ fn parse<'a>(
 
 fn codegen(ret: &ParserReturn<'_>, minify: bool) -> String {
     CodeGenerator::new()
-        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
         .with_options(CodegenOptions { minify, ..CodegenOptions::default() })
         .build(&ret.program)
         .code
diff --git a/crates/oxc_codegen/src/comment.rs b/crates/oxc_codegen/src/comment.rs
index 389b0ad55ad5d..d24f4c4b94316 100644
--- a/crates/oxc_codegen/src/comment.rs
+++ b/crates/oxc_codegen/src/comment.rs
@@ -16,10 +16,6 @@ static ANNOTATION_MATCHER: Lazy<DoubleArrayAhoCorasick<usize>> = Lazy::new(|| {
 pub(crate) type CommentsMap = FxHashMap</* attached_to */ u32, Vec<Comment>>;
 
 impl<'a> Codegen<'a> {
-    pub(crate) fn preserve_annotate_comments(&self) -> bool {
-        self.comment_options.preserve_annotate_comments && !self.options.minify
-    }
-
     pub(crate) fn build_comments(&mut self, comments: &[Comment]) {
         for comment in comments {
             self.comments.entry(comment.attached_to).or_default().push(*comment);
@@ -31,35 +27,33 @@ impl<'a> Codegen<'a> {
     }
 
     pub(crate) fn has_annotation_comment(&self, start: u32) -> bool {
-        if !self.preserve_annotate_comments() {
+        if !self.options.print_annotation_comments() {
             return false;
         }
-        let Some(source_text) = self.source_text else { return false };
         self.comments.get(&start).is_some_and(|comments| {
-            comments.iter().any(|comment| Self::is_annotation_comment(comment, source_text))
+            comments.iter().any(|comment| self.is_annotation_comment(comment))
         })
     }
 
     pub(crate) fn has_non_annotation_comment(&self, start: u32) -> bool {
-        if !self.preserve_annotate_comments() {
+        if !self.options.print_annotation_comments() {
             return self.has_comment(start);
         }
-        let Some(source_text) = self.source_text else { return false };
         self.comments.get(&start).is_some_and(|comments| {
-            comments.iter().any(|comment| !Self::is_annotation_comment(comment, source_text))
+            comments.iter().any(|comment| !self.is_annotation_comment(comment))
         })
     }
 
     /// Weather to keep leading comments.
-    fn is_leading_comments(comment: &Comment, source_text: &str) -> bool {
-        (comment.is_jsdoc(source_text) || (comment.is_line() && Self::is_annotation_comment(comment, source_text)))
+    fn is_leading_comments(&self, comment: &Comment) -> bool {
+        (comment.is_jsdoc(self.source_text) || (comment.is_line() && self.is_annotation_comment(comment)))
             && comment.preceded_by_newline
             // webpack comment `/*****/`
-            && !comment.span.source_text(source_text).chars().all(|c| c == '*')
+            && !comment.span.source_text(self.source_text).chars().all(|c| c == '*')
     }
 
-    fn print_comment(&mut self, comment: &Comment, source_text: &str) {
-        let comment_source = comment.real_span().source_text(source_text);
+    fn print_comment(&mut self, comment: &Comment) {
+        let comment_source = comment.real_span().source_text(self.source_text);
         match comment.kind {
             CommentKind::Line => {
                 self.print_str(comment_source);
@@ -84,14 +78,12 @@ impl<'a> Codegen<'a> {
         if self.options.minify {
             return;
         }
-        let Some(source_text) = self.source_text else { return };
         let Some(comments) = self.comments.remove(&start) else {
             return;
         };
 
-        let (comments, unused_comments): (Vec<_>, Vec<_>) = comments
-            .into_iter()
-            .partition(|comment| Self::is_leading_comments(comment, source_text));
+        let (comments, unused_comments): (Vec<_>, Vec<_>) =
+            comments.into_iter().partition(|comment| self.is_leading_comments(comment));
 
         if comments.first().is_some_and(|c| c.preceded_by_newline) {
             // Skip printing newline if this comment is already on a newline.
@@ -107,7 +99,7 @@ impl<'a> Codegen<'a> {
                 self.print_indent();
             }
 
-            self.print_comment(comment, source_text);
+            self.print_comment(comment);
         }
 
         if comments.last().is_some_and(|c| c.is_line() || c.followed_by_newline) {
@@ -120,32 +112,31 @@ impl<'a> Codegen<'a> {
         }
     }
 
-    fn is_annotation_comment(comment: &Comment, source_text: &str) -> bool {
-        let comment_content = comment.span.source_text(source_text);
+    fn is_annotation_comment(&self, comment: &Comment) -> bool {
+        let comment_content = comment.span.source_text(self.source_text);
         ANNOTATION_MATCHER.find_iter(comment_content).count() != 0
     }
 
     pub(crate) fn print_annotation_comments(&mut self, node_start: u32) {
-        if !self.preserve_annotate_comments() {
+        if !self.options.print_annotation_comments() {
             return;
         }
 
         // If there is has annotation comments awaiting move to here, print them.
         let start = self.start_of_annotation_comment.take().unwrap_or(node_start);
 
-        let Some(source_text) = self.source_text else { return };
         let Some(comments) = self.comments.remove(&start) else { return };
 
         for comment in comments {
-            if !Self::is_annotation_comment(&comment, source_text) {
+            if !self.is_annotation_comment(&comment) {
                 continue;
             }
             if comment.is_line() {
                 self.print_str("/*");
-                self.print_str(comment.span.source_text(source_text));
+                self.print_str(comment.span.source_text(self.source_text));
                 self.print_str("*/");
             } else {
-                self.print_str(comment.real_span().source_text(source_text));
+                self.print_str(comment.real_span().source_text(self.source_text));
             }
             self.print_hard_space();
         }
@@ -155,12 +146,10 @@ impl<'a> Codegen<'a> {
         if self.options.minify {
             return false;
         }
-        let Some(source_text) = self.source_text else { return false };
         let Some(comments) = self.comments.remove(&start) else { return false };
 
-        let (annotation_comments, comments): (Vec<_>, Vec<_>) = comments
-            .into_iter()
-            .partition(|comment| Self::is_annotation_comment(comment, source_text));
+        let (annotation_comments, comments): (Vec<_>, Vec<_>) =
+            comments.into_iter().partition(|comment| self.is_annotation_comment(comment));
 
         if !annotation_comments.is_empty() {
             self.comments.insert(start, annotation_comments);
@@ -169,7 +158,7 @@ impl<'a> Codegen<'a> {
         for comment in &comments {
             self.print_hard_newline();
             self.print_indent();
-            self.print_comment(comment, source_text);
+            self.print_comment(comment);
         }
 
         if comments.is_empty() {
diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs
index a815a3c01880a..4dd193eb2a978 100644
--- a/crates/oxc_codegen/src/gen.rs
+++ b/crates/oxc_codegen/src/gen.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, ops::Not};
+use std::ops::Not;
 
 use cow_utils::CowUtils;
 #[allow(clippy::wildcard_imports)]
@@ -558,7 +558,7 @@ impl<'a> Gen for VariableDeclaration<'a> {
             p.print_str("declare ");
         }
 
-        if p.preserve_annotate_comments()
+        if p.options.print_annotation_comments()
             && p.start_of_annotation_comment.is_none()
             && matches!(self.kind, VariableDeclarationKind::Const)
             && matches!(self.declarations.first(), Some(VariableDeclarator { init: Some(init), .. }) if init.is_function())
@@ -825,7 +825,7 @@ impl<'a> Gen for ExportNamedDeclaration<'a> {
         p.add_source_mapping(self.span.start);
         p.print_indent();
 
-        if p.preserve_annotate_comments() {
+        if p.options.print_annotation_comments() {
             match &self.declaration {
                 Some(Declaration::FunctionDeclaration(_)) => {
                     p.print_annotation_comments(self.span.start);
@@ -1195,10 +1195,7 @@ impl<'a> Gen for RegExpLiteral<'a> {
     fn gen(&self, p: &mut Codegen, _ctx: Context) {
         p.add_source_mapping(self.span.start);
         let last = p.peek_nth(0);
-        let pattern_text = p.source_text.map_or_else(
-            || Cow::Owned(self.regex.pattern.to_string()),
-            |src| self.regex.pattern.source_text(src),
-        );
+        let pattern_text = self.regex.pattern.source_text(p.source_text);
         // Avoid forming a single-line comment or "</script" sequence
         if Some('/') == last
             || (Some('<') == last && pattern_text.cow_to_lowercase().starts_with("script"))
diff --git a/crates/oxc_codegen/src/lib.rs b/crates/oxc_codegen/src/lib.rs
index 8fc7f1d2f67f8..fc0a1f83f633f 100644
--- a/crates/oxc_codegen/src/lib.rs
+++ b/crates/oxc_codegen/src/lib.rs
@@ -35,7 +35,7 @@ pub use crate::{
 /// Code generator without whitespace removal.
 pub type CodeGenerator<'a> = Codegen<'a>;
 
-#[derive(Default, Clone, Copy)]
+#[derive(Clone, Copy)]
 pub struct CodegenOptions {
     /// Use single quotes instead of double quotes.
     ///
@@ -46,47 +46,49 @@ pub struct CodegenOptions {
     ///
     /// Default is `false`.
     pub minify: bool,
+
+    /// Print comments?
+    ///
+    /// Default is `true`.
+    pub comments: bool,
+
+    /// Print annotation comments, e.g. `/* #__PURE__ */` and `/* #__NO_SIDE_EFFECTS__ */`.
+    ///
+    /// Only takes into effect when `comments` is false.
+    ///
+    /// Default is `false`.
+    pub annotation_comments: bool,
+}
+
+impl Default for CodegenOptions {
+    fn default() -> Self {
+        Self { single_quote: false, minify: false, comments: true, annotation_comments: false }
+    }
 }
 
-#[derive(Default, Clone, Copy)]
-pub struct CommentOptions {
-    /// Enable preserve annotate comments, like `/* #__PURE__ */` and `/* #__NO_SIDE_EFFECTS__ */`.
-    pub preserve_annotate_comments: bool,
+impl CodegenOptions {
+    fn print_annotation_comments(self) -> bool {
+        !self.minify && (self.comments || self.annotation_comments)
+    }
 }
 
 /// Output from [`Codegen::build`]
 pub struct CodegenReturn {
     /// The generated source code.
     pub code: String,
+
     /// The source map from the input source code to the generated source code.
-    ///
-    /// You must use [`Codegen::enable_source_map`] for this to be [`Some`].
     pub map: Option<oxc_sourcemap::SourceMap>,
 }
 
 pub struct Codegen<'a> {
-    options: CodegenOptions,
-    comment_options: CommentOptions,
+    pub(crate) options: CodegenOptions,
 
     /// Original source code of the AST
-    source_text: Option<&'a str>,
+    source_text: &'a str,
 
     comments: CommentsMap,
 
-    /// Start of comment that needs to be moved to the before VariableDeclarator
-    ///
-    /// For example:
-    /// ```js
-    ///  /* @__NO_SIDE_EFFECTS__ */ export const a = function() {
-    ///  }, b = 10000;
-    /// ```
-    /// Should be generated as:
-    /// ```js
-    ///   export const /* @__NO_SIDE_EFFECTS__ */ a = function() {
-    ///  }, b = 10000;
-    /// ```
-    start_of_annotation_comment: Option<u32>,
-
     mangler: Option<Mangler>,
 
     /// Output Code
@@ -107,6 +109,19 @@ pub struct Codegen<'a> {
     start_of_stmt: usize,
     start_of_arrow_expr: usize,
     start_of_default_export: usize,
+    /// Start of comment that needs to be moved to the before VariableDeclarator
+    ///
+    /// For example:
+    /// ```js
+    ///  /* @__NO_SIDE_EFFECTS__ */ export const a = function() {
+    ///  }, b = 10000;
+    /// ```
+    /// Should be generated as:
+    /// ```js
+    ///   export const /* @__NO_SIDE_EFFECTS__ */ a = function() {
+    ///  }, b = 10000;
+    /// ```
+    start_of_annotation_comment: Option<u32>,
 
     /// Track the current indentation level
     indent: u32,
@@ -142,8 +157,7 @@ impl<'a> Codegen<'a> {
     pub fn new() -> Self {
         Self {
             options: CodegenOptions::default(),
-            comment_options: CommentOptions::default(),
-            source_text: None,
+            source_text: "",
             comments: CommentsMap::default(),
             start_of_annotation_comment: None,
             mangler: None,
@@ -164,44 +178,13 @@ impl<'a> Codegen<'a> {
         }
     }
 
-    /// Initialize the output code buffer to reduce memory reallocation.
-    /// Minification will reduce by at least half of the original size.
-    #[must_use]
-    pub fn with_capacity(mut self, source_text_len: usize) -> Self {
-        let capacity = if self.options.minify { source_text_len / 2 } else { source_text_len };
-        // ensure space for at least `capacity` additional bytes without clobbering existing
-        // allocations.
-        self.code.reserve(capacity);
-        self
-    }
-
     #[must_use]
     pub fn with_options(mut self, options: CodegenOptions) -> Self {
-        self.options = options;
         self.quote = if options.single_quote { b'\'' } else { b'"' };
+        self.options = options;
         self
     }
 
-    /// Adds the source text of the original AST.
-    ///
-    /// The source code will be used with comments or for improving the generated output. It also
-    /// pre-allocates memory for the output code using [`Codegen::with_capacity`]. Note that if you
-    /// use this method alongside your own call to [`Codegen::with_capacity`], the larger of the
-    /// two will be used.
-    #[must_use]
-    pub fn with_source_text(mut self, source_text: &'a str) -> Self {
-        self.source_text = Some(source_text);
-        self.with_capacity(source_text.len())
-    }
-
-    /// Also sets the [Self::with_source_text]
-    #[must_use]
-    pub fn enable_comment(mut self, program: &Program<'a>, options: CommentOptions) -> Self {
-        self.comment_options = options;
-        self.build_comments(&program.comments);
-        self.with_source_text(program.source_text)
-    }
-
     #[must_use]
     pub fn enable_source_map(mut self, source_name: &str, source_text: &str) -> Self {
         let mut sourcemap_builder = SourcemapBuilder::default();
@@ -217,7 +200,14 @@ impl<'a> Codegen<'a> {
     }
 
     #[must_use]
-    pub fn build(mut self, program: &Program<'_>) -> CodegenReturn {
+    pub fn build(mut self, program: &Program<'a>) -> CodegenReturn {
+        self.quote = if self.options.single_quote { b'\'' } else { b'"' };
+        self.source_text = program.source_text;
+        self.code.reserve(program.source_text.len());
+        if self.options.print_annotation_comments() {
+            self.build_comments(&program.comments);
+        }
+
         program.print(&mut self, Context::default());
         let code = self.into_source_text();
         let map = self.sourcemap_builder.map(SourcemapBuilder::into_sourcemap);
@@ -227,7 +217,6 @@ impl<'a> Codegen<'a> {
     #[must_use]
     pub fn into_source_text(&mut self) -> String {
         // SAFETY: criteria of `from_utf8_unchecked` are met.
-
         unsafe { String::from_utf8_unchecked(std::mem::take(&mut self.code)) }
     }
 
diff --git a/crates/oxc_codegen/tests/integration/main.rs b/crates/oxc_codegen/tests/integration/main.rs
index 21e6e641aaa75..b2c5c4f9f15c1 100644
--- a/crates/oxc_codegen/tests/integration/main.rs
+++ b/crates/oxc_codegen/tests/integration/main.rs
@@ -7,7 +7,7 @@ pub mod ts;
 pub mod unit;
 
 use oxc_allocator::Allocator;
-use oxc_codegen::{CodeGenerator, CodegenOptions, CommentOptions};
+use oxc_codegen::{CodeGenerator, CodegenOptions};
 use oxc_parser::Parser;
 use oxc_span::SourceType;
 
@@ -17,7 +17,6 @@ pub fn codegen(source_text: &str) -> String {
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
-        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
         .build(&ret.program)
         .code
 }
diff --git a/crates/oxc_codegen/tests/integration/tester.rs b/crates/oxc_codegen/tests/integration/tester.rs
index e6460fd82af45..5f8d8a3993171 100644
--- a/crates/oxc_codegen/tests/integration/tester.rs
+++ b/crates/oxc_codegen/tests/integration/tester.rs
@@ -1,5 +1,5 @@
 use oxc_allocator::Allocator;
-use oxc_codegen::{CodeGenerator, CodegenOptions, CommentOptions};
+use oxc_codegen::{CodeGenerator, CodegenOptions};
 use oxc_parser::Parser;
 use oxc_span::SourceType;
 
@@ -7,10 +7,7 @@ pub fn test(source_text: &str, expected: &str) {
     let source_type = SourceType::jsx();
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let result = CodeGenerator::new()
-        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: true })
-        .build(&ret.program)
-        .code;
+    let result = CodeGenerator::new().build(&ret.program).code;
     assert_eq!(result, expected, "\nfor source: {source_text:?}");
 }
 
diff --git a/crates/oxc_isolated_declarations/examples/isolated_declarations.rs b/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
index 2074fcb19d820..ce354f662ae42 100644
--- a/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
+++ b/crates/oxc_isolated_declarations/examples/isolated_declarations.rs
@@ -2,7 +2,7 @@
 use std::{env, path::Path};
 
 use oxc_allocator::Allocator;
-use oxc_codegen::{CodeGenerator, CommentOptions};
+use oxc_codegen::CodeGenerator;
 use oxc_isolated_declarations::{IsolatedDeclarations, IsolatedDeclarationsOptions};
 use oxc_parser::Parser;
 use oxc_span::SourceType;
@@ -35,10 +35,7 @@ fn main() {
     let id_ret =
         IsolatedDeclarations::new(&allocator, IsolatedDeclarationsOptions { strip_internal: true })
             .build(&ret.program);
-    let printed = CodeGenerator::new()
-        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: false })
-        .build(&id_ret.program)
-        .code;
+    let printed = CodeGenerator::new().build(&id_ret.program).code;
 
     println!("Dts Emit:\n");
     println!("{printed}\n");
diff --git a/crates/oxc_isolated_declarations/tests/mod.rs b/crates/oxc_isolated_declarations/tests/mod.rs
index dc0f18e6ca9e7..7c3d2b184cc0b 100644
--- a/crates/oxc_isolated_declarations/tests/mod.rs
+++ b/crates/oxc_isolated_declarations/tests/mod.rs
@@ -3,7 +3,7 @@ mod deno;
 use std::{fs, path::Path, sync::Arc};
 
 use oxc_allocator::Allocator;
-use oxc_codegen::{CodeGenerator, CommentOptions};
+use oxc_codegen::CodeGenerator;
 use oxc_isolated_declarations::{IsolatedDeclarations, IsolatedDeclarationsOptions};
 use oxc_parser::Parser;
 use oxc_span::SourceType;
@@ -16,10 +16,7 @@ fn transform(path: &Path, source_text: &str) -> String {
     let id_ret =
         IsolatedDeclarations::new(&allocator, IsolatedDeclarationsOptions { strip_internal: true })
             .build(&parser_ret.program);
-    let code = CodeGenerator::new()
-        .enable_comment(&parser_ret.program, CommentOptions { preserve_annotate_comments: false })
-        .build(&id_ret.program)
-        .code;
+    let code = CodeGenerator::new().build(&id_ret.program).code;
 
     let mut snapshot =
         format!("```\n==================== .D.TS ====================\n\n{code}\n\n");
diff --git a/crates/oxc_linter/src/fixer/mod.rs b/crates/oxc_linter/src/fixer/mod.rs
index 2c51081a2719e..df16517e394dd 100644
--- a/crates/oxc_linter/src/fixer/mod.rs
+++ b/crates/oxc_linter/src/fixer/mod.rs
@@ -170,7 +170,6 @@ impl<'c, 'a: 'c> RuleFixer<'c, 'a> {
     #[allow(clippy::unused_self)]
     pub fn codegen(self) -> CodeGenerator<'a> {
         CodeGenerator::new()
-            .with_source_text(self.source_text())
             .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
     }
 
diff --git a/napi/minify/src/lib.rs b/napi/minify/src/lib.rs
index 550785a5e69a0..61156f360f351 100644
--- a/napi/minify/src/lib.rs
+++ b/napi/minify/src/lib.rs
@@ -22,7 +22,6 @@ pub fn minify(filename: String, source_text: String) -> String {
     Codegen::new()
         .with_options(CodegenOptions { minify: true, ..CodegenOptions::default() })
         .with_mangler(mangler)
-        .with_capacity(source_text.len())
         .build(&program)
         .code
 }
diff --git a/napi/transform/src/isolated_declaration.rs b/napi/transform/src/isolated_declaration.rs
index 72867b8200858..89645cebcfea0 100644
--- a/napi/transform/src/isolated_declaration.rs
+++ b/napi/transform/src/isolated_declaration.rs
@@ -4,7 +4,7 @@ use napi_derive::napi;
 
 use oxc::{
     allocator::Allocator,
-    codegen::{CodeGenerator, CommentOptions},
+    codegen::CodeGenerator,
     isolated_declarations::IsolatedDeclarations,
     napi::{
         isolated_declarations::{IsolatedDeclarationsOptions, IsolatedDeclarationsResult},
@@ -39,8 +39,7 @@ pub fn isolated_declaration(
     )
     .build(&ret.program);
 
-    let mut codegen = CodeGenerator::new()
-        .enable_comment(&ret.program, CommentOptions { preserve_annotate_comments: false });
+    let mut codegen = CodeGenerator::new();
     if options.sourcemap == Some(true) {
         codegen = codegen.enable_source_map(&filename, &source_text);
     }
diff --git a/tasks/transform_conformance/src/driver.rs b/tasks/transform_conformance/src/driver.rs
index 107328276d8f2..2a595d8d74bd4 100644
--- a/tasks/transform_conformance/src/driver.rs
+++ b/tasks/transform_conformance/src/driver.rs
@@ -2,9 +2,8 @@ use std::{mem, ops::ControlFlow, path::Path};
 
 use oxc::{
     ast::ast::Program,
-    codegen::{CodeGenerator, CodegenOptions, CodegenReturn},
+    codegen::{CodegenOptions, CodegenReturn},
     diagnostics::OxcDiagnostic,
-    mangler::Mangler,
     span::SourceType,
     transformer::{TransformOptions, TransformerReturn},
     CompilerInterface,
@@ -23,6 +22,10 @@ impl CompilerInterface for Driver {
         Some(self.options.clone())
     }
 
+    fn codegen_options(&self) -> Option<CodegenOptions> {
+        Some(CodegenOptions { comments: false, ..CodegenOptions::default() })
+    }
+
     fn check_semantic_error(&self) -> bool {
         false
     }
@@ -55,17 +58,6 @@ impl CompilerInterface for Driver {
         }
         ControlFlow::Continue(())
     }
-
-    // Disable comments
-    fn codegen(
-        &self,
-        program: &Program<'_>,
-        _source_path: &Path,
-        mangler: Option<Mangler>,
-        options: CodegenOptions,
-    ) -> CodegenReturn {
-        CodeGenerator::new().with_options(options).with_mangler(mangler).build(program)
-    }
 }
 
 impl Driver {
diff --git a/tasks/transform_conformance/src/test_case.rs b/tasks/transform_conformance/src/test_case.rs
index 84b89b48e36cf..baab1fa7980a1 100644
--- a/tasks/transform_conformance/src/test_case.rs
+++ b/tasks/transform_conformance/src/test_case.rs
@@ -6,7 +6,7 @@ use std::{
 use cow_utils::CowUtils;
 use oxc::{
     allocator::Allocator,
-    codegen::CodeGenerator,
+    codegen::{CodeGenerator, CodegenOptions},
     diagnostics::{Error, NamedSource, OxcDiagnostic},
     parser::Parser,
     span::{SourceType, VALID_EXTENSIONS},
@@ -300,11 +300,10 @@ impl TestCase for ConformanceTestCase {
                     // Get expected code by parsing the source text, so we can get the same code generated result.
                     let ret = Parser::new(&allocator, &output, source_type).parse();
                     CodeGenerator::new()
-                        // .enable_comment(
-                        // &output,
-                        // ret.trivias,
-                        // CommentOptions { preserve_annotate_comments: true },
-                        // )
+                        .with_options(CodegenOptions {
+                            comments: false,
+                            ..CodegenOptions::default()
+                        })
                         .build(&ret.program)
                         .code
                 },
@@ -396,7 +395,10 @@ impl ExecTestCase {
         let source_text = fs::read_to_string(&target_path).unwrap();
         let source_type = SourceType::from_path(&target_path).unwrap();
         let transformed_ret = Parser::new(&allocator, &source_text, source_type).parse();
-        let result = CodeGenerator::new().build(&transformed_ret.program).code;
+        let result = CodeGenerator::new()
+            .with_options(CodegenOptions { comments: false, ..CodegenOptions::default() })
+            .build(&transformed_ret.program)
+            .code;
         fs::write(&target_path, result).unwrap();
         target_path
     }

From f46fd71cc05b569110893e12a03d08fad3fcf9f0 Mon Sep 17 00:00:00 2001
From: Cameron Clark <cameron.clark@hey.com>
Date: Thu, 10 Oct 2024 20:42:14 +0100
Subject: [PATCH 23/24] feat(minifier): implement folding `indexOf` and
 `lastIndexOf` string fns

---
 .../peephole_replace_known_methods/mod.rs     | 106 ++++++++++++++----
 .../string_methods.rs                         |  91 +++++++++++++++
 2 files changed, 176 insertions(+), 21 deletions(-)
 create mode 100644 crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs

diff --git a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
index 057b9f4ae603f..f23ecb9bbe426 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
@@ -1,6 +1,9 @@
 use cow_utils::CowUtils;
 use oxc_ast::ast::*;
 use oxc_traverse::{Traverse, TraverseCtx};
+use string_methods::{evaluate_string_index_of, evaluate_string_last_index_of};
+
+mod string_methods;
 
 use crate::CompressorPass;
 
@@ -41,25 +44,86 @@ impl PeepholeReplaceKnownMethods {
 
         let Expression::StaticMemberExpression(member) = &call_expr.callee else { return };
         if let Expression::StringLiteral(string_lit) = &member.object {
-            if call_expr.arguments.len() == 0 {
-                let transformed_value = match member.property.name.as_str() {
-                    "toLowerCase" => Some(
-                        ctx.ast.string_literal(call_expr.span, string_lit.value.cow_to_lowercase()),
-                    ),
-                    "toUpperCase" => Some(
-                        ctx.ast.string_literal(call_expr.span, string_lit.value.cow_to_uppercase()),
-                    ),
-                    "trim" => Some(ctx.ast.string_literal(call_expr.span, string_lit.value.trim())),
-                    _ => None,
-                };
-
-                if let Some(transformed_value) = transformed_value {
-                    self.changed = true;
-                    *node = ctx.ast.expression_from_string_literal(transformed_value);
+            #[expect(clippy::match_same_arms)]
+            let replacement = match member.property.name.as_str() {
+                "toLowerCase" | "toUpperCase" | "trim" => {
+                    let transformed_value =
+                        match member.property.name.as_str() {
+                            "toLowerCase" => Some(ctx.ast.string_literal(
+                                call_expr.span,
+                                string_lit.value.cow_to_lowercase(),
+                            )),
+                            "toUpperCase" => Some(ctx.ast.string_literal(
+                                call_expr.span,
+                                string_lit.value.cow_to_uppercase(),
+                            )),
+                            "trim" => Some(
+                                ctx.ast.string_literal(call_expr.span, string_lit.value.trim()),
+                            ),
+                            _ => None,
+                        };
+
+                    transformed_value.map(|transformed_value| {
+                        ctx.ast.expression_from_string_literal(transformed_value)
+                    })
                 }
+                "indexOf" | "lastIndexOf" => Self::try_fold_string_index_of(
+                    call_expr.span,
+                    call_expr,
+                    member,
+                    string_lit,
+                    ctx,
+                ),
+                // TODO: Implement the rest of the string methods
+                "substr" => None,
+                "substring" | "slice" => None,
+                "charAt" => None,
+                "charCodeAt" => None,
+                "replace" => None,
+                "replaceAll" => None,
+                _ => None,
+            };
+
+            if let Some(replacement) = replacement {
+                self.changed = true;
+                *node = replacement;
             }
         }
     }
+
+    fn try_fold_string_index_of<'a>(
+        span: Span,
+        call_expr: &CallExpression<'a>,
+        member: &StaticMemberExpression<'a>,
+        string_lit: &StringLiteral<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) -> Option<Expression<'a>> {
+        let search_value = match call_expr.arguments.first() {
+            Some(Argument::StringLiteral(string_lit)) => Some(string_lit.value.as_str()),
+            None => None,
+            _ => return None,
+        };
+
+        let search_start_index = match call_expr.arguments.get(1) {
+            Some(Argument::NumericLiteral(numeric_lit)) => Some(numeric_lit.value),
+            None => None,
+            _ => return None,
+        };
+
+        let result = if member.property.name.as_str() == "indexOf" {
+            evaluate_string_index_of(&string_lit.value, search_value, search_start_index)
+        } else {
+            evaluate_string_last_index_of(&string_lit.value, search_value, search_start_index)
+        };
+
+        #[expect(clippy::cast_precision_loss)]
+        return Some(ctx.ast.expression_from_numeric_literal(ctx.ast.numeric_literal(
+            span,
+            result as f64,
+            result.to_string(),
+            NumberBase::Decimal,
+        )));
+    }
 }
 
 /// Port from: <https://github.com/google/closure-compiler/blob/master/test/com/google/javascript/jscomp/PeepholeReplaceKnownMethodsTest.java>
@@ -88,7 +152,6 @@ mod test {
     }
 
     #[test]
-    #[ignore]
     fn test_string_index_of() {
         fold("x = 'abcdef'.indexOf('g')", "x = -1");
         fold("x = 'abcdef'.indexOf('b')", "x = 1");
@@ -102,11 +165,12 @@ mod test {
 
         // Both elements must be strings. Don't do anything if either one is not
         // string.
-        fold("x = 'abc1def'.indexOf(1)", "x = 3");
-        fold("x = 'abcNaNdef'.indexOf(NaN)", "x = 3");
-        fold("x = 'abcundefineddef'.indexOf(undefined)", "x = 3");
-        fold("x = 'abcnulldef'.indexOf(null)", "x = 3");
-        fold("x = 'abctruedef'.indexOf(true)", "x = 3");
+        // TODO: cast first arg to a string, and fold if possible.
+        // fold("x = 'abc1def'.indexOf(1)", "x = 3");
+        // fold("x = 'abcNaNdef'.indexOf(NaN)", "x = 3");
+        // fold("x = 'abcundefineddef'.indexOf(undefined)", "x = 3");
+        // fold("x = 'abcnulldef'.indexOf(null)", "x = 3");
+        // fold("x = 'abctruedef'.indexOf(true)", "x = 3");
 
         // The following test case fails with JSC_PARSE_ERROR. Hence omitted.
         // fold_same("x = 1.indexOf('bcd');");
diff --git a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs
new file mode 100644
index 0000000000000..50a37600f8028
--- /dev/null
+++ b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs
@@ -0,0 +1,91 @@
+use oxc_syntax::number::ToJsInt32;
+
+#[expect(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
+pub(super) fn evaluate_string_index_of<'a>(
+    string: &'a str,
+    search_value: Option<&'a str>,
+    from_index: Option<f64>,
+) -> isize {
+    let from_index = from_index.map_or(0, |x| x.to_js_int_32().max(0)) as usize;
+    let Some(search_value) = search_value else {
+        return -1;
+    };
+    let result = string.chars().skip(from_index).collect::<String>().find(search_value);
+    result.map(|index| index + from_index).map_or(-1, |index| index as isize)
+}
+
+#[expect(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
+pub(super) fn evaluate_string_last_index_of<'a>(
+    string: &'a str,
+    search_value: Option<&'a str>,
+    from_index: Option<f64>,
+) -> isize {
+    let Some(search_value) = search_value else { return -1 };
+
+    let from_index =
+        from_index.map_or(usize::MAX, |x| x.to_js_int_32().max(0) as usize + search_value.len());
+
+    string
+        .chars()
+        .take(from_index)
+        .collect::<String>()
+        .rfind(search_value)
+        .map_or(-1, |index| index as isize)
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_evaluate_string_index_of() {
+        use super::evaluate_string_index_of;
+
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(0.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(1.0)), 3);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(4.0)), 5);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(4.1)), 5);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(0.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(-1.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(-1.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("t"), Some(-1.1)), 0);
+        assert_eq!(
+            evaluate_string_index_of("test test test", Some("t"), Some(-1_073_741_825.0)),
+            0
+        );
+        assert_eq!(evaluate_string_index_of("test test test", Some("e"), Some(0.0)), 1);
+        assert_eq!(evaluate_string_index_of("test test test", Some("s"), Some(0.0)), 2);
+
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(4.0)), 5);
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(5.0)), 5);
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(6.0)), 10);
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(0.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(-1.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("not found"), Some(-1.0)), -1);
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(-1.0)), 0);
+        assert_eq!(
+            evaluate_string_index_of("test test test", Some("test"), Some(-1_073_741_825.0)),
+            0
+        );
+        assert_eq!(evaluate_string_index_of("test test test", Some("test"), Some(0.0)), 0);
+        assert_eq!(evaluate_string_index_of("test test test", Some("notpresent"), Some(0.0)), -1);
+        assert_eq!(evaluate_string_index_of("test test test", None, Some(0.0)), -1);
+    }
+
+    #[test]
+    fn test_evaluate_string_last_index_of() {
+        use super::evaluate_string_last_index_of;
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(15.0)), 10);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(14.0)), 10);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(10.0)), 10);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(9.0)), 5);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(6.0)), 5);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(5.0)), 5);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(4.0)), 0);
+        assert_eq!(evaluate_string_last_index_of("test test test", Some("test"), Some(0.0)), 0);
+        assert_eq!(
+            evaluate_string_last_index_of("test test test", Some("notpresent"), Some(0.0)),
+            -1
+        );
+        assert_eq!(evaluate_string_last_index_of("test test test", None, Some(1.0)), -1);
+        assert_eq!(evaluate_string_last_index_of("abcdef", Some("b"), None), 1);
+    }
+}

From 115c8bbb509ade48a623e42250a0a9e0e62b497d Mon Sep 17 00:00:00 2001
From: Cameron Clark <cameron.clark@hey.com>
Date: Thu, 10 Oct 2024 21:33:24 +0100
Subject: [PATCH 24/24] feat(minifier): implement folding `charAt` string fns

---
 .../peephole_replace_known_methods/mod.rs     | 45 ++++++++++++++++---
 .../string_methods.rs                         | 21 +++++++++
 2 files changed, 59 insertions(+), 7 deletions(-)

diff --git a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
index f23ecb9bbe426..c30fce64f852d 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/mod.rs
@@ -1,7 +1,9 @@
 use cow_utils::CowUtils;
 use oxc_ast::ast::*;
 use oxc_traverse::{Traverse, TraverseCtx};
-use string_methods::{evaluate_string_index_of, evaluate_string_last_index_of};
+use string_methods::{
+    evaluate_string_char_at, evaluate_string_index_of, evaluate_string_last_index_of,
+};
 
 mod string_methods;
 
@@ -77,7 +79,9 @@ impl PeepholeReplaceKnownMethods {
                 // TODO: Implement the rest of the string methods
                 "substr" => None,
                 "substring" | "slice" => None,
-                "charAt" => None,
+                "charAt" => {
+                    Self::try_fold_string_char_at(call_expr.span, call_expr, string_lit, ctx)
+                }
                 "charCodeAt" => None,
                 "replace" => None,
                 "replaceAll" => None,
@@ -124,6 +128,32 @@ impl PeepholeReplaceKnownMethods {
             NumberBase::Decimal,
         )));
     }
+
+    fn try_fold_string_char_at<'a>(
+        span: Span,
+        call_expr: &CallExpression<'a>,
+        string_lit: &StringLiteral<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) -> Option<Expression<'a>> {
+        let char_at_index: Option<f64> = match call_expr.arguments.first() {
+            Some(Argument::NumericLiteral(numeric_lit)) => Some(numeric_lit.value),
+            Some(Argument::UnaryExpression(unary_expr))
+                if unary_expr.operator == UnaryOperator::UnaryNegation =>
+            {
+                let Expression::NumericLiteral(numeric_lit) = &unary_expr.argument else {
+                    return None;
+                };
+                Some(-(numeric_lit.value))
+            }
+            None => None,
+            _ => return None,
+        };
+
+        let result = evaluate_string_char_at(&string_lit.value, char_at_index)
+            .map_or(String::new(), |v| v.to_string());
+
+        return Some(ctx.ast.expression_from_string_literal(ctx.ast.string_literal(span, result)));
+    }
 }
 
 /// Port from: <https://github.com/google/closure-compiler/blob/master/test/com/google/javascript/jscomp/PeepholeReplaceKnownMethodsTest.java>
@@ -381,18 +411,19 @@ mod test {
     }
 
     #[test]
-    #[ignore]
     fn test_fold_string_char_at() {
         fold("x = 'abcde'.charAt(0)", "x = 'a'");
         fold("x = 'abcde'.charAt(1)", "x = 'b'");
         fold("x = 'abcde'.charAt(2)", "x = 'c'");
         fold("x = 'abcde'.charAt(3)", "x = 'd'");
         fold("x = 'abcde'.charAt(4)", "x = 'e'");
-        fold_same("x = 'abcde'.charAt(5)"); // or x = ''
-        fold_same("x = 'abcde'.charAt(-1)"); // or x = ''
+        // START: note, the following test cases outputs differ from Google's
+        fold("x = 'abcde'.charAt(5)", "x = ''");
+        fold("x = 'abcde'.charAt(-1)", "x = ''");
+        fold("x = 'abcde'.charAt()", "x = 'a'");
+        fold("x = 'abcde'.charAt(0, ++z)", "x = 'a'");
+        // END
         fold_same("x = 'abcde'.charAt(y)");
-        fold_same("x = 'abcde'.charAt()"); // or x = 'a'
-        fold_same("x = 'abcde'.charAt(0, ++z)"); // or (++z, 'a')
         fold_same("x = 'abcde'.charAt(null)"); // or x = 'a'
         fold_same("x = 'abcde'.charAt(true)"); // or x = 'b'
                                                // fold("x = '\\ud834\udd1e'.charAt(0)", "x = '\\ud834'");
diff --git a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs
index 50a37600f8028..f89d9939a2cbe 100644
--- a/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs
+++ b/crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods/string_methods.rs
@@ -33,6 +33,16 @@ pub(super) fn evaluate_string_last_index_of<'a>(
         .map_or(-1, |index| index as isize)
 }
 
+#[expect(clippy::cast_sign_loss)]
+pub(super) fn evaluate_string_char_at(string: &str, index: Option<f64>) -> Option<char> {
+    let index = index.map_or(0, |x| x.to_js_int_32() as isize);
+    if index < 0 {
+        None
+    } else {
+        string.chars().nth(index as usize)
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[test]
@@ -88,4 +98,15 @@ mod test {
         assert_eq!(evaluate_string_last_index_of("test test test", None, Some(1.0)), -1);
         assert_eq!(evaluate_string_last_index_of("abcdef", Some("b"), None), 1);
     }
+
+    #[test]
+    fn test_evaluate_string_char_at() {
+        use super::evaluate_string_char_at;
+        assert_eq!(evaluate_string_char_at("test", Some(0.0)), Some('t'));
+        assert_eq!(evaluate_string_char_at("test", Some(1.0)), Some('e'));
+        assert_eq!(evaluate_string_char_at("test", Some(2.0)), Some('s'));
+        assert_eq!(evaluate_string_char_at("test", Some(-1.0)), None);
+        assert_eq!(evaluate_string_char_at("test", Some(-1.1)), None);
+        assert_eq!(evaluate_string_char_at("test", Some(-1_073_741_825.0)), None);
+    }
 }