Simplifies creating a release build with debug information for
profiling/debugging purposes. Instead of needing to manually edit
`Cargo.toml` and add `strip = false` and `debug = true`, now you can
simply build with this profile:
```bash
cargo build --profile release-with-debug --bin oxlint
```
When writing new rules, it is always inevitable to add `diagnostic`.
Perhaps we can preset it in the `template`.
In addition, guide users to view relevant documents.
Tiny refactor. Export `var_declarations` module from `common`, rather than `var_declarations::VarDeclarationsStore`. Once we have more common transforms, the namespace of `common` module will become crowded.
First step towards #5049.
Various transforms need to add a `var` statement at top of enclosing statement block.
e.g.:
```js
// Input
a ??= b;
```
```js
// Output
var _a;
(_a = a) !== null && _a !== void 0 ? _a : (a = b);
```
Each of these transforms previously maintained it's own stack and added `var` statements individually.
Share this functionality in a "common" utility transform which maintains a single stack to serve them all.
`NonEmptyStack::push` was previously updating `cursor` before writing the value to stack. This could be UB if the type `T` is `Drop`, and writing the value panicked - as then `drop` would attempt to drop an uninitialized `T`.
I think `ptr::write` is infallible (can't panic), so it shouldn't matter. But *maybe* in debug mode it can panic if some invariant is broken (e.g. pointer not aligned). So play it safe and write the value first and update the cursor after.
Hello,
I was following the guide
https://oxc.rs/docs/contribute/development.html and executed `just
ready` as said.
I got an error on Windows on the `doc` command because it sets the env
variable in a way that is not compatible with `powershell`.
I've used
[attributes](https://just.systems/man/en/attributes.html#attributes) to
fix the issue.
I never used `just` so I don't know if there's a better way to fix the
issue.
Parse JSX pragmas faster by:
1. Finding patterns with byte-by-byte iteration, with fast path for ASCII.
2. Checking for the `@jsx` prefix first before parsing the rest of the pragma.
These routines could be speeded up further by using unchecked slicing (unsafe code). But I've avoided that as the routines at present are quite complex, so hard to verify. The exception is `trim_end`, which is trivial to verify, so I have used unchecked slicing there.
The perf gain here is only ~0.5%, but we should split these routines out into a separate common crate and further optimize them, so that they can be used elsewhere in the codebase where we do string operations, which are often quite expensive.
# Human Description
Low on time, so this one is short.
- consolidate source file and partial loader logic into `loader` module. I have more plans for this.
- ~LSP no longer uses `VALID_EXTENSIONS`, so now `.d.ts` files (and the like) will be linted as well~ LSP does not respect `.gitignore` files, so this change was reverted.
# AI Description
## Refactor Loader and Partial Loader
This PR refactors the loader and partial loader functionality in the oxc_linter crate:
* Introduce a new `Loader` struct with methods for checking if a file can be loaded and loading file contents
* Move `partial_loader` module to `loader/partial_loader`
* Rename `JavaScriptSource` to `source.rs` and move it to the `loader` module
* Update `JavaScriptSource` to use `u32` for `start` offset instead of `usize`
* Refactor `IsolatedLintHandler` to use the new `Loader`
* Update imports and module references throughout the codebase
This change improves the organization of the loader-related code and provides a more unified interface for loading different file types.
- fixes https://github.com/oxc-project/oxc/issues/6136
The original eslint rule checks if chars start with `\u` or `\x`, but our character spans are currently busted and only report 1 char for chars like `\u{0a}`. I've made whitespace an exception to the rule, so we don't report `\x0a` currently, which is fine for now I think
All TS transforms only need a subset of the options in `TypeScriptOptions` - mostly just a single `bool`. Store these specific options in the transforms, not the whole `TypeScriptOptions` object.
This makes the transformer types smaller, and also checking the option is cheaper as it doesn't involve going through a double-reference.
e.g. Accessing `only_remove_type_imports` option with Rust's deref sugar made explicit:
Before: `*(&*self.options).only_remove_type_imports`
After: `*self.only_remove_type_imports`
- closes https://github.com/oxc-project/oxc/issues/5416
Rewrites the `no-control-regex` rule to use a regular expression AST visitor instead of the `regex` crate and parsing by hand. This change simplifies the code and makes it easier to maintain.
One notable change in the snapshots is the printing of the control characters. Previously, we always printed from the source text. Now, we print a representation of the control character itself based on its numeric value. This resulted in the nonprintable chars being printed, which are invisible. The other reason for this change is that the spans output by the regex parser for unicode escapes do not match 1:1 when raw strings and escapes are involved. This resulted in goofy looking spans in the output:
```
⚠ eslint(no-control-regex): Unexpected control character: '*\\x'
╭─[no_control_regex.tsx:1:22]
1 │ new RegExp('\\u{1111}*\\x1F', 'u')
· ────
╰────
```
Not sure where the bug lies there yet.
Updates the `no-hex-escape` to use the new standard `Visit` trait for visiting the RegExp AST, replacing the handwritten implementation in this rule. This makes it much simpler to maintain.
In exponentiation operator transform, the first branch handling `**` was "falling through" to also run the 2nd branch which handles `**=`. The first branch replaces `**` with `Math.pow`, so it can never match on the 2nd branch.
Convert it to a `match` instead, so it only executes one branch or the other.
Similar to #6118.
Share `TypeScriptOptions` between transforms as a plain `&` reference, rather than an `Rc`, to reduce setup/teardown time.
The code to parse pragmas from comments is moved into `Transformer::new`. This isn't the ideal place for it, but it means `TypeScriptOptions` can be shared with the existing `'ctx` lifetime, rather than having to have a 3rd lifetime `TypeScript<'a, 'ctx, 'options>`.
Many transforms share `TransformCtx`. Currently it's shared with `Rc`, which has a cost as the `Rc` has to be cloned many times, and it also makes dropping `Transformer` more expensive.
The PR changes that to share it as a normal reference `&TransformCtx` instead.
This requires adding an inner `TransformerImpl`. `Transformer` is now just a facade which creates the `TransformCtx` and stores options. `Transformer::build_with_symbols_and_scopes` constructs `TransformerImpl` and runs the visitor on it.
Unlikely to have any perf impact on larger files, but for small files where setup/teardown is a larger % of the overall workload, it may help a little.
Pre-allocate 16 bytes for stacks in transforms that use them. Allocators usually support minimum of 16 bytes for allocations anyway. Now that we're using `SparseStack`, allocating decent capacity is now cheap.
Introduce a wrapper around `NonNull` which enables methods which exist on `std::ptr::NonNull` but are not yet stable in our MSRV. These methods remove a lot of boilerplate code from `Stack` and `NonEmptyStack` and make them easier to understand - which is important, since they contain so much unsafe code.
`Stack` and `NonEmptyStack` contained a lot of the same logic. Move shared logic into a `StackCommon` trait that they both implement.
Also split out core allocation logic into non-generic free functions for faster compile time.
Similar to previous PRs, this refactors the `no-regex-spaces` rule to use the RegExp AST visitor, rather than the handwritten implementation in this rule. This makes the rule much simpler and easier to maintain in the future.
This PR updates this rule to use the new RegExp AST visitor trait, instead of a custom implementation, which makes this rule much simpler and easier to maintain. The core logic is the same though, and the output should be identical.
Replaces rule-specific regex AST visitor method with the standard `oxc_regular_expression` one. This simplifies the code and also enables more capabilities (visiting more than just terms, but also character class contents, etc.)
