Merge branch 'oxc-project:main' into linter/order

oxc-project · Jan 9, 2025 · 50fdf58 · 50fdf58
2 parents 2c4a972 + fd35866
commit 50fdf58
Show file tree

Hide file tree

Showing 609 changed files with 6,059 additions and 4,306 deletions.
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -14,6 +14,23 @@
         "SERVER_PATH_DEV": "${workspaceRoot}/target/debug/oxc_language_server",
         "RUST_LOG": "debug"
       }
+    },
+    {
+      "type": "lldb",
+      "request": "launch",
+      "name": "Debug Oxlint",
+      "cargo": {
+        "env": {
+          "RUSTFLAGS": "-g"
+        },
+        "args": ["build", "--bin=oxlint", "--package=oxlint"],
+        "filter": {
+          "name": "oxlint",
+          "kind": "bin"
+        }
+      }
+      // "args": ["--ARGS-TO-OXLINT"],
+      // "cwd": "PATH-TO-TEST-PROJECT"
     }
   ]
 }
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,7 +11,7 @@ homepage = "https://oxc.rs"
 keywords = ["JavaScript", "TypeScript", "linter", "minifier", "parser"]
 license = "MIT"
 repository = "https://github.com/oxc-project/oxc"
-rust-version = "1.78" # Support last 6 minor versions.
+rust-version = "1.79" # Support last 6 minor versions.
 description = "A collection of JavaScript tools written in Rust."
 
 # <https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html>

diff --git a/crates/oxc_allocator/src/vec.rs b/crates/oxc_allocator/src/vec.rs
@@ -245,15 +245,24 @@ impl<'alloc, T> IntoIterator for Vec<'alloc, T> {
     }
 }
 
-impl<'alloc, T> IntoIterator for &'alloc Vec<'alloc, T> {
-    type IntoIter = std::slice::Iter<'alloc, T>;
-    type Item = &'alloc T;
+impl<'i, T> IntoIterator for &'i Vec<'_, T> {
+    type IntoIter = std::slice::Iter<'i, T>;
+    type Item = &'i T;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.iter()
     }
 }
 
+impl<'i, T> IntoIterator for &'i mut Vec<'_, T> {
+    type IntoIter = std::slice::IterMut<'i, T>;
+    type Item = &'i mut T;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter_mut()
+    }
+}
+
 impl<T, I> ops::Index<I> for Vec<'_, T>
 where
     I: SliceIndex<[T]>,

diff --git a/crates/oxc_ast/src/ast_impl/js.rs b/crates/oxc_ast/src/ast_impl/js.rs
@@ -263,6 +263,18 @@ impl<'a> Expression<'a> {
         matches!(self, Expression::FunctionExpression(_) | Expression::ArrowFunctionExpression(_))
     }
 
+    /// Returns `true` if this [`Expression`] is an anonymous function definition.
+    /// Note that this includes [`Class`]s.
+    /// <https://262.ecma-international.org/15.0/#sec-isanonymousfunctiondefinition>
+    pub fn is_anonymous_function_definition(&self) -> bool {
+        match self {
+            Self::ArrowFunctionExpression(_) => true,
+            Self::FunctionExpression(func) => func.name().is_none(),
+            Self::ClassExpression(class) => class.name().is_none(),
+            _ => false,
+        }
+    }
+
     /// Returns `true` if this [`Expression`] is a [`CallExpression`].
     pub fn is_call_expression(&self) -> bool {
         matches!(self, Expression::CallExpression(_))
@@ -1160,7 +1172,13 @@ impl<'a> ArrowFunctionExpression<'a> {
     }
 }
 
-impl Class<'_> {
+impl<'a> Class<'a> {
+    /// Returns this [`Class`]'s name, if it has one.
+    #[inline]
+    pub fn name(&self) -> Option<Atom<'a>> {
+        self.id.as_ref().map(|id| id.name.clone())
+    }
+
     /// `true` if this [`Class`] is an expression.
     ///
     /// For example,
