feat(formatter): implement formatting for TSTypeAliasDeclaration (#14040)

Author: Dunqing

crates/oxc_formatter/src/utils/assignment_like.rs

@@ -20,7 +20,7 @@ use crate::{
     write,
     write::{
         BinaryLikeExpression, FormatJsArrowFunctionExpression,
-        FormatJsArrowFunctionExpressionOptions,
+        FormatJsArrowFunctionExpressionOptions, FormatWrite,
     },
 };
 
@@ -32,7 +32,7 @@ pub enum AssignmentLike<'a, 'b> {
     AssignmentExpression(&'b AstNode<'a, AssignmentExpression<'a>>),
     ObjectProperty(&'b AstNode<'a, ObjectProperty<'a>>),
     PropertyDefinition(&'b AstNode<'a, PropertyDefinition<'a>>),
-    // TODO: Add TSTypeAliasDeclaration when needed
+    TSTypeAliasDeclaration(&'b AstNode<'a, TSTypeAliasDeclaration<'a>>),
 }
 
 /// Determines how a assignment like be formatted
@@ -224,6 +224,18 @@ impl<'a> AssignmentLike<'a, '_> {
 
                 Ok(false) // Class properties don't use "short" key logic
             }
+            AssignmentLike::TSTypeAliasDeclaration(declaration) => {
+                write!(
+                    f,
+                    [
+                        declaration.declare.then_some("declare "),
+                        "type ",
+                        declaration.id(),
+                        declaration.type_parameters()
+                    ]
+                )?;
+                Ok(false)
+            }
         }
     }
 
@@ -244,6 +256,9 @@ impl<'a> AssignmentLike<'a, '_> {
             {
                 write!(f, [space(), "="])
             }
+            Self::TSTypeAliasDeclaration(_) => {
+                write!(f, [space(), "="])
+            }
             _ => Ok(()),
         }
     }
@@ -274,6 +289,14 @@ impl<'a> AssignmentLike<'a, '_> {
                     [space(), with_assignment_layout(property.value().unwrap(), Some(layout))]
                 )
             }
+            Self::TSTypeAliasDeclaration(declaration) => {
+                if let AstNodes::TSUnionType(union) = declaration.type_annotation().as_ast_nodes() {
+                    union.write(f)?;
+                    union.format_trailing_comments(f)
+                } else {
+                    write!(f, [space(), declaration.type_annotation()])
+                }
+            }
         }
     }
 
@@ -305,14 +328,14 @@ impl<'a> AssignmentLike<'a, '_> {
             return AssignmentLikeLayout::NeverBreakAfterOperator;
         }
 
-        if self.should_break_left_hand_side() {
-            return AssignmentLikeLayout::BreakLeftHandSide;
-        }
-
         if self.should_break_after_operator(right_expression, f) {
             return AssignmentLikeLayout::BreakAfterOperator;
         }
 
+        if self.should_break_left_hand_side() {
+            return AssignmentLikeLayout::BreakLeftHandSide;
+        }
+
         if is_left_short {
             return AssignmentLikeLayout::NeverBreakAfterOperator;
         }
@@ -370,14 +393,15 @@ impl<'a> AssignmentLike<'a, '_> {
             AssignmentLike::PropertyDefinition(property_class_member) => {
                 property_class_member.value()
             }
+            AssignmentLike::TSTypeAliasDeclaration(declaration) => None,
         }
     }
 
     /// Checks that a [AssignmentLike] consists only of the left part
     /// usually, when a [variable declarator](VariableDeclarator) doesn't have initializer
     fn has_only_left_hand_side(&self) -> bool {
         match self {
-            Self::AssignmentExpression(_) => false,
+            Self::AssignmentExpression(_) | Self::TSTypeAliasDeclaration(_) => false,
             Self::VariableDeclarator(declarator) => declarator.init.is_none(),
             Self::PropertyDefinition(property) => property.value().is_none(),
             Self::ObjectProperty(property) => property.shorthand,
@@ -441,17 +465,20 @@ impl<'a> AssignmentLike<'a, '_> {
             return true;
         }
 
-        // TODO: Add is_complex_type_alias when TypeAliasDeclaration is supported
-        let is_complex_type_alias = false;
+        if self.is_complex_type_alias() {
+            return true;
+        }
 
-        if !self
-            .get_right_expression()
-            .is_some_and(|expr| matches!(expr.as_ref(), Expression::ArrowFunctionExpression(_)))
-        {
+        let Self::VariableDeclarator(declarator) = self else {
             return false;
-        }
+        };
 
-        matches!(self, Self::VariableDeclarator(decl) if decl.id.type_annotation.as_ref().is_some_and(|ann| is_complex_type_annotation(ann)))
+        let type_annotation = declarator.id.type_annotation.as_ref();
+
+        type_annotation.is_some_and(|ann| is_complex_type_annotation(ann))
+            || (self.get_right_expression().is_some_and(|expr| {
+                matches!(expr.as_ref(), Expression::ArrowFunctionExpression(_))
+            }) && type_annotation.is_some_and(|ann| is_annotation_breakable(ann)))
     }
 
     /// Checks if the current assignment is eligible for [AssignmentLikeLayout::BreakAfterOperator]
