fix(formatter): missing trailing semicolon in TSSignature (#13823)

Dunqing · Dunqing · commit 72144e995465 · 2025-09-17T09:36:02.000Z
* Fixes: #13837
diff --git a/crates/oxc_formatter/src/write/mod.rs b/crates/oxc_formatter/src/write/mod.rs
@@ -1547,8 +1547,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSInterfaceDeclaration<'a>> {
 
 impl<'a> FormatWrite<'a> for AstNode<'a, TSInterfaceBody<'a>> {
     fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        let source_text = f.context().source_text();
-        f.join_nodes_with_soft_line().entries(self.body()).finish()
+        self.body().fmt(f)
     }
 }
 
@@ -1572,9 +1571,50 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSPropertySignature<'a>> {
     }
 }
 
+struct FormatTSSignature<'a, 'b> {
+    last: bool,
+    signature: &'b AstNode<'a, TSSignature<'a>>,
+}
+
+impl GetSpan for FormatTSSignature<'_, '_> {
+    fn span(&self) -> Span {
+        self.signature.span()
+    }
+}
+
+impl<'a> Format<'a> for FormatTSSignature<'a, '_> {
+    fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
+        self.signature.fmt(f)?;
+
+        match f.options().semicolons {
+            Semicolons::Always => {
+                if self.last {
+                    write!(f, [if_group_breaks(&text(";"))])?;
+                } else {
+                    text(";").fmt(f)?;
+                }
+            }
+            Semicolons::AsNeeded => {
+                if !self.last {
+                    write!(f, [if_group_fits_on_line(&text(";"))])?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
 impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSSignature<'a>>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        f.join_nodes_with_soft_line().entries(self).finish()
+        let last_index = self.len().saturating_sub(1);
+        f.join_nodes_with_soft_line()
+            .entries(
+                self.iter()
+                    .enumerate()
+                    .map(|(i, signature)| FormatTSSignature { last: i == last_index, signature }),
+            )
+            .finish()
     }
 }
 
@@ -1584,16 +1624,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSIndexSignature<'a>> {
             write!(f, ["readonly", space()])?;
         }
         // TODO: parameters only have one element for now.
-        write!(
-            f,
-            [
-                "[",
-                self.parameters().first().unwrap(),
-                "]",
-                self.type_annotation(),
-                OptionalSemicolon
-            ]
-        )
+        write!(f, ["[", self.parameters().first().unwrap(), "]", self.type_annotation(),])
     }
 }
 
@@ -1610,7 +1641,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSCallSignatureDeclaration<'a>> {
         if let Some(return_type) = &self.return_type() {
             write!(f, return_type)?;
         }
-        write!(f, OptionalSemicolon)
+        Ok(())
     }
 }
 
@@ -1656,7 +1687,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSMethodSignature<'a>> {
         if let Some(return_type) = &self.return_type() {
             write!(f, return_type)?;
         }
-        write!(f, OptionalSemicolon)
+        Ok(())
     }
 }
 
@@ -1670,7 +1701,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSConstructSignatureDeclaration<'a>> {
         if let Some(return_type) = self.return_type() {
             write!(f, return_type)?;
         }
-        write!(f, OptionalSemicolon)
+        Ok(())
     }
 }
 
diff --git a/crates/oxc_formatter/src/write/semicolon.rs b/crates/oxc_formatter/src/write/semicolon.rs
@@ -73,6 +73,7 @@ impl<'a, 'b> ClassPropertySemicolon<'a, 'b> {
             ClassElement::AccessorProperty(def) => {
                 def.computed && !(def.accessibility.is_some() || def.r#static || def.r#override)
             }
+            ClassElement::TSIndexSignature(_) => true,
             _ => false,
         }
     }
@@ -82,9 +83,7 @@ impl<'a> Format<'a> for ClassPropertySemicolon<'a, '_> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         if matches!(
             self.element.as_ref(),
-            ClassElement::StaticBlock(_)
-                | ClassElement::MethodDefinition(_)
-                | ClassElement::TSIndexSignature(_)
+            ClassElement::StaticBlock(_) | ClassElement::MethodDefinition(_)
         ) {
             return Ok(());
         }
diff --git a/tasks/coverage/snapshots/formatter_typescript.snap b/tasks/coverage/snapshots/formatter_typescript.snap
@@ -2,9 +2,7 @@ commit: 261630d6
 
 formatter_typescript Summary:
 AST Parsed     : 8816/8816 (100.00%)
-Positive Passed: 8763/8816 (99.40%)
-Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/APISample_jsdoc.ts
-Expected `]` but found `:`
+Positive Passed: 8774/8816 (99.52%)
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/amdLikeInputDeclarationEmit.ts
 
 Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/arrayFromAsync.ts
