feat(parser,linter)!: use a different ModuleRecord for linter (#7554)

The parser returns a simple `ModuleRecord` that is allocated in the arena for performance reasons.

The linter uses a more complicated, `Send` + `Sync` `ModuleRecord` that will hold more cross-module information.

The next step is to return more esm information from the parser to eliminated the need of the `oxc_module_lexer` crate.

crates/oxc_language_server/src/linter.rs

@@ -13,7 +13,7 @@ use oxc_allocator::Allocator;
 use oxc_diagnostics::{Error, NamedSource, Severity};
 use oxc_linter::{
     loader::{JavaScriptSource, Loader},
-    FixKind, Linter,
+    FixKind, Linter, ModuleRecord,
 };
 use oxc_parser::{ParseOptions, Parser};
 use oxc_semantic::SemanticBuilder;
@@ -290,7 +290,7 @@ impl IsolatedLintHandler {
                 return Some(Self::wrap_diagnostics(path, &source_text, reports, start));
             };
 
-            let module_record = Arc::new(ret.module_record);
+            let module_record = Arc::new(ModuleRecord::new(path, &ret.module_record));
             let mut semantic = semantic_ret.semantic;
             semantic.set_irregular_whitespaces(ret.irregular_whitespaces);
             let result = self.linter.run(path, Rc::new(semantic), module_record);

crates/oxc_linter/src/context/host.rs

@@ -2,13 +2,13 @@ use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc};
 
 use oxc_semantic::Semantic;
 use oxc_span::SourceType;
-use oxc_syntax::module_record::ModuleRecord;
 
 use crate::{
     config::{LintConfig, LintPlugins},
     disable_directives::{DisableDirectives, DisableDirectivesBuilder},
     fixer::{FixKind, Message},
     frameworks,
+    module_record::ModuleRecord,
     options::LintOptions,
     utils, FrameworkFlags, RuleWithSeverity,
 };

crates/oxc_linter/src/context/mod.rs

@@ -7,15 +7,14 @@ use oxc_cfg::ControlFlowGraph;
 use oxc_diagnostics::{OxcDiagnostic, Severity};
 use oxc_semantic::Semantic;
 use oxc_span::{GetSpan, Span};
-use oxc_syntax::module_record::ModuleRecord;
 
 #[cfg(debug_assertions)]
 use crate::rule::RuleFixMeta;
 use crate::{
     disable_directives::DisableDirectives,
     fixer::{FixKind, Message, RuleFix, RuleFixer},
     javascript_globals::GLOBALS,
-    AllowWarnDeny, FrameworkFlags, OxlintEnv, OxlintGlobals, OxlintSettings,
+    AllowWarnDeny, FrameworkFlags, ModuleRecord, OxlintEnv, OxlintGlobals, OxlintSettings,
 };
 
 pub(crate) use host::ContextHost;

crates/oxc_linter/src/frameworks.rs

@@ -1,7 +1,8 @@
 use std::{hash, path::Path};
 
 use bitflags::bitflags;
-use oxc_syntax::module_record::ModuleRecord;
+
+use crate::ModuleRecord;
 
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/oxc_linter/src/lib.rs

@@ -12,6 +12,8 @@ mod fixer;
 mod frameworks;
 mod globals;
 mod javascript_globals;
+mod module_graph_visitor;
+mod module_record;
 mod options;
 mod rule;
 mod rules;
@@ -24,14 +26,14 @@ pub mod table;
 use std::{io::Write, path::Path, rc::Rc, sync::Arc};
 
 use oxc_semantic::{AstNode, Semantic};
-use oxc_syntax::module_record::ModuleRecord;
 
 pub use crate::{
     builder::{LinterBuilder, LinterBuilderError},
     config::{ESLintRule, LintPlugins, Oxlintrc},
     context::LintContext,
     fixer::FixKind,
     frameworks::FrameworkFlags,
+    module_record::ModuleRecord,
     options::{AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind},
     rule::{RuleCategory, RuleFixMeta, RuleMeta, RuleWithSeverity},
     service::{LintService, LintServiceOptions},

crates/oxc_syntax/src/module_graph_visitor.rs → crates/oxc_linter/src/module_graph_visitor.rs

@@ -4,7 +4,7 @@ use std::{marker::PhantomData, path::PathBuf, sync::Arc};
 use oxc_span::CompactStr;
 use rustc_hash::FxHashSet;
 
-use crate::module_record::ModuleRecord;
+use crate::ModuleRecord;
 
 type ModulePair<'a> = (&'a CompactStr, &'a Arc<ModuleRecord>);
 
@@ -73,19 +73,19 @@ impl<'a, T> ModuleGraphVisitorBuilder<'a, T> {
         self
     }
 
-    /// Sets the enter module event closure.
-    #[must_use]
-    pub fn enter<F: FnMut(ModulePair, &ModuleRecord) + 'a>(mut self, enter: F) -> Self {
-        self.enter = Some(Box::new(enter));
-        self
-    }
+    // /// Sets the enter module event closure.
+    // #[must_use]
+    // pub fn enter<F: FnMut(ModulePair, &ModuleRecord) + 'a>(mut self, enter: F) -> Self {
+    // self.enter = Some(Box::new(enter));
+    // self
+    // }
 
-    /// Sets the leave module event closure.
-    #[must_use]
-    pub fn leave<F: FnMut(ModulePair, &ModuleRecord) + 'a>(mut self, leave: F) -> Self {
-        self.leave = Some(Box::new(leave));
-        self
-    }
+    // /// Sets the leave module event closure.
+    // #[must_use]
+    // pub fn leave<F: FnMut(ModulePair, &ModuleRecord) + 'a>(mut self, leave: F) -> Self {
+    // self.leave = Some(Box::new(leave));
+    // self
+    // }
 
     /// Behaves similar to a flat fold_while iteration.
     pub fn visit_fold<V: Fn(T, ModulePair, &ModuleRecord) -> VisitFoldWhile<T>>(
@@ -125,13 +125,13 @@ impl<T> Default for ModuleGraphVisitorBuilder<'_, T> {
 
 pub struct ModuleGraphVisitResult<T> {
     pub result: T,
-    pub traversed: FxHashSet<PathBuf>,
-    pub max_depth: u32,
+    pub _traversed: FxHashSet<PathBuf>,
+    pub _max_depth: u32,
 }
 
 impl<T> ModuleGraphVisitResult<T> {
     fn with_result(result: T, visitor: ModuleGraphVisitor) -> Self {
-        Self { result, traversed: visitor.traversed, max_depth: visitor.max_depth }
+        Self { result, _traversed: visitor.traversed, _max_depth: visitor.max_depth }
     }
 }