@@ -1479,7 +1497,7 @@ impl ExportNamedDeclaration<'_> {
     #[allow(missing_docs)]
     pub fn is_typescript_syntax(&self) -> bool {
         self.export_kind == ImportOrExportKind::Type
-            || self.declaration.as_ref().map_or(false, Declaration::is_typescript_syntax)
+            || self.declaration.as_ref().is_some_and(Declaration::is_typescript_syntax)
     }
 }
 

diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs
@@ -172,7 +172,6 @@ impl Gen for Statement<'_> {
                 p.print_statement_comments(stmt.span.start);
                 stmt.print(p, ctx);
             }
-
             Self::ImportDeclaration(decl) => {
                 p.print_statement_comments(decl.span.start);
                 decl.print(p, ctx);
@@ -197,7 +196,6 @@ impl Gen for Statement<'_> {
                 p.print_statement_comments(decl.span.start);
                 decl.print(p, ctx);
             }
-
             Self::VariableDeclaration(decl) => {
                 p.print_statement_comments(decl.span.start);
                 p.print_indent();
@@ -273,6 +271,7 @@ impl Gen for IfStatement<'_> {
 }
 
 fn print_if(if_stmt: &IfStatement<'_>, p: &mut Codegen, ctx: Context) {
+    p.print_space_before_identifier();
     p.print_str("if");
     p.print_soft_space();
     p.print_ascii_byte(b'(');
@@ -362,6 +361,7 @@ impl Gen for ForStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("for");
         p.print_soft_space();
         p.print_ascii_byte(b'(');
@@ -393,6 +393,7 @@ impl Gen for ForInStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("for");
         p.print_soft_space();
         p.print_ascii_byte(b'(');
@@ -411,6 +412,7 @@ impl Gen for ForOfStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("for");
         if self.r#await {
             p.print_str(" await");
@@ -458,6 +460,7 @@ impl Gen for WhileStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("while");
         p.print_soft_space();
         p.print_ascii_byte(b'(');
@@ -471,17 +474,23 @@ impl Gen for DoWhileStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
-        p.print_str("do ");
-        if let Statement::BlockStatement(block) = &self.body {
-            p.print_block_statement(block, ctx);
-            p.print_soft_space();
-        } else {
-            p.print_soft_newline();
-            p.indent();
-            self.body.print(p, ctx);
-            p.print_semicolon_if_needed();
-            p.dedent();
-            p.print_indent();
+        p.print_space_before_identifier();
+        p.print_str("do");
+        match &self.body {
+            Statement::BlockStatement(block) => {
+                p.print_soft_space();
+                p.print_block_statement(block, ctx);
+                p.print_soft_space();
+            }
+            Statement::EmptyStatement(s) => s.print(p, ctx),
+            _ => {
+                p.print_soft_newline();
+                p.indent();
+                self.body.print(p, ctx);
+                p.print_semicolon_if_needed();
+                p.dedent();
+                p.print_indent();
+            }
         }
         p.print_str("while");
         p.print_soft_space();
@@ -505,6 +514,7 @@ impl Gen for ContinueStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("continue");
         if let Some(label) = &self.label {
             p.print_soft_space();
@@ -518,6 +528,7 @@ impl Gen for BreakStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("break");
         if let Some(label) = &self.label {
             p.print_soft_space();
@@ -531,6 +542,7 @@ impl Gen for SwitchStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("switch");
         p.print_soft_space();
         p.print_ascii_byte(b'(');
@@ -638,6 +650,7 @@ impl Gen for ThrowStatement<'_> {
     fn gen(&self, p: &mut Codegen, _ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("throw");
         p.print_soft_space();
         p.print_expression(&self.argument);
@@ -649,6 +662,7 @@ impl Gen for WithStatement<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("with");
         p.print_ascii_byte(b'(');
         p.print_expression(&self.object);
@@ -661,6 +675,7 @@ impl Gen for DebuggerStatement {
     fn gen(&self, p: &mut Codegen, _ctx: Context) {
         p.add_source_mapping(self.span);
         p.print_indent();
+        p.print_space_before_identifier();
         p.print_str("debugger");
         p.print_semicolon_after_statement();
     }
@@ -669,6 +684,7 @@ impl Gen for DebuggerStatement {
 impl Gen for VariableDeclaration<'_> {
     fn gen(&self, p: &mut Codegen, ctx: Context) {
         p.add_source_mapping(self.span);
+        p.print_space_before_identifier();
         if self.declare {
             p.print_str("declare ");
         }
@@ -1308,9 +1324,9 @@ impl GenExpr for NumericLiteral<'_> {
 
 impl GenExpr for BigIntLiteral<'_> {
     fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, _ctx: Context) {
-        let raw = self.raw.as_str().cow_replace('_', "");
-
+        p.print_space_before_identifier();
         p.add_source_mapping(self.span);
+        let raw = self.raw.as_str().cow_replace('_', "");
         if !raw.starts_with('-') {
             p.print_str(&raw);
         } else if precedence >= Precedence::Prefix {

diff --git a/crates/oxc_codegen/tests/integration/unit.rs b/crates/oxc_codegen/tests/integration/unit.rs
@@ -87,6 +87,26 @@ fn for_stmt() {
     );
 }
 
+#[test]
+fn do_while_stmt() {
+    test("do ; while (true)", "do;\nwhile (true);\n");
+    test_minify("do ; while (true)", "do;while(true);");
+    test_minify("do break; while (true)", "do break;while(true);");
+    test_minify("do continue; while (true)", "do continue;while(true);");
+    test_minify("do debugger; while (true)", "do debugger;while(true);");
+    test_minify("do for(x in y); while (true)", "do for(x in y);while(true);");
+    test_minify("do for(x of y); while (true)", "do for(x of y);while(true);");
+    test_minify("do for(;;); while (true)", "do for(;;);while(true);");
+    test_minify("do if (test) {} while (true)", "do if(test){}while(true);");
+    test_minify("do foo:; while (true)", "do foo:;while(true);");
+    test_minify("do return; while (true)", "do return;while(true);");
+    test_minify("do switch(test){} while (true)", "do switch(test){}while(true);");
+    test_minify("do throw x; while (true)", "do throw x;while(true);");
+    test_minify("do with(x); while (true)", "do with(x);while(true);");
+    test_minify("do try{} catch{} while (true)", "do try{}catch{}while(true);");
+    test_minify("do do ; while(true) while (true)", "do do;while(true);while(true);");
+}
+
 #[test]
 fn if_stmt() {
     test(
@@ -382,6 +402,9 @@ fn big_int() {
     test("0xfabn", "0xfabn;\n");
     test("0xaef_en;", "0xaefen;\n");
     test("0xaefen;", "0xaefen;\n");
+
+    test("return 1n", "return 1n;\n");
+    test_minify("return 1n", "return 1n;");
 }
 
 #[test]

diff --git a/crates/oxc_data_structures/src/stack/mod.rs b/crates/oxc_data_structures/src/stack/mod.rs
@@ -1,8 +1,11 @@
 //! Contains the following FILO data structures:
-//! - [`Stack`]: A growable stack
-//! - [`SparseStack`]: A stack that can have empty entries
-//! - [`NonEmptyStack`]: A growable stack that can never be empty, allowing for more efficient
-//!  operations
+//!
+//! * [`Stack`]: A growable stack, equivalent to [`Vec`], but more efficient for stack usage (push/pop).
+//! * [`NonEmptyStack`]: A growable stack that can never be empty, allowing for more efficient operations
+//!   (very fast `last` / `last_mut`).
+//! * [`SparseStack`]: A growable stack of `Option`s, optimized for low memory usage when many entries in
+//!   the stack are empty (`None`).
+
 mod capacity;
 mod common;
 mod non_empty;