@@ -21,8 +19,6 @@ Mismatch: tasks/coverage/typescript/tests/cases/compiler/complexNarrowingWithAny
 
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/declarationEmitCastReusesTypeNode4.ts
 
-Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/declarationEmitPartialReuseComputedProperty.ts
-Unexpected token
 Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/declarationEmitPromise.ts
 Expected a semicolon or an implicit semicolon after a statement, but found none
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/declarationEmitRecursiveConditionalAliasPreserved.ts
@@ -37,16 +33,12 @@ Mismatch: tasks/coverage/typescript/tests/cases/compiler/jsxNamespaceGlobalReexp
 
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/jsxNamespaceImplicitImportJSXNamespace.tsx
 
-Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/keyRemappingKeyofResult.ts
-Unexpected token
 Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/narrowingByTypeofInSwitch.ts
 Expected a semicolon or an implicit semicolon after a statement, but found none
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/propertyAccessExpressionInnerComments.ts
 
 Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/readonlyAssignmentInSubclassOfClassExpression.ts
 Expected `{` but found `as`
-Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/reducibleIndexedAccessTypes.ts
-Expected `]` but found `:`
 Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/reverseMappedTypeInferenceSameSource1.ts
 An implementation cannot be declared in ambient contexts.
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/sourceMapValidationClasses.ts
@@ -59,8 +51,6 @@ Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/superAccessCaste
 Expected a semicolon or an implicit semicolon after a statement, but found none
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/tryStatementInternalComments.ts
 
-Expect to Parse: tasks/coverage/typescript/tests/cases/compiler/typeName1.ts
-Expected `]` but found `:`
 Mismatch: tasks/coverage/typescript/tests/cases/compiler/unionSignaturesWithThisParameter.ts
 
 Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/classes/propertyMemberDeclarations/overrideInterfaceProperty.ts
@@ -93,19 +83,7 @@ Mismatch: tasks/coverage/typescript/tests/cases/conformance/interfaces/interface
 
 Mismatch: tasks/coverage/typescript/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClassWithProtecteds2.ts
 
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/pedantic/noUncheckedIndexedAccess.ts
-Expected `]` but found `:`
 Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/statements/returnStatements/returnStatementNoAsiAfterTransform.ts
 Expected `,` but found `(`
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/types/mapped/mappedTypeModifiers.ts
-Expected `]` but found `:`
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/types/objectTypeLiteral/propertySignatures/propertyNamesOfReservedWords.ts
-'static' modifier cannot appear on a type member.'static' modifier cannot appear on a type member.
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/types/rest/genericObjectRest.ts
-Unexpected token
 Mismatch: tasks/coverage/typescript/tests/cases/conformance/types/tuple/named/namedTupleMembers.ts
 
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/types/uniqueSymbol/uniqueSymbols.ts
-Unexpected token
-Expect to Parse: tasks/coverage/typescript/tests/cases/conformance/types/uniqueSymbol/uniqueSymbolsDeclarations.ts
-Unexpected token
diff --git a/tasks/prettier_conformance/snapshots/prettier.ts.snap.md b/tasks/prettier_conformance/snapshots/prettier.ts.snap.md

Original file line number	Diff line number	Diff line change
`@@ -1547,8 +1547,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSInterfaceDeclaration<'a>> {`
`1547`	`1547`
`1548`	`1548`	`impl<'a> FormatWrite<'a> for AstNode<'a, TSInterfaceBody<'a>> {`
`1549`	`1549`	`fn write(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {`
`1550`		`- let source_text = f.context().source_text();`
`1551`		`- f.join_nodes_with_soft_line().entries(self.body()).finish()`
	`1550`	`+ self.body().fmt(f)`
`1552`	`1551`	`}`
`1553`	`1552`	`}`
`1554`	`1553`
`@@ -1572,9 +1571,50 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSPropertySignature<'a>> {`
`1572`	`1571`	`}`
`1573`	`1572`	`}`
`1574`	`1573`
	`1574`	`+struct FormatTSSignature<'a, 'b> {`
	`1575`	`+ last: bool,`
	`1576`	`+ signature: &'b AstNode<'a, TSSignature<'a>>,`
	`1577`	`+}`
	`1578`	`+`
	`1579`	`+impl GetSpan for FormatTSSignature<'_, '_> {`
	`1580`	`+ fn span(&self) -> Span {`
	`1581`	`+ self.signature.span()`
	`1582`	`+ }`
	`1583`	`+}`
	`1584`	`+`
	`1585`	`+impl<'a> Format<'a> for FormatTSSignature<'a, '_> {`
	`1586`	`+ fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {`
	`1587`	`+ self.signature.fmt(f)?;`
	`1588`	`+`
	`1589`	`+ match f.options().semicolons {`
	`1590`	`+ Semicolons::Always => {`
	`1591`	`+ if self.last {`
	`1592`	`+ write!(f, [if_group_breaks(&text(";"))])?;`
	`1593`	`+ } else {`
	`1594`	`+ text(";").fmt(f)?;`
	`1595`	`+ }`
	`1596`	`+ }`
	`1597`	`+ Semicolons::AsNeeded => {`
	`1598`	`+ if !self.last {`
	`1599`	`+ write!(f, [if_group_fits_on_line(&text(";"))])?;`
	`1600`	`+ }`
	`1601`	`+ }`
	`1602`	`+ }`
	`1603`	`+`
	`1604`	`+ Ok(())`
	`1605`	`+ }`
	`1606`	`+}`
	`1607`	`+`
