mason: preserve ES import attribute clauses during regeneration

Model verbatim with/assert clauses in parsing, deduplication, and every ES import rewrite path. Biome preserves the attribute while reordering the same fixture, so stripping it is not an accepted organizer tradeoff like evaluation ordering.

Author: ualtinok

crates/aft/src/commands/add_import.rs

@@ -332,11 +332,15 @@ pub fn handle_add_import(req: &RawRequest, ctx: &AppContext) -> Response {
             LangId::TypeScript | LangId::Tsx | LangId::JavaScript | LangId::Python | LangId::Rust
         ) {
         block.imports.iter().find(|imp| {
+            let es_import = matches!(
+                lang,
+                LangId::TypeScript | LangId::Tsx | LangId::JavaScript | LangId::Vue
+            );
             imp.module_path == module
                 && imp.kind == target_kind
                 && imp.namespace_import.is_none()
-                && imp.default_import.is_none()
-                && !imp.names.is_empty()
+                && (es_import || imp.default_import.is_none())
+                && (es_import || !imp.names.is_empty())
                 && (lang != LangId::Python
                     || matches!(
                         imp.form,
@@ -374,12 +378,14 @@ pub fn handle_add_import(req: &RawRequest, ctx: &AppContext) -> Response {
         // Build the merged named-import list: union of existing + new, sorted.
         let merged_names = merge_named_import_specifiers(&existing.names, &names);
 
-        let merged_line = imports::generate_import_line(
+        let merged_line = imports::generate_import_line_with_namespace_and_attribute_clause(
             lang,
             &existing.module_path,
             &merged_names,
-            None,
+            existing.default_import.as_deref(),
+            existing.namespace_import.as_deref(),
             type_only,
+            imports::es_import_attribute_clause(existing),
         );
         (
             existing.byte_range.start,
@@ -388,13 +394,14 @@ pub fn handle_add_import(req: &RawRequest, ctx: &AppContext) -> Response {
             true,
         )
     } else if let Some(existing) = namespace_merge_target {
-        let merged_line = imports::generate_import_line_with_namespace(
+        let merged_line = imports::generate_import_line_with_namespace_and_attribute_clause(
             lang,
             &existing.module_path,
             &existing.names,
             existing.default_import.as_deref(),
             namespace.as_deref(),
             type_only,
+            imports::es_import_attribute_clause(existing),
         );
         (
             existing.byte_range.start,
@@ -462,6 +469,30 @@ pub fn handle_add_import(req: &RawRequest, ctx: &AppContext) -> Response {
         let import_line = if matches!(lang, LangId::Go) {
             let in_group = imports::go_offset_is_in_grouped_import(&source, &tree, insert_offset);
             imports::generate_go_import_line_pub(module, default_import.as_deref(), in_group)
+        } else if matches!(
+            lang,
+            LangId::TypeScript | LangId::Tsx | LangId::JavaScript | LangId::Vue
+        ) {
+            // Import attributes select the module type. A new sibling import of
+            // an already-attributed module must carry the same clause or runtimes
+            // such as Node reject that sibling before loading the module.
+            let mut clauses = block
+                .imports
+                .iter()
+                .filter(|imp| imp.module_path == module)
+                .filter_map(imports::es_import_attribute_clause);
+            let inherited_clause = clauses
+                .next()
+                .filter(|first| clauses.all(|item| item == *first));
+            imports::generate_import_line_with_namespace_and_attribute_clause(
+                lang,
+                module,
+                &names,
+                default_import.as_deref(),
+                namespace.as_deref(),
+                type_only,
+                inherited_clause,
+            )
         } else {
             imports::generate_import(lang, &import_request)
         };

crates/aft/src/commands/move_symbol.rs

@@ -1202,22 +1202,29 @@ fn rewrite_consumer_imports(
         };
 
         let type_only = imp.kind == imports::ImportKind::Type;
-        let moved_import =
-            generate_import_for_bindings(lang, &new_import_path, &moved_bindings, type_only);
+        let attribute_clause = imports::es_import_attribute_clause(imp);
+        let moved_import = generate_import_for_bindings(
+            lang,
+            &new_import_path,
+            &moved_bindings,
+            type_only,
+            attribute_clause,
+        );
 
         if remaining_names.is_empty()
             && remaining_default.is_none()
             && remaining_namespace.is_none()
         {
             edits.push((imp.byte_range.clone(), moved_import));
         } else {
-            let kept_import = imports::generate_import_line_with_namespace(
+            let kept_import = imports::generate_import_line_with_namespace_and_attribute_clause(
                 lang,
                 &imp.module_path,
                 &remaining_names,
                 remaining_default.as_deref(),
                 remaining_namespace.as_deref(),
                 type_only,
+                attribute_clause,
             );
             edits.push((
                 imp.byte_range.clone(),
@@ -1734,14 +1741,16 @@ fn generate_import_for_bindings(
     module_path: &str,
     bindings: &MovedImportBindings,
     type_only: bool,
+    attribute_clause: Option<&str>,
 ) -> String {
-    imports::generate_import_line_with_namespace(
+    imports::generate_import_line_with_namespace_and_attribute_clause(
         lang,
         module_path,
         &bindings.named,
         bindings.default_import.as_deref(),
         bindings.namespace_import.as_deref(),
         type_only,
+        attribute_clause,
     )
 }
 
@@ -1783,10 +1792,11 @@ fn build_add_moved_import_edit(
     // imported. Preserve the existing module spelling (for example `./dest.js`).
     if !moved_symbol_is_default {
         if let Some(existing) = block.imports.iter().find(|import| {
+            let es_import = matches!(lang, LangId::TypeScript | LangId::Tsx | LangId::JavaScript);
             import.kind == imports::ImportKind::Value
                 && import.namespace_import.is_none()
-                && import.default_import.is_none()
-                && !import.names.is_empty()
+                && (es_import || import.default_import.is_none())
+                && (es_import || !import.names.is_empty())
                 && import_path_matches_file(&import.module_path, consumer_file, dest_file)
         }) {
             let requested = &names[0];
@@ -1801,12 +1811,14 @@ fn build_add_moved_import_edit(
 
             let merged_names =
                 super::add_import::merge_named_import_specifiers(&existing.names, &names);
-            let merged_line = imports::generate_import_line(
+            let merged_line = imports::generate_import_line_with_namespace_and_attribute_clause(
                 lang,
                 &existing.module_path,
                 &merged_names,
-                None,
+                existing.default_import.as_deref(),
+                existing.namespace_import.as_deref(),
                 false,
+                imports::es_import_attribute_clause(existing),
             );
             return Some((existing.byte_range.clone(), merged_line));
         }
@@ -1815,8 +1827,29 @@ fn build_add_moved_import_edit(
     let group = imports::classify_group(lang, &new_import_path);
     let (insert_offset, needs_blank_before, needs_blank_after) =
         imports::find_insertion_point(content, block, group, &new_import_path, false);
-    let import_line =
-        imports::generate_import_line(lang, &new_import_path, &names, default_import, false);
+    let import_line = if matches!(lang, LangId::TypeScript | LangId::Tsx | LangId::JavaScript) {
+        let mut clauses = block
+            .imports
+            .iter()
+            .filter(|import| {
+                import_path_matches_file(&import.module_path, consumer_file, dest_file)
+            })
+            .filter_map(imports::es_import_attribute_clause);
+        let inherited_clause = clauses
+            .next()
+            .filter(|first| clauses.all(|item| item == *first));
+        imports::generate_import_line_with_namespace_and_attribute_clause(
+            lang,
+            &new_import_path,
+            &names,
+            default_import,
+            None,
+            false,
+            inherited_clause,
+        )
+    } else {
+        imports::generate_import_line(lang, &new_import_path, &names, default_import, false)
+    };
 
     let mut insert_text = String::new();
     if needs_blank_before {

crates/aft/src/commands/organize_imports.rs

@@ -643,6 +643,7 @@ fn organized_from_statement(imp: &ImportStatement, lang: LangId) -> OrganizedImp
         default_import: imp.default_import.clone(),
         namespace_import: imp.namespace_import.clone(),
         kind: imp.kind,
+        attribute_clause: imports::es_import_attribute_clause(imp).map(str::to_string),
         raw_override,
     }
 }
@@ -681,6 +682,7 @@ struct OrganizedImport {
     default_import: Option<String>,
     namespace_import: Option<String>,
     kind: ImportKind,
+    attribute_clause: Option<String>,
     /// When set, the import is rendered verbatim from this string instead of
     /// being regenerated from the structured fields. Used by dialect-sensitive
     /// languages (e.g. Scala) where re-rendering would normalize across
@@ -732,22 +734,23 @@ fn organize_generic_group(
     side_effects.extend(sorted);
 
     for imp in side_effects {
-        // Build dedup key: module_path + kind + sorted names + default + namespace.
-        // Namespace imports introduce local bindings, so different aliases are
-        // distinct and side-effect imports are not duplicates of namespace
-        // imports from the same module.
+        // Build dedup key from every semantic part of the import. Import
+        // attributes select the module type, so attributed and unattributed
+        // imports of the same path must remain distinct.
         let names_key = {
             let mut n = imp.names.clone();
             sort_named_specifiers(&mut n);
             n.join(",")
         };
+        let attribute_clause = imports::es_import_attribute_clause(imp);
         let dedup_key = format!(
-            "{}|{:?}|{}|{}|{}",
+            "{}|{:?}|{}|{}|{}|{}",
             imp.module_path,
             imp.kind,
             names_key,
             imp.default_import.as_deref().unwrap_or(""),
-            imp.namespace_import.as_deref().unwrap_or("")
+            imp.namespace_import.as_deref().unwrap_or(""),
+            attribute_clause.unwrap_or("")
         );
 
         if seen.contains(&dedup_key) {
@@ -765,6 +768,7 @@ fn organize_generic_group(
             default_import: imp.default_import.clone(),
             namespace_import: imp.namespace_import.clone(),
             kind: imp.kind,
+            attribute_clause: attribute_clause.map(str::to_string),
             raw_override: None,
         });
     }
@@ -815,6 +819,7 @@ fn organize_raw_preserving_group(
             default_import: imp.default_import.clone(),
             namespace_import: imp.namespace_import.clone(),
             kind: imp.kind,
+            attribute_clause: imports::es_import_attribute_clause(imp).map(str::to_string),
             raw_override: Some(imp.raw_text.trim().to_string()),
         })
         .collect();
@@ -994,6 +999,7 @@ fn organize_rust_group(imps: &[&ImportStatement]) -> (Vec<OrganizedImport>, usiz
                     default_import: up.visibility.clone(),
                     namespace_import: None,
                     kind: up.kind,
+                    attribute_clause: None,
                     raw_override: None,
                 });
             }
@@ -1025,6 +1031,7 @@ fn organize_rust_group(imps: &[&ImportStatement]) -> (Vec<OrganizedImport>, usiz
             default_import: visibility,
             namespace_import: None,
             kind,
+            attribute_clause: None,
             raw_override: None,
         });
     }
@@ -1143,13 +1150,16 @@ fn generate_organized_line(imp: &OrganizedImport, lang: LangId) -> String {
                 format!("import \"{}\"", imp.module_path)
             }
         }
-        LangId::TypeScript | LangId::Tsx | LangId::JavaScript
-            if imp.names.is_empty()
-                && imp.default_import.is_none()
-                && imp.namespace_import.is_some() =>
-        {
-            let namespace = imp.namespace_import.as_deref().unwrap_or_default();
-            format!("import * as {} from '{}';", namespace, imp.module_path)
+        LangId::TypeScript | LangId::Tsx | LangId::JavaScript => {
+            imports::generate_import_line_with_namespace_and_attribute_clause(
+                lang,
+                &imp.module_path,
+                &imp.names,
+                imp.default_import.as_deref(),
+                imp.namespace_import.as_deref(),
+                imp.kind == ImportKind::Type,
+                imp.attribute_clause.as_deref(),
+            )
         }
         _ => {
             // TS/JS/TSX/Python — use the standard generator

crates/aft/src/commands/remove_import.rs

@@ -362,13 +362,14 @@ fn remove_name_from_imports(
                 edits.push((range, String::new()));
             } else {
                 // Other bindings remain — regenerate without target
-                let new_line = imports::generate_import_line_with_namespace(
+                let new_line = imports::generate_import_line_with_namespace_and_attribute_clause(
                     lang,
                     &imp.module_path,
                     &new_names,
                     imp.default_import.as_deref(),
                     imp.namespace_import.as_deref(),
                     imp.kind == imports::ImportKind::Type,
+                    imports::es_import_attribute_clause(imp),
                 );
                 edits.push((imp.byte_range.clone(), new_line));
             }
@@ -380,13 +381,14 @@ fn remove_name_from_imports(
                 edits.push((range, String::new()));
             } else {
                 // Has named or namespace imports too — regenerate without default
-                let new_line = imports::generate_import_line_with_namespace(
+                let new_line = imports::generate_import_line_with_namespace_and_attribute_clause(
                     lang,
                     &imp.module_path,
                     &imp.names,
                     None,
                     imp.namespace_import.as_deref(),
                     imp.kind == imports::ImportKind::Type,
+                    imports::es_import_attribute_clause(imp),
                 );
                 edits.push((imp.byte_range.clone(), new_line));
             }
@@ -398,13 +400,14 @@ fn remove_name_from_imports(
                 edits.push((range, String::new()));
             } else {
                 // Has default or named imports too — regenerate without namespace
-                let new_line = imports::generate_import_line_with_namespace(
+                let new_line = imports::generate_import_line_with_namespace_and_attribute_clause(
                     lang,
                     &imp.module_path,
                     &imp.names,
                     imp.default_import.as_deref(),
                     None,
                     imp.kind == imports::ImportKind::Type,
+                    imports::es_import_attribute_clause(imp),
                 );
                 edits.push((imp.byte_range.clone(), new_line));
             }