feat(rome_formatter): format export syntax

crates/rome_formatter/src/cst.rs

@@ -4,15 +4,20 @@ use rslint_parser::ast::{
     JsBlockStatement, JsBooleanLiteralExpression, JsCallArguments, JsCallExpression, JsCaseClause,
     JsCatchClause, JsClassStatement, JsConstructorParameters, JsContinueStatement,
     JsDebuggerStatement, JsDefaultClause, JsDefaultImportSpecifier, JsDoWhileStatement,
-    JsEmptyStatement, JsExpressionStatement, JsFinallyClause, JsForInStatement, JsForStatement,
-    JsFunctionStatement, JsGetterClassMember, JsIdentifierBinding, JsIdentifierExpression,
-    JsIfStatement, JsImport, JsImportAssertion, JsImportAssertionEntry, JsImportBareClause,
-    JsImportCallExpression, JsImportDefaultClause, JsImportNamedClause, JsImportNamespaceClause,
-    JsLabeledStatement, JsLiteralExportName, JsModule, JsModuleSource, JsNamedImportSpecifier,
-    JsNamedImportSpecifiers, JsNamespaceImportSpecifier, JsNullLiteralExpression,
-    JsNumberLiteralExpression, JsObjectExpression, JsParameters, JsPropertyClassMember,
-    JsPropertyObjectMember, JsReturnStatement, JsScript, JsSequenceExpression, JsSetterClassMember,
-    JsShorthandNamedImportSpecifier, JsShorthandPropertyObjectMember, JsSpread, JsStatementList,
+    JsEmptyStatement, JsExport, JsExportAsClause, JsExportClassClause, JsExportDefaultClassClause,
+    JsExportDefaultExpressionClause, JsExportDefaultFunctionClause, JsExportFromClause,
+    JsExportFunctionClause, JsExportNamedClause, JsExportNamedFromClause,
+    JsExportNamedFromSpecifier, JsExportNamedShorthandSpecifier, JsExportNamedSpecifier,
+    JsExportVariableClause, JsExpressionStatement, JsFinallyClause, JsForInStatement,
+    JsForStatement, JsFunctionStatement, JsGetterClassMember, JsIdentifierBinding,
+    JsIdentifierExpression, JsIfStatement, JsImport, JsImportAssertion, JsImportAssertionEntry,
+    JsImportBareClause, JsImportCallExpression, JsImportDefaultClause, JsImportNamedClause,
+    JsImportNamespaceClause, JsLabeledStatement, JsLiteralExportName, JsModule, JsModuleSource,
+    JsNamedImportSpecifier, JsNamedImportSpecifiers, JsNamespaceImportSpecifier,
+    JsNullLiteralExpression, JsNumberLiteralExpression, JsObjectExpression, JsParameters,
+    JsPropertyClassMember, JsPropertyObjectMember, JsReturnStatement, JsScript,
+    JsSequenceExpression, JsSetterClassMember, JsShorthandNamedImportSpecifier,
+    JsShorthandPropertyObjectMember, JsSpread, JsStatementList,
     JsStaticInitializationBlockClassMember, JsStringLiteralExpression, JsSwitchStatement,
     JsTemplate, JsTemplateChunkElement, JsTemplateElement, JsTryStatement, JsUnknownAssignment,
     JsUnknownBinding, JsUnknownExpression, JsUnknownImportAssertionEntry, JsUnknownMember,
@@ -277,6 +282,62 @@ impl ToFormatElement for SyntaxNode {
             JsSyntaxKind::IMPORT_META => ImportMeta::cast(self.clone())
                 .unwrap()
                 .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT => JsExport::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_CLASS_CLAUSE => JsExportClassClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_DEFAULT_CLASS_CLAUSE => {
+                JsExportDefaultClassClause::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_EXPORT_FUNCTION_CLAUSE => JsExportFunctionClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_DEFAULT_FUNCTION_CLAUSE => {
+                JsExportDefaultFunctionClause::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_EXPORT_VARIABLE_CLAUSE => JsExportVariableClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_DEFAULT_EXPRESSION_CLAUSE => {
+                JsExportDefaultExpressionClause::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_EXPORT_FROM_CLAUSE => JsExportFromClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+
+            JsSyntaxKind::JS_EXPORT_AS_CLAUSE => JsExportAsClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_NAMED_CLAUSE => JsExportNamedClause::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_NAMED_SPECIFIER => JsExportNamedSpecifier::cast(self.clone())
+                .unwrap()
+                .to_format_element(formatter),
+            JsSyntaxKind::JS_EXPORT_NAMED_SHORTHAND_SPECIFIER => {
+                JsExportNamedShorthandSpecifier::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_EXPORT_NAMED_FROM_CLAUSE => {
+                JsExportNamedFromClause::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+            JsSyntaxKind::JS_EXPORT_NAMED_FROM_SPECIFIER => {
+                JsExportNamedFromSpecifier::cast(self.clone())
+                    .unwrap()
+                    .to_format_element(formatter)
+            }
+
             _ => todo!(
                 "Implement formatting for the {:?} syntax kind.",
                 self.kind()

crates/rome_formatter/src/ts/export/any_export_clause.rs

@@ -0,0 +1,24 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::JsAnyExportClause;
+
+impl ToFormatElement for JsAnyExportClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        match self {
+            JsAnyExportClause::JsExportClassClause(node) => node.to_format_element(formatter),
+            JsAnyExportClause::JsExportDefaultClassClause(node) => {
+                node.to_format_element(formatter)
+            }
+            JsAnyExportClause::JsExportDefaultExpressionClause(node) => {
+                node.to_format_element(formatter)
+            }
+            JsAnyExportClause::JsExportDefaultFunctionClause(node) => {
+                node.to_format_element(formatter)
+            }
+            JsAnyExportClause::JsExportFromClause(node) => node.to_format_element(formatter),
+            JsAnyExportClause::JsExportFunctionClause(node) => node.to_format_element(formatter),
+            JsAnyExportClause::JsExportNamedClause(node) => node.to_format_element(formatter),
+            JsAnyExportClause::JsExportNamedFromClause(node) => node.to_format_element(formatter),
+            JsAnyExportClause::JsExportVariableClause(node) => node.to_format_element(formatter),
+        }
+    }
+}

crates/rome_formatter/src/ts/export/any_export_name_specifier.rs

@@ -0,0 +1,15 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::JsAnyExportNamedSpecifier;
+
+impl ToFormatElement for JsAnyExportNamedSpecifier {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        match self {
+            JsAnyExportNamedSpecifier::JsExportNamedShorthandSpecifier(node) => {
+                node.to_format_element(formatter)
+            }
+            JsAnyExportNamedSpecifier::JsExportNamedSpecifier(node) => {
+                node.to_format_element(formatter)
+            }
+        }
+    }
+}

crates/rome_formatter/src/ts/export/as_clause.rs

@@ -0,0 +1,13 @@
+use crate::{
+    format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsExportAsClause;
+
+impl ToFormatElement for JsExportAsClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let as_token = formatter.format_token(&self.as_token()?)?;
+        let exported_name = formatter.format_node(&self.exported_name()?)?;
+
+        Ok(format_elements![as_token, space_token(), exported_name])
+    }
+}

crates/rome_formatter/src/ts/export/class_clause.rs

@@ -0,0 +1,8 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::{JsAnyClass, JsExportClassClause};
+
+impl ToFormatElement for JsExportClassClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        JsAnyClass::from(self.clone()).to_format_element(formatter)
+    }
+}

crates/rome_formatter/src/ts/export/default_class_clause.rs

@@ -0,0 +1,13 @@
+use crate::{
+    format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::{JsAnyClass, JsExportDefaultClassClause};
+
+impl ToFormatElement for JsExportDefaultClassClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let default_token = formatter.format_token(&self.default_token()?)?;
+        let class = JsAnyClass::from(self.clone()).to_format_element(formatter)?;
+
+        Ok(format_elements![default_token, space_token(), class])
+    }
+}

crates/rome_formatter/src/ts/export/default_expression_clause.rs

@@ -0,0 +1,22 @@
+use crate::{
+    format_elements, space_token, token, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsExportDefaultExpressionClause;
+
+impl ToFormatElement for JsExportDefaultExpressionClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let default_token = formatter.format_token(&self.default_token()?)?;
+        let class = formatter.format_node(&self.expression()?)?;
+        let semicolon = if let Some(semicolon) = &self.semicolon_token() {
+            formatter.format_token(semicolon)?
+        } else {
+            token(";")
+        };
+        Ok(format_elements![
+            default_token,
+            space_token(),
+            class,
+            semicolon
+        ])
+    }
+}