`1575`	`1608`	`impl<'a> Format<'a> for AstNode<'a, Vec<'a, TSSignature<'a>>> {`
`1576`	`1609`	`fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {`
`1577`		`- f.join_nodes_with_soft_line().entries(self).finish()`
	`1610`	`+ let last_index = self.len().saturating_sub(1);`
	`1611`	`+ f.join_nodes_with_soft_line()`
	`1612`	`+ .entries(`
	`1613`	`+ self.iter()`
	`1614`	`+ .enumerate()`
	`1615`	`+ .map(\|(i, signature)\| FormatTSSignature { last: i == last_index, signature }),`
	`1616`	`+ )`
	`1617`	`+ .finish()`
`1578`	`1618`	`}`
`1579`	`1619`	`}`
`1580`	`1620`
`@@ -1584,16 +1624,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSIndexSignature<'a>> {`
`1584`	`1624`	`write!(f, ["readonly", space()])?;`
`1585`	`1625`	`}`
`1586`	`1626`	`// TODO: parameters only have one element for now.`
`1587`		`- write!(`
`1588`		`- f,`
`1589`		`- [`
`1590`		`- "[",`
`1591`		`- self.parameters().first().unwrap(),`
`1592`		`- "]",`
`1593`		`- self.type_annotation(),`
`1594`		`- OptionalSemicolon`
`1595`		`- ]`
`1596`		`- )`
	`1627`	`+ write!(f, ["[", self.parameters().first().unwrap(), "]", self.type_annotation(),])`
`1597`	`1628`	`}`
`1598`	`1629`	`}`
`1599`	`1630`
`@@ -1610,7 +1641,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSCallSignatureDeclaration<'a>> {`
`1610`	`1641`	`if let Some(return_type) = &self.return_type() {`
`1611`	`1642`	`write!(f, return_type)?;`
`1612`	`1643`	`}`
`1613`		`- write!(f, OptionalSemicolon)`
	`1644`	`+ Ok(())`
`1614`	`1645`	`}`
`1615`	`1646`	`}`
`1616`	`1647`
`@@ -1656,7 +1687,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSMethodSignature<'a>> {`
`1656`	`1687`	`if let Some(return_type) = &self.return_type() {`
`1657`	`1688`	`write!(f, return_type)?;`
`1658`	`1689`	`}`
`1659`		`- write!(f, OptionalSemicolon)`
	`1690`	`+ Ok(())`
`1660`	`1691`	`}`
`1661`	`1692`	`}`
`1662`	`1693`
`@@ -1670,7 +1701,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSConstructSignatureDeclaration<'a>> {`
`1670`	`1701`	`if let Some(return_type) = self.return_type() {`
`1671`	`1702`	`write!(f, return_type)?;`
`1672`	`1703`	`}`
`1673`		`- write!(f, OptionalSemicolon)`
	`1704`	`+ Ok(())`
`1674`	`1705`	`}`
`1675`	`1706`	`}`
`1676`	`1707`
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,7 @@ impl<'a, 'b> ClassPropertySemicolon<'a, 'b> {`
`73`	`73`	`ClassElement::AccessorProperty(def) => {`
`74`	`74`	`def.computed && !(def.accessibility.is_some() \|\| def.r#static \|\| def.r#override)`
`75`	`75`	`}`
	`76`	`+ ClassElement::TSIndexSignature(_) => true,`
`76`	`77`	`_ => false,`
`77`	`78`	`}`
`78`	`79`	`}`
`@@ -82,9 +83,7 @@ impl<'a> Format<'a> for ClassPropertySemicolon<'a, '_> {`
`82`	`83`	`fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {`
`83`	`84`	`if matches!(`
`84`	`85`	`self.element.as_ref(),`
`85`		`- ClassElement::StaticBlock(_)`
`86`		`- \| ClassElement::MethodDefinition(_)`
`87`		`- \| ClassElement::TSIndexSignature(_)`
	`86`	`+ ClassElement::StaticBlock(_) \| ClassElement::MethodDefinition(_)`
`88`	`87`	`) {`
`89`	`88`	`return Ok(());`
`90`	`89`	`}`