@@ -466,33 +493,49 @@ impl<'a> AssignmentLike<'a, '_> {
         let comments = f.context().comments();
         if let Some(right_expression) = right_expression {
             should_break_after_operator(right_expression, f)
+        } else if let AssignmentLike::TSTypeAliasDeclaration(decl) = self {
+            // For TSTypeAliasDeclaration, check if the type annotation is a union type with comments
+            match &decl.type_annotation {
+                TSType::TSConditionalType(conditional_type) => {
+                    let is_generic = |ts_type: &TSType<'a>| -> bool {
+                        match ts_type {
+                            TSType::TSFunctionType(function) => function.type_parameters.is_some(),
+                            TSType::TSTypeReference(reference) => {
+                                reference.type_arguments.is_some()
+                            }
+                            _ => false,
+                        }
+                    };
+
+                    is_generic(&conditional_type.check_type)
+                        || is_generic(&conditional_type.extends_type)
+                }
+                _ => {
+                    // Check for leading comments on any other type
+                    comments.has_comment_before(decl.type_annotation.span().start)
+                }
+            }
         } else {
-            // RightAssignmentLike::AnyTsType(AnyTsType::TsUnionType(ty)) => {
-            //     // Recursively checks if the union type is nested and identifies the innermost union type.
-            //     // If a leading comment is found while navigating to the inner union type,
-            //     // it is considered as having leading comments.
-            //     let mut union_type = ty.clone();
-            //     let mut has_leading_comments = comments.has_leading_comments(union_type.syntax());
-            //     while is_nested_union_type(&union_type)? && !has_leading_comments {
-            //         if let Some(Ok(inner_union_type)) = union_type.types().last() {
-            //             let inner_union_type = TsUnionType::cast(inner_union_type.into_syntax());
-            //             if let Some(inner_union_type) = inner_union_type {
-            //                 has_leading_comments =
-            //                     comments.has_leading_comments(inner_union_type.syntax());
-            //                 union_type = inner_union_type;
-            //             } else {
-            //                 break;
-            //             }
-            //         } else {
-            //             break;
-            //         }
-            //     }
-            //     has_leading_comments
-            // }
             false
         }
     }
 
+    fn is_complex_type_alias(&self) -> bool {
+        let AssignmentLike::TSTypeAliasDeclaration(type_alias) = self else {
+            return false;
+        };
+
+        let Some(type_parameters) = &type_alias.type_parameters else {
+            return false;
+        };
+
+        type_parameters.params.len() > 1
+            && type_parameters
+                .params
+                .iter()
+                .any(|param| param.constraint.is_some() || param.default.is_some())
+    }
+
     fn is_complex_destructuring(&self) -> bool {
         match self {
             AssignmentLike::VariableDeclarator(variable_decorator) => {
@@ -522,7 +565,9 @@ impl<'a> AssignmentLike<'a, '_> {
                     AssignmentTargetProperty::AssignmentTargetPropertyProperty(_) => true,
                 })
             }
-            AssignmentLike::ObjectProperty(_) | AssignmentLike::PropertyDefinition(_) => false,
+            AssignmentLike::ObjectProperty(_)
+            | AssignmentLike::PropertyDefinition(_)
+            | AssignmentLike::TSTypeAliasDeclaration(_) => false,
         }
     }
 }
@@ -883,10 +928,7 @@ fn is_complex_type_arguments(type_arguments: &TSTypeParameterInstantiation) -> b
     let is_first_argument_complex = ts_type_argument_list.first().is_some_and(|first_argument| {
         matches!(
             first_argument,
-            TSType::TSUnionType(_)
-                | TSType::TSIntersectionType(_)
-                | TSType::TSTupleType(_)
-                | TSType::TSTypeLiteral(_)
+            TSType::TSUnionType(_) | TSType::TSIntersectionType(_) | TSType::TSTypeLiteral(_)
         )
     });
 
@@ -900,20 +942,6 @@ fn is_complex_type_arguments(type_arguments: &TSTypeParameterInstantiation) -> b
     false
 }
 