crates/rome_formatter/src/ts/export/default_function_clause.rs

@@ -0,0 +1,13 @@
+use crate::{
+    format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::{JsAnyFunction, JsExportDefaultFunctionClause};
+
+impl ToFormatElement for JsExportDefaultFunctionClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let default_token = formatter.format_token(&self.default_token()?)?;
+        let class = JsAnyFunction::from(self.clone()).to_format_element(formatter)?;
+
+        Ok(format_elements![default_token, space_token(), class])
+    }
+}

crates/rome_formatter/src/ts/export/from_clause.rs

@@ -0,0 +1,38 @@
+use crate::{
+    empty_element, format_elements, space_token, token, FormatElement, FormatResult, Formatter,
+    ToFormatElement,
+};
+use rslint_parser::ast::JsExportFromClause;
+
+impl ToFormatElement for JsExportFromClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let star = formatter.format_token(&self.star_token()?)?;
+        let export_as = if let Some(export_as) = self.export_as() {
+            format_elements![formatter.format_node(&export_as)?, space_token()]
+        } else {
+            empty_element()
+        };
+        let from = formatter.format_token(&self.from_token()?)?;
+        let source = formatter.format_node(&self.source()?)?;
+        let assertion = if let Some(assertion) = self.assertion() {
+            formatter.format_node(&assertion)?
+        } else {
+            empty_element()
+        };
+        let semicolon = if let Some(semicolon) = self.semicolon_token() {
+            formatter.format_token(&semicolon)?
+        } else {
+            token(";")
+        };
+        Ok(format_elements![
+            star,
+            space_token(),
+            export_as,
+            from,
+            space_token(),
+            source,
+            assertion,
+            semicolon
+        ])
+    }
+}

