dan/oxc
1
0
Fork 0
mirror of https://github.com/danbulant/oxc synced 2026-05-25 04:42:10 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
4541 commits 1 branch 0 tags 45 MiB
Commit graph

412 commits

Author SHA1 Message Date
overlookmotel
ab8509edaa perf(parser): use - not saturating_sub (#4561) 
Follow-on after #4304. Avoid using `saturating_sub` when plain `-` will do. `-` is cheaper - it's a single assembly instruction, whereas `saturating_sub` is usually 3 instructions.

https://godbolt.org/z/fo8Tcx6bK
 2024-07-31 00:28:46 +00:00
lucab
c9c38a187c perf(parser): support peeking over bytes (#4304) 
Closes https://github.com/oxc-project/oxc/issues/3291
 2024-07-30 17:53:13 +00:00
DonIsaac
d5c4b190aa fix(parser): fix enum member parsing (#4543) 
Closes #4449
 2024-07-30 10:43:09 +00:00
lucab
0870ee1f9f perf(parser): get and check lookahead token (#4534) 2024-07-29 16:45:39 +00:00
overlookmotel
148bdb5585 refactor(parser): adjust function inlining (#4530) 
These 2 `#[inline(always)]` were introduced by accident by me just playing around in #4298. One should be kept, but the other one we should leave to compiler to decide.
 2024-07-29 15:38:02 +00:00
Boshen
7446e986c3 feat(codegen): align more esbuild implementations (#4510) 2024-07-28 13:35:37 +00:00
Boshen
35654e665c feat(codegen): align operator precedence with esbuild (#4509) 
closes #4339
 2024-07-28 11:48:51 +00:00
lucab
868fc87885 perf(parser): optimize conditional advance on ASCII values (#4298) 
Part of https://github.com/oxc-project/oxc/issues/3291.
 2024-07-27 01:17:25 +00:00
overlookmotel
aece1df561 fix(ast): visit Programs hashbang field first (#4368) 
Visit `hashbang` before `directives` for `Program`.
 2024-07-19 16:27:51 +00:00
Dunqing
f68b659713 refactor(ast)!: reorder fields of ArrowFunctionExpression (#4364) 
Found in #4328
Same as #4248
 2024-07-19 14:12:05 +00:00
DonIsaac
a2eabe1f4b refactor(parser): use error codes for ts diagnostics (#4335) 
Part of #4333
 2024-07-18 16:09:25 +00:00
lucab
9a87e41332 fix(parser): avoid crashing on invalid const modifier (#4267) 
Followup on https://github.com/oxc-project/oxc/pull/3977, fixing one of the crashes at https://github.com/oxc-project/oxc/pull/3977.
 2024-07-15 11:37:31 +00:00
overlookmotel
a8dc4f34b2
perf(parser): speed up parsing numbers with _ separators (#4259) 
When parsing a number which contains `_` separators, rather than looping
through the string once to remove separators, and then again to convert
to an `f64`, do it all in a single loop.

Co-authored-by: overlookmotel <557937+overlookmotel@users.noreply.github.com>
 2024-07-15 12:27:47 +08:00
overlookmotel
b94540d0fb perf(parser): speed up parsing octal literals (#4258) 
Micro-optimization to parsing octal numbers. This removes usage of `char`, so removes a surprising amount of instructions.
 2024-07-15 03:42:47 +00:00
overlookmotel
a7b328c4f5 perf(parser): faster parsing decimal numbers (#4257) 
Closes #3288.

Speed up parsing decimal literals (e.g. `123`), using same techniques as `parse_octal` etc.
 2024-07-15 03:38:09 +00:00
Boshen
a71787572e
chore: remove unsafe_code = "warn" rust lint 
Feels too verbose as we already have unsafe comment turned on
 2024-07-15 10:39:08 +08:00
overlookmotel
641a78bc2b fix(parser): fix tests for number parsing (#4254) 
Fix tests for parsing large numbers.

* Tests for imprecision decimals and octals weren't using numbers larger than `u64::MAX`, so were not testing what they were meant to be - that parser can handle larger numbers.
* Tests for decimals (e.g. `123.5`) were calling `parse_int` which isn't meant to handle that (`parse_float` does that).
* Tests were calling `parse_int` with negative numbers, which it's not meant to handle.

Also, re-order the const assertions in same order as the code above.
 2024-07-15 01:26:13 +00:00
Dunqing
ace4f1ff77 refactor(semantic): update the order of visit_function and Visit fields in the builder to be consistent (#4248) 
Same as #4195
 2024-07-14 11:39:15 +00:00
Dunqing
20cdb1fe0a feat(semantic): align class scope with typescript (#4195) 
```ts
class Klass <T>   extends Root       <R>                   {}
//    ^^^^^ ^^^           ^^^^       ^^^                   ^^
//    id type_paramter super_class super_type_parameters  body
```
I reorder fields according to the order above

The class scope is not defined in the spec. But we need to create a scope for `class` to store `TypeParamters`
 2024-07-14 03:19:30 +00:00
DonIsaac
4a656c3a18 fix(lexer): incorrect lexing of large hex/octal/binary literals (#4072) 
Closes #3347. Implementation follows the approach described by @overlookmotel [here](https://github.com/oxc-project/oxc/issues/3347#issuecomment-2119004288).
 2024-07-10 16:39:10 +00:00
Boshen
28eeee0f71 fix(parser): fix asi error diagnostic pointing at invalid text causing crash (#4163) 2024-07-10 14:45:10 +00:00
rzvxa
48947a26d2 fix(ast): put decorators before everything else. (#4143) 
Won't fix #4142

It is similar to #3994 but for those types that weren't relying on this order. It seems to be the right order.
technically speaking it is a breaking change but I know as a fact that it won't have a big difference on our downstream. If you want it to be chronically correct feel free to merge as a breaking change.
 2024-07-10 02:03:05 +00:00
Luca Bruno
5731e3957f
refactor(ast)!: store span details inside comment struct (#4132) 
This tweaks `Comment` definition in order to internally store the start
and end position of its span.

Closes: https://github.com/oxc-project/oxc/issues/4069
 2024-07-09 23:23:43 +08:00
rzvxa
b936162093 refactor(ast/ast_builder)!: shorter allocator utility method names. (#4122) 
This PR serves two purposes, First off it would lower the amount of characters we have to type in for a simple operation such as wrapping an expression in a vector. Secondly, it would follow the generated names more closely since nowhere else in the builder we do have `new_xxx`, We always say `xxx` since a builder always constructs something.

```
new_vec -> vec
new_vec_single -> vec1*
new_vec_from_iter -> vec_from_iter
new_vec_with_capacity -> vec_with_capacity
new_str -> str
new_atom -> atom
```

`*` This one is the main motivation behind this PR, It saves 10 characters!
 2024-07-09 12:16:38 +00:00
DonIsaac
3a0f2aa7ef feat(parser): check for illegal modifiers in modules and namespaces (#4126) 2024-07-09 02:54:06 +00:00
rzvxa
d347aedfda feat(ast)!: generate ast_builder.rs. (#3890) 
### Every structure has 2 builder methods:

1. `xxx` e.g. `block_statement`
```rust
    #[inline]
    pub fn block_statement(self, span: Span, body: Vec<'a, Statement<'a>>) -> BlockStatement<'a> {
        BlockStatement { span, body, scope_id: Default::default() }
    }
```
2. `alloc_xxx` e.g. `alloc_block_statement`
```rust
    #[inline]
    pub fn alloc_block_statement(
        self,
        span: Span,
        body: Vec<'a, Statement<'a>>,
    ) -> Box<'a, BlockStatement<'a>> {
        self.block_statement(span, body).into_in(self.allocator)
    }
```

### We generate 3 types of methods for enums:

1. `yyy_xxx` e.g. `statement_block`
```rust
    #[inline]
    pub fn statement_block(self, span: Span, body: Vec<'a, Statement<'a>>) -> Statement<'a> {
        Statement::BlockStatement(self.alloc(self.block_statement(span, body)))
    }
```
2. `yyy_from_xxx` e.g. `statement_from_block`
```rust
    #[inline]
    pub fn statement_from_block<T>(self, inner: T) -> Statement<'a>
    where
        T: IntoIn<'a, Box<'a, BlockStatement<'a>>>,
    {
        Statement::BlockStatement(inner.into_in(self.allocator))
    }
```
3. `yyy_xxx` where `xxx` is inherited e.g. `statement_declaration`
```rust
    #[inline]
    pub fn statement_declaration(self, inner: Declaration<'a>) -> Statement<'a> {
        Statement::from(inner)
    }
```

------------

### Generic parameters:

We no longer accept `Box<'a, ADT>`, `Atom` or `&'a str`, Instead we use `IntoIn<'a, Box<'a, ADT>>`, `IntoIn<'a, Atom<'a>>` and `IntoIn<'a, &'a str>` respectively.
It allows us to rewrite things like this:
```rust
let ident = IdentifierReference::new(SPAN, Atom::from("require"));
let number_literal_expr = self.ast.expression_numeric_literal(
    right_expr.span(),
    num,
    raw,
    self.ast.new_str(num.to_string().as_str()),
    NumberBase::Decimal,
);
```
As this:
```rust
let ident = IdentifierReference::new(SPAN, "require");
let number_literal_expr = self.ast.expression_numeric_literal(
    right_expr.span(),
    num,
    raw,
    num.to_string(),
    NumberBase::Decimal,
);
```
 2024-07-09 00:57:26 +00:00
overlookmotel
7fe2a2f681 perf(parser): do not copy comments (#4067) 
Follow-on from #4045. `.from_iter()` copies the `Vec` of comments into another `Vec` before converting to a boxed slice. This copy is unnecessary - just convert direct.
 2024-07-06 09:56:41 +00:00
Luca Bruno
e32b4bc57c
refactor(ast)!: store trivia comments in a sorted slice (#4045) 
This gets rid of `TriviasMap`, introducing `SortedComments` in order to
store trivia comments in a sorted slice.

Closes: https://github.com/oxc-project/backlog/issues/38
 2024-07-04 01:57:36 +08:00
Boshen
243c9f35b0 refactor(parser): use function instead of trait to parse list with rest element (#4028) 
closes #3887
 2024-07-02 13:43:14 +00:00
Boshen
1dacb1fc5b
refactor(parser): use function instead of trait to parse delimited lists (#4014) 
relates #3887

The rest of the list parsing trait implementations involves ... parsing
`rest`, which I'll refactor in another PR.
 2024-07-02 14:47:56 +08:00
Boshen
d0eac46fc8 refactor(parser): use function instead of trait to parse normal lists (#4003) 
To reduce boilerplate and code noise.

relates #3887
 2024-07-01 15:57:36 +00:00
Boshen
dc6d45e2e6 feat(ast,codegen): add TSParenthesizedType and print type parentheses correctly (#3979) 
closes #3916
 2024-06-30 07:57:48 +00:00
DonIsaac
63f36daae0 feat(parser): parse modifiers with parse_modifiers (take 2) (#3977) 
Same as #3948, with fixes for bugs found by @Boshen.
 2024-06-30 03:46:34 +00:00
Boshen
14bc31ee74
Revert "feat(parser): parse modifiers with parse_modifiers (#3948)" 
This reverts commit 7b38bde073.
 2024-06-29 14:16:26 +08:00
DonIsaac
7b38bde073 feat(parser): parse modifiers with parse_modifiers (#3948) 
Closes #3929
 2024-06-29 05:29:47 +00:00
DonIsaac
2705df93b3 refactor(linter): improve diagnostic labeling (#3960) 2024-06-29 05:19:22 +00:00
Boshen
275349a9fe fix(parser): parse function type parameter name accessor (#3926) 
fixes #3910
 2024-06-26 13:34:24 +00:00
Boshen
a471e62e2d refactor(parser): clean up try_parse (#3925) 2024-06-26 11:18:02 +00:00
Boshen
3db2553dc2 refactor(parser): improve parsing of TypeScript type arguments (#3923) 2024-06-26 07:16:18 +00:00
Boshen
4cf3c7645f refactor(parser): improve parsing of TypeScript types (#3903) 
- [x] fix everything
 2024-06-26 05:58:16 +00:00
rzvxa
6796891e2e fix(ast)!: rename all instances of BigintLiteral to BigIntLiteral. (#3898) 
Notice the casing! Just for the sake of consistency.
 2024-06-25 14:39:42 +00:00
rzvxa
1f85f1a5f7 refactor(ast)!: revert adding span field to the BindingPattern type. (#3899) 
Since this is a temporary solution in the time that we are waiting for the `#[span]` hint, And there are already other workarounds used in our `ast_codegen` I propose removing it right away - sorry in my opinion adding it in the first place was a mistake - in favor of adding an edge case in the codegen. It is better to do the refactoring in the codegen instead of the production code which people may depend on.
 2024-06-25 09:43:48 +00:00
Boshen
4bf405ddfc perf(parser): add a few more inline hints to cursor functions (#3894) 2024-06-25 06:00:46 +00:00
Boshen
187f0782c1 refactor(parser): improve parsing of parse_function_or_constructor_type (#3892) 
part of #3502
 2024-06-25 03:43:02 +00:00
Dunqing
ef82c78a72 fix(parser): trailing comma is not allowed in ParenthesizedExpression (#3885) 
close: #3878

The implementation is copied from `SeparatedList`'s `print_list`.
```diff
    fn parse_list(&mut self, p: &mut ParserImpl<'a>) -> Result<()> {
        p.expect(self.open())?;

        let mut first = true;

        while !p.at(self.close()) && !p.at(Kind::Eof) {
            if first {
                first = false;
            } else {
                p.expect(self.separator())?;
-                if p.at(self.close()) {
-                    break;
-               }
            }

            self.parse_element(p)?;
        }

        p.expect(self.close())?;
        Ok(())
    }
```
 2024-06-24 14:56:32 +00:00
rzvxa
363d3d57d7 refactor(ast): add span field to the BindingPattern type. (#3855) 
So we don't have to introduce a special case while generating `GetSpan` implementations for all of our Ast types.
 2024-06-23 16:00:40 +00:00
Boshen
d6437fec0b refactor: clean up some usages of with_labels (#3854) 2024-06-23 15:24:37 +00:00
Boshen
13754cbd3d fix(parser): change diagnostic to "modifier cannot be used here" (#3853) 2024-06-23 15:14:27 +00:00
Boshen
97d59fc2f3 refactor(parser): move code around for parsing Modifiers (#3849) 2024-06-23 12:46:42 +00:00
Boshen
ae09a97a09
refactor(ast)!: remove Modifiers from ts nodes (#3846) 2024-06-23 19:44:35 +08:00