-/// If a union type has only one type and it's a union type, then it's a nested union type
-/// ```js
-/// type A = | (A | B)
-///          ^^^^^^^^^^
-/// ```
-/// The final format will only keep the inner union type
-fn is_nested_union_type(union_type: &TSUnionType) -> bool {
-    if union_type.types.len() == 1 {
-        let ty = &union_type.types[0];
-        return matches!(ty, TSType::TSUnionType(_));
-    }
-    false
-}
-
 /// Checks if the annotation is breakable
 fn is_annotation_breakable(annotation: &TSTypeAnnotation) -> bool {
     matches!(

crates/oxc_formatter/src/utils/mod.rs

@@ -8,6 +8,7 @@ pub mod object;
 pub mod string_utils;
 pub mod suppressed;
 pub mod typecast;
+pub mod typescript;
 
 use oxc_allocator::Address;
 use oxc_ast::{AstKind, ast::CallExpression};

crates/oxc_formatter/src/utils/typescript.rs

@@ -0,0 +1,72 @@
+use oxc_ast::ast::{TSType, TSUnionType};
+use oxc_span::GetSpan;
+
+use crate::{formatter::Formatter, generated::ast_nodes::AstNode};
+
+/// Check if a TSType is a simple type (primitives, keywords, simple references)
+pub fn is_simple_type(ty: &TSType) -> bool {
+    match ty {
+        TSType::TSAnyKeyword(_)
+        | TSType::TSNullKeyword(_)
+        | TSType::TSThisType(_)
+        | TSType::TSVoidKeyword(_)
+        | TSType::TSNumberKeyword(_)
+        | TSType::TSBooleanKeyword(_)
+        | TSType::TSBigIntKeyword(_)
+        | TSType::TSStringKeyword(_)
+        | TSType::TSSymbolKeyword(_)
+        | TSType::TSNeverKeyword(_)
+        | TSType::TSObjectKeyword(_)
+        | TSType::TSUndefinedKeyword(_)
+        | TSType::TSTemplateLiteralType(_)
+        | TSType::TSLiteralType(_)
+        | TSType::TSUnknownKeyword(_) => true,
+        TSType::TSTypeReference(reference) => {
+            // Simple reference without type arguments
+            reference.type_arguments.is_none()
+        }
+        _ => false,
+    }
+}
+
+/// Check if a TSType is object-like (object literal, mapped type, etc.)
+pub fn is_object_like_type(ty: &TSType) -> bool {
+    matches!(ty, TSType::TSTypeLiteral(_) | TSType::TSMappedType(_))
+}
+
+pub fn should_hug_type(node: &TSUnionType<'_>, f: &Formatter<'_, '_>) -> bool {
+    let types = &node.types;
+
+    if types.len() == 1 {
+        return true;
+    }
+
+    let has_object_type =
+        types.iter().any(|t| matches!(t, TSType::TSTypeLiteral(_) | TSType::TSTypeReference(_)));
+
+    if !has_object_type {
+        return false;
+    }
+
+    let void_count = types
+        .iter()
+        .filter(|t| matches!(t, TSType::TSVoidKeyword(_) | TSType::TSNullKeyword(_)))
+        .count();
+
+    if types.len() - 1 != void_count {
+        return false;
+    }
+
+    // `{ a: string } /* comment */ | null | /* comment */ */ undefined`
+    //                ^^^^^^^^^^^^           ^^^^^^^^^^^^
+    // Check whether there are comments between the types, if so, we should not hug
+    let mut start = node.span.start;
+    for t in types {
+        if f.comments().has_comment_in_range(start, t.span().start) {
+            return false;
+        }
+        start = t.span().end;
+    }
+
+    true
+}

crates/oxc_formatter/src/write/call_arguments.rs

@@ -299,11 +299,14 @@ fn should_group_last_argument(
     match last.and_then(|arg| arg.as_expression()) {
         Some(last) => {
             let penultimate = iter.next_back();
-            if let Some(penultimate) = &penultimate {
-                // TODO: check if both last and penultimate are same kind of expression.
-                // if penultimate.syntax().kind() == last.syntax().kind() {
-                //     return Ok(false);
-                // }
+            if let Some(penultimate) = &penultimate
+                && matches!(
+                    (penultimate, last),
+                    (Argument::ObjectExpression(_), Expression::ObjectExpression(_))
+                        | (Argument::ArrayExpression(_), Expression::ArrayExpression(_))
+                )
+            {
+                return false;
             }
 
             let previous_span = penultimate.map_or(call_like_span.start, |a| a.span().end);