crates/rome_formatter/src/ts/export/function_clause.rs

@@ -0,0 +1,8 @@
+use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
+use rslint_parser::ast::{JsAnyFunction, JsExportFunctionClause};
+
+impl ToFormatElement for JsExportFunctionClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        JsAnyFunction::from(self.clone()).to_format_element(formatter)
+    }
+}

crates/rome_formatter/src/ts/export/mod.rs

@@ -0,0 +1,28 @@
+mod any_export_clause;
+mod any_export_name_specifier;
+mod as_clause;
+mod class_clause;
+mod default_class_clause;
+mod default_expression_clause;
+mod default_function_clause;
+mod from_clause;
+mod function_clause;
+mod named_clause;
+mod named_from_clause;
+mod named_from_specifier;
+mod named_shorthand_specifier;
+mod named_specifier;
+mod variable_clause;
+
+use crate::{
+    format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsExport;
+
+impl ToFormatElement for JsExport {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let export_token = formatter.format_token(&self.export_token()?)?;
+        let export_clause = formatter.format_node(&self.export_clause()?)?;
+        Ok(format_elements![export_token, space_token(), export_clause])
+    }
+}

crates/rome_formatter/src/ts/export/named_clause.rs

@@ -0,0 +1,44 @@
+use crate::{
+    empty_element, format_elements, group_elements, if_group_fits_on_single_line, join_elements,
+    soft_block_indent, soft_line_break_or_space, space_token, token, FormatElement, FormatResult,
+    Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsExportNamedClause;
+use rslint_parser::AstSeparatedList;
+
+impl ToFormatElement for JsExportNamedClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let specifiers = self.specifiers();
+        let space = if specifiers.is_empty() {
+            empty_element()
+        } else {
+            if_group_fits_on_single_line(space_token())
+        };
+        let list = group_elements(formatter.format_delimited(
+            &self.l_curly_token()?,
+            |leading, trailing| {
+                Ok(format_elements!(
+                    space.clone(),
+                    soft_block_indent(format_elements![
+                        leading,
+                        join_elements(
+                            soft_line_break_or_space(),
+                            formatter.format_separated(specifiers, || token(","))?
+                        ),
+                        trailing,
+                    ]),
+                    space,
+                ))
+            },
+            &self.r_curly_token()?,
+        )?);
+
+        let semicolon = if let Some(semicolon) = self.semicolon_token() {
+            formatter.format_token(&semicolon)?
+        } else {
+            token(";")
+        };
+
+        Ok(format_elements![list, semicolon])
+    }
+}

crates/rome_formatter/src/ts/export/named_from_clause.rs

@@ -0,0 +1,60 @@
+use crate::{
+    empty_element, format_elements, group_elements, if_group_fits_on_single_line, join_elements,
+    soft_block_indent, soft_line_break_or_space, space_token, token, FormatElement, FormatResult,
+    Formatter, ToFormatElement,
+};
+use rslint_parser::ast::JsExportNamedFromClause;
+use rslint_parser::AstSeparatedList;
+
+impl ToFormatElement for JsExportNamedFromClause {
+    fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+        let specifiers = self.specifiers();
+        let space = if specifiers.is_empty() {
+            empty_element()
+        } else {
+            if_group_fits_on_single_line(space_token())
+        };
+        let list = group_elements(formatter.format_delimited(
+            &self.l_curly_token()?,
+            |leading, trailing| {
+                Ok(format_elements!(
+                    space.clone(),
+                    soft_block_indent(format_elements![
+                        leading,
+                        join_elements(
+                            soft_line_break_or_space(),
+                            formatter.format_separated(specifiers, || token(","))?
+                        ),
+                        trailing,
+                    ]),
+                    space,
+                ))
+            },
+            &self.r_curly_token()?,
+        )?);
+
+        let from = formatter.format_token(&self.from_token()?)?;
+        let source = formatter.format_node(&self.source()?)?;
+        let assertion = if let Some(assertion) = self.assertion() {
+            formatter.format_node(&assertion)?
+        } else {
+            empty_element()
+        };
+        let semicolon = if let Some(semicolon) = self.semicolon_token() {
+            formatter.format_token(&semicolon)?
+        } else {
+            token(";")
+        };
+
+        Ok(format_elements![
+            list,
+            space_token(),
+            from,
+            space_token(),
+            source,
+            space_token(),
+            assertion,
+            semicolon
+        ])
+    }
+}