feat(assist): import organizer revamping

Author: Conaclos

crates/biome_js_analyze/src/assist/source/organize_imports.rs

@@ -0,0 +1,39 @@
+use std::cmp::Ordering;
+
+use biome_rowan::TokenText;
+use biome_string_case::StrLikeExtension;
+
+/// A [JsSyntaxToken] that is ordered according to the ASCII natural order.
+#[derive(Clone, Debug)]
+pub struct ComparableToken(pub TokenText);
+impl From<TokenText> for ComparableToken {
+    fn from(value: TokenText) -> Self {
+        Self(value)
+    }
+}
+impl AsRef<str> for ComparableToken {
+    fn as_ref(&self) -> &str {
+        self.0.text()
+    }
+}
+impl Eq for ComparableToken {}
+impl PartialEq for ComparableToken {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.text() == other.0.text()
+    }
+}
+impl std::hash::Hash for ComparableToken {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.text().hash(state);
+    }
+}
+impl Ord for ComparableToken {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0.text().ascii_nat_cmp(other.0.text())
+    }
+}
+impl PartialOrd for ComparableToken {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}

crates/biome_js_analyze/src/assist/source/organize_imports/comparable_token.rs

@@ -0,0 +1,117 @@
+use biome_deserialize::{Deserializable, DeserializationContext, Text};
+use biome_deserialize_macros::Deserializable;
+use biome_glob::{CandidatePath, Glob};
+
+use crate::globals::is_node_builtin_module;
+
+#[derive(
+    Clone, Debug, Default, Deserializable, Eq, PartialEq, serde::Deserialize, serde::Serialize,
+)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub struct ImportGroups(Box<[ImportGroup]>);
+impl ImportGroups {
+    /// Returns the index of the first group containing `candidate`.
+    /// If no group contains `candidate`, then the returned value corresponds to the index of the implicit group.
+    /// The index of the implicit group correspond to the number of groups.
+    pub fn index(&self, candidate: &ImportSourceCandidate) -> usize {
+        self.0
+            .iter()
+            .position(|group| group.contains(candidate))
+            .unwrap_or(self.0.len())
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum ImportGroup {
+    Predefined(PredefinedImportGroup),
+    Glob(Box<ImportSourceGlob>),
+    GlobList(Box<[ImportSourceGlob]>),
+}
+impl ImportGroup {
+    pub fn contains(&self, candidate: &ImportSourceCandidate) -> bool {
+        match self {
+            ImportGroup::Predefined(predefined) => predefined.contains(candidate),
+            ImportGroup::Glob(glob) => {
+                // TODO: use `is_match_candidate` instead?
+                glob.is_match(candidate)
+            }
+            ImportGroup::GlobList(globs) => candidate
+                .path_candidate
+                .matches_with_exceptions(globs.iter().map(|glob| &glob.0)),
+        }
+    }
+}
+impl Deserializable for ImportGroup {
+    fn deserialize(
+        ctx: &mut impl DeserializationContext,
+        value: &impl biome_deserialize::DeserializableValue,
+        name: &str,
+    ) -> Option<Self> {
+        if value.visitable_type() == Some(biome_deserialize::DeserializableType::Str) {
+            let value_text = Text::deserialize(ctx, value, name)?;
+            if value_text.starts_with(':') && value_text.ends_with(':') {
+                Deserializable::deserialize(ctx, value, name).map(ImportGroup::Predefined)
+            } else {
+                Deserializable::deserialize(ctx, value, name).map(ImportGroup::Glob)
+            }
+        } else {
+            Deserializable::deserialize(ctx, value, name).map(ImportGroup::GlobList)
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserializable, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub enum PredefinedImportGroup {
+    #[serde(rename = ":BUN:")]
+    Bun,
+    #[serde(rename = ":NODE:")]
+    Node,
+}
+impl PredefinedImportGroup {
+    fn contains(&self, candidate: &ImportSourceCandidate) -> bool {
+        let import_source = candidate.as_str();
+        match self {
+            Self::Bun => import_source == "bun" || import_source.starts_with("bun:"),
+            Self::Node => {
+                import_source.starts_with("node:") || is_node_builtin_module(import_source)
+            }
+        }
+    }
+}
+
+/// Glob to match against import sources.
+#[derive(Clone, Debug, Deserializable, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub struct ImportSourceGlob(Glob);
+impl ImportSourceGlob {
+    /// Tests whether the given import source matches this pattern or not.
+    pub fn is_match(&self, import_source: &ImportSourceCandidate) -> bool {
+        import_source.path_candidate.matches(&self.0)
+    }
+}
+
+/// A candidate import source for matching.
+///
+/// Constructing candidates has a very small cost associated with it.
+/// The cost is amortized by matching against several import source globs.
+pub struct ImportSourceCandidate<'a> {
+    import_source: &'a str,
+    path_candidate: CandidatePath<'a>,
+}
+impl<'a> ImportSourceCandidate<'a> {
+    /// Create a new candidate for matching from the given path.
+    pub fn new(import_source: &'a str) -> Self {
+        Self {
+            import_source,
+            path_candidate: CandidatePath::new(import_source),
+        }
+    }
+
+    /// Returns the original string of this import source.
+    pub fn as_str(&self) -> &str {
+        self.import_source
+    }
+}

crates/biome_js_analyze/src/assist/source/organize_imports/import_groups.rs

@@ -0,0 +1,225 @@
+use biome_js_syntax::{
+    AnyJsCombinedSpecifier, AnyJsExportClause, AnyJsImportClause, AnyJsModuleItem,
+    AnyJsModuleSource, JsExport, JsImport, JsImportAssertion,
+};
+use biome_rowan::AstNode;
+
+use super::{
+    comparable_token::ComparableToken, import_groups, import_source,
+    specifiers_attributes::JsNamedSpecifiers,
+};
+
+/// Type used to determine the order between imports
+#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct ImportKey {
+    pub group: u16,
+    pub source: import_source::ImportSource<ComparableToken>,
+    pub has_no_attributes: bool,
+    pub kind: ImportStatementKind,
+    /// Slot index of the import in the module.
+    /// This is used as a last resort for ensuring a strict total order between imports.
+    pub slot_index: u32,
+}
+impl ImportKey {
+    pub fn new(info: ImportInfo, groups: &import_groups::ImportGroups) -> Self {
+        let candidate = import_groups::ImportSourceCandidate::new(info.source.inner().0.text());
+        Self {
+            group: groups.index(&candidate) as u16,
+            source: info.source,
+            has_no_attributes: info.has_no_attributes,
+            kind: info.kind,
+            slot_index: info.slot_index,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[enumflags2::bitflags]
+#[repr(u8)]
+pub enum ImportStatementKind {
+    DefaultType = 1 << 0,
+    Default = 1 << 1,
+    DefaultNamespace = 1 << 2,
+    DefaultNamed = 1 << 3,
+    NamespaceType = 1 << 4,
+    Namespace = 1 << 5,
+    NamedType = 1 << 6,
+    Named = 1 << 7,
+}
+impl ImportStatementKind {
+    pub fn has_type_token(self) -> bool {
+        (ImportStatementKind::DefaultType
+            | ImportStatementKind::NamespaceType
+            | ImportStatementKind::NamedType)
+            .contains(self)
+    }
+
+    pub fn is_mergeable(self, kinds: ImportStatementKinds) -> bool {
+        match self {
+            ImportStatementKind::DefaultNamed => kinds.contains(ImportStatementKind::Named),
+            ImportStatementKind::Named => kinds
+                .0
+                .intersects(ImportStatementKind::DefaultNamed | ImportStatementKind::Named),
+            ImportStatementKind::NamedType => kinds.contains(ImportStatementKind::NamedType),
+            _ => false,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ImportStatementKinds(enumflags2::BitFlags<ImportStatementKind>);
+impl ImportStatementKinds {
+    pub fn contains(self, kind: ImportStatementKind) -> bool {
+        self.0.contains(kind)
+    }
+
+    pub fn insert(&mut self, kind: ImportStatementKind) {
+        self.0 |= kind;
+    }
+
+    pub fn clear(&mut self) {
+        self.0 = Default::default();
+    }
+}
+
+/// Type that gathers information extracted from an import or an export.
+#[derive(Debug)]
+pub struct ImportInfo {
+    /// Slot index of the import in the module.
+    pub slot_index: u32,
+    pub kind: ImportStatementKind,
+    pub source: import_source::ImportSource<ComparableToken>,
+    pub has_no_attributes: bool,
+}
+impl ImportInfo {
+    pub fn from_module_item(
+        item: &AnyJsModuleItem,
+    ) -> Option<(Self, Option<JsNamedSpecifiers>, Option<JsImportAssertion>)> {
+        match item {
+            AnyJsModuleItem::AnyJsStatement(_) => None,
+            AnyJsModuleItem::JsExport(export) => Self::from_export(export),
+            AnyJsModuleItem::JsImport(import) => Self::from_import(import),
+        }
+    }
+
+    fn from_import(
+        value: &JsImport,
+    ) -> Option<(Self, Option<JsNamedSpecifiers>, Option<JsImportAssertion>)> {
+        let (kind, named_specifiers, source, attributes) = match value.import_clause().ok()? {
+            AnyJsImportClause::JsImportBareClause(_) => {
+                return None;
+            }
+            AnyJsImportClause::JsImportCombinedClause(clause) => {
+                let (kind, named_specifiers) = match clause.specifier().ok()? {
+                    AnyJsCombinedSpecifier::JsNamedImportSpecifiers(specifiers) => {
+                        (ImportStatementKind::DefaultNamed, Some(specifiers))
+                    }
+                    AnyJsCombinedSpecifier::JsNamespaceImportSpecifier(_) => {
+                        (ImportStatementKind::DefaultNamespace, None)
+                    }
+                };
+                (kind, named_specifiers, clause.source(), clause.assertion())
+            }
+            AnyJsImportClause::JsImportDefaultClause(clause) => (
+                if clause.type_token().is_some() {
+                    ImportStatementKind::DefaultType
+                } else {
+                    ImportStatementKind::Default
+                },
+                None,
+                clause.source(),
+                clause.assertion(),
+            ),
+            AnyJsImportClause::JsImportNamedClause(clause) => {
+                let named_specifiers = clause.named_specifiers().ok();
+                (
+                    if clause.type_token().is_some() {
+                        ImportStatementKind::NamedType
+                    } else {
+                        ImportStatementKind::Named
+                    },
+                    named_specifiers,
+                    clause.source(),
+                    clause.assertion(),
+                )
+            }
+            AnyJsImportClause::JsImportNamespaceClause(clause) => (
+                if clause.type_token().is_some() {
+                    ImportStatementKind::NamespaceType
+                } else {
+                    ImportStatementKind::Namespace
+                },
+                None,
+                clause.source(),
+                clause.assertion(),
+            ),
+        };
+        let Ok(AnyJsModuleSource::JsModuleSource(source)) = source else {
+            return None;
+        };
+        Some((
+            Self {
+                source: ComparableToken(source.inner_string_text().ok()?).into(),
+                has_no_attributes: attributes.is_none(),
+                kind,
+                slot_index: value.syntax().index() as u32,
+            },
+            named_specifiers.map(JsNamedSpecifiers::JsNamedImportSpecifiers),
+            attributes,
+        ))
+    }
+
+    fn from_export(
+        value: &JsExport,
+    ) -> Option<(Self, Option<JsNamedSpecifiers>, Option<JsImportAssertion>)> {
+        let (kind, _first_local_name, named_specifiers, source, attributes) =
+            match value.export_clause().ok()? {
+                AnyJsExportClause::JsExportFromClause(clause) => (
+                    if clause.type_token().is_some() {
+                        ImportStatementKind::NamespaceType
+                    } else {
+                        ImportStatementKind::Namespace
+                    },
+                    clause
+                        .export_as()
+                        .and_then(|export_as| export_as.exported_name().ok()),
+                    None,
+                    clause.source(),
+                    clause.assertion(),
+                ),
+                AnyJsExportClause::JsExportNamedFromClause(clause) => (
+                    if clause.type_token().is_some() {
+                        ImportStatementKind::NamedType
+                    } else {
+                        ImportStatementKind::Named
+                    },
+                    clause
+                        .specifiers()
+                        .into_iter()
+                        .flatten()
+                        .next()
+                        .and_then(|x| x.source_name().ok()),
+                    Some(clause.specifiers()),
+                    clause.source(),
+                    clause.assertion(),
+                ),
+                _ => {
+                    return None;
+                }
+            };
+        let Ok(AnyJsModuleSource::JsModuleSource(source)) = source else {
+            return None;
+        };
+        let source = source.inner_string_text().ok()?;
+        Some((
+            Self {
+                source: ComparableToken(source).into(),
+                has_no_attributes: attributes.is_none(),
+                kind,
+                slot_index: value.syntax().index() as u32,
+            },
+            named_specifiers.map(JsNamedSpecifiers::JsExportNamedFromSpecifierList),
+            attributes,
+        ))
+    }
+}