Omit last element semicolon from single-line object-like types

Author: andrewbranch

src/server/protocol.ts

@@ -2960,6 +2960,8 @@ namespace ts.server.protocol {
         Ignore = "ignore",
         Insert = "insert",
         Remove = "remove",
+        /*@internal*/
+        RemoveUnconventional = "remove-unconventional"
     }
 
     export interface EditorSettings {

src/services/formatting/rules.ts

@@ -314,6 +314,7 @@ namespace ts.formatting {
             rule("SpaceBeforeTypeAnnotation", anyToken, SyntaxKind.ColonToken, [isOptionEnabled("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], RuleAction.Space),
             rule("NoSpaceBeforeTypeAnnotation", anyToken, SyntaxKind.ColonToken, [isOptionDisabledOrUndefined("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], RuleAction.DeleteTrivia),
             rule("NoOptionalSemicolon", SyntaxKind.SemicolonToken, anyTokenIncludingEOF, [optionEquals("semicolons", SemicolonPreference.Remove), isSemicolonDeletionContext], RuleAction.DeleteToken),
+            rule("NoUnconventionalSemicolon", SyntaxKind.SemicolonToken, anyTokenIncludingEOF, [optionEquals("semicolons", SemicolonPreference.RemoveUnconventional), isUnconventionalSemicolonDeletionContext], RuleAction.DeleteToken),
             rule("OptionalSemicolon", anyToken, anyTokenIncludingEOF, [optionEquals("semicolons", SemicolonPreference.Insert), isSemicolonInsertionContext], RuleAction.TrailingSemicolon),
         ];
 
@@ -790,6 +791,14 @@ namespace ts.formatting {
         return context.contextNode.kind === SyntaxKind.NonNullExpression;
     }
 
+    function isUnconventionalSemicolonDeletionContext(context: FormattingContext): boolean {
+        return nodeAllowsUnconventionalTrailingSemicolon(
+            context.currentTokenParent,
+            context.contextNode,
+            context.nextTokenSpan.kind,
+            context.sourceFile);
+    }
+
     function isSemicolonDeletionContext(context: FormattingContext): boolean {
         let nextTokenKind = context.nextTokenSpan.kind;
         let nextTokenStart = context.nextTokenSpan.pos;
@@ -859,7 +868,7 @@ namespace ts.formatting {
             if (ancestor.end !== context.currentTokenSpan.end) {
                 return "quit";
             }
-            return syntaxMayBeASICandidate(ancestor.kind);
+            return nodeMayBeASICandidate(ancestor);
         });
 
         return !!contextAncestor && isASICandidate(contextAncestor, context.sourceFile);

src/services/textChanges.ts

@@ -836,12 +836,12 @@ namespace ts.textChanges {
             return {
                 ...context.options,
                 // If the user has no semicolon preference defined and the file doesn’t use semicolons,
-                // make the formatter remove them. Otherwise, ignore semicolons in the formatter because
+                // make the formatter remove them. Otherwise, only remove unconventional semicolons because
                 // the writer will insert them by default.
                 semicolons: context.options.semicolons === SemicolonPreference.Remove ||
                 (!context.options.semicolons || context.options.semicolons === SemicolonPreference.Ignore) && !probablyUsesSemicolons(sourceFile)
                     ? SemicolonPreference.Remove
-                    : SemicolonPreference.Ignore,
+                    : SemicolonPreference.RemoveUnconventional,
             };
         }
 

src/services/types.ts

@@ -684,6 +684,8 @@ namespace ts {
         Ignore = "ignore",
         Insert = "insert",
         Remove = "remove",
+        /*@internal*/
+        RemoveUnconventional = "remove-unconventional"
     }
 
     /* @deprecated - consider using EditorSettings instead */

src/services/utilities.ts

@@ -2027,13 +2027,37 @@ namespace ts {
             || kind === SyntaxKind.ExportAssignment;
     }
 
-    export const syntaxMayBeASICandidate = or(
-        syntaxRequiresTrailingCommaOrSemicolonOrASI,
-        syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI,
-        syntaxRequiresTrailingModuleBlockOrSemicolonOrASI,
-        syntaxRequiresTrailingSemicolonOrASI);
+    function isMappedTypeNodeType(node: Node) {
+        return node.parent && isMappedTypeNode(node.parent) && node.parent.type === node;
+    }
+
+    export function nodeMayBeASICandidate(node: Node) {
+        if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind) ||
+            syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI(node.kind) ||
+            syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(node.kind) ||
+            syntaxRequiresTrailingSemicolonOrASI(node.kind)) {
+            return true;
+        }
+        return isMappedTypeNodeType(node);
+    }
 
-    export function isASICandidate(node: Node, sourceFile: SourceFileLike): boolean {
+    export function nodeAllowsUnconventionalTrailingSemicolon(node: Node, contextNode: Node, nextTokenKind: SyntaxKind | undefined, sourceFile: SourceFileLike) {
+        if (isMappedTypeNodeType(node)) {
+            return rangeIsOnSingleLine(contextNode, sourceFile as SourceFile);
+        }
+        if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) {
+            return nextTokenKind === SyntaxKind.CloseBraceToken && rangeIsOnSingleLine(contextNode, sourceFile as SourceFile);
+        }
+        return false;
+    }
+
+    /**
+     * @param strict Return true for positions that allow semicolons but conventionally
+     * drop them, even in code that largely contains semicolons. Examples include the last
+     * declaration inside the curly braces of single-line object type literals and mapped types,
+     * e.g. `type X = { x: string; }` and `type X<T> = { [K in keyof T]: T[K]; }`.
+     */
+    export function isASICandidate(node: Node, sourceFile: SourceFileLike, strict?: boolean): boolean {
         const lastToken = node.getLastToken(sourceFile);
         if (lastToken && lastToken.kind === SyntaxKind.SemicolonToken) {
             return false;
@@ -2060,20 +2084,28 @@ namespace ts {
             return false;
         }
 
+        let nextToken = getNextToken();
+        const contextNode = findAncestor(node, or(isObjectTypeDeclaration, isMappedTypeNode));
+        if (contextNode && nodeAllowsUnconventionalTrailingSemicolon(node, contextNode, nextToken && nextToken.kind, sourceFile)) {
+            return !!strict;
+        }
+
         // See comment in parser’s `parseDoStatement`
         if (node.kind === SyntaxKind.DoStatement) {
             return true;
         }
 
-        const topNode = findAncestor(node, ancestor => !ancestor.parent)!;
-        const nextToken = findNextToken(node, topNode, sourceFile);
         if (!nextToken || nextToken.kind === SyntaxKind.CloseBraceToken) {
             return true;
         }
 
-        const startLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
-        const endLine = sourceFile.getLineAndCharacterOfPosition(nextToken.getStart(sourceFile)).line;
-        return startLine !== endLine;
+        return !positionsAreOnSameLine(node.getEnd(),
+            nextToken.getStart(sourceFile),
+            sourceFile as SourceFile);
+
+        function getNextToken(): Node | undefined {
+            return nextToken || (nextToken = findNextToken(node, findAncestor(node, ancestor => !ancestor.parent)!, sourceFile));
+        }
     }
 
     export function probablyUsesSemicolons(sourceFile: SourceFile): boolean {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -5297,7 +5297,7 @@ declare namespace ts {
     enum SemicolonPreference {
         Ignore = "ignore",
         Insert = "insert",
-        Remove = "remove"
+        Remove = "remove",
     }
     interface EditorOptions {
         BaseIndentSize?: number;
@@ -8202,7 +8202,7 @@ declare namespace ts.server.protocol {
     enum SemicolonPreference {
         Ignore = "ignore",
         Insert = "insert",
-        Remove = "remove"
+        Remove = "remove",
     }
     interface EditorSettings {
         baseIndentSize?: number;

tests/baselines/reference/api/typescript.d.ts

@@ -5297,7 +5297,7 @@ declare namespace ts {
     enum SemicolonPreference {
         Ignore = "ignore",
         Insert = "insert",
-        Remove = "remove"
+        Remove = "remove",
     }
     interface EditorOptions {
         BaseIndentSize?: number;

tests/baselines/reference/convertToAsyncFunction/convertToAsyncFunction_catchBlockUniqueParamsBindingPattern.ts

@@ -7,7 +7,7 @@ function /*[#|*/f/*|]*/() {
 // ==ASYNC FUNCTION::Convert to async function==
 
 async function f() {
-    let result: { x: number; } | { x: string; };
+    let result: { x: number } | { x: string };
     try {
         await Promise.resolve();
         result = ({ x: 3 });

tests/baselines/reference/extractFunction/extractFunction_VariableDeclaration_Multiple1.ts

@@ -5,7 +5,7 @@ x; y;
 
 // ==SCOPE::Extract to function in global scope==
 
-const { x, y }: { x: number; y: string; } = /*RENAME*/newFunction();
+const { x, y }: { x: number; y: string } = /*RENAME*/newFunction();
 x; y;
 
 function newFunction() {

tests/baselines/reference/extractFunction/extractFunction_VariableDeclaration_Multiple3.ts

@@ -6,7 +6,7 @@ x; y; z;
 
 // ==SCOPE::Extract to function in global scope==
 
-var { x, y, z }: { x: number; y: string; z: number; } = /*RENAME*/newFunction();
+var { x, y, z }: { x: number; y: string; z: number } = /*RENAME*/newFunction();
 x; y; z;
 
 function newFunction() {

tests/baselines/reference/extractFunction/extractFunction_VariableDeclaration_Writes_Mixed3.ts

@@ -11,7 +11,7 @@ function f() {
 
 function f() {
     let a = 1;
-    let { x, y }: { x: number; y: number; } = /*RENAME*/newFunction();
+    let { x, y }: { x: number; y: number } = /*RENAME*/newFunction();
     a; x; y;
 
     function newFunction() {

tests/baselines/reference/extractFunction/extractFunction_VariableDeclaration_Writes_UnionUndefined.ts

@@ -12,7 +12,7 @@ function f() {
 
 function f() {
     let a = 1;
-    let { x, y, z }: { x: number; y: number; z: number; } = /*RENAME*/newFunction();
+    let { x, y, z }: { x: number; y: number; z: number } = /*RENAME*/newFunction();
     a; x; y; z;
 
     function newFunction() {

tests/cases/fourslash/annotateWithTypeFromJSDoc22.ts

@@ -14,7 +14,7 @@ verify.codeFix({
 `
 /** @param {Object<string, boolean>} sb
   * @param {Object<number, string>} ns */
-function f(sb: { [s: string]: boolean; }, ns: { [n: number]: string; }) {
+function f(sb: { [s: string]: boolean }, ns: { [n: number]: string }) {
     sb; ns;
 }`,
 });

tests/cases/fourslash/annotateWithTypeFromJSDoc3.ts

@@ -30,7 +30,7 @@ verify.codeFix({
  * @param alpha - the other best parameter
  * @param {*} beta - I have no idea how this got here
  */
-function f(x: number, y: { a: string; b: Date; }, z: string, alpha, beta: any) {
+function f(x: number, y: { a: string; b: Date }, z: string, alpha, beta: any) {
     x; y; z; alpha; beta;
 }`,
 });

tests/cases/fourslash/annotateWithTypeFromJSDoc4.ts

@@ -26,7 +26,7 @@ verify.codeFix({
  * @param {number?} gamma
  * @param {number!} delta
  */
-function f(x: any, y: any, z: number | undefined, alpha: number[], beta: (this: { a: string; }, arg1: string, arg2: number) => boolean, gamma: number | null, delta: number) {
+function f(x: any, y: any, z: number | undefined, alpha: number[], beta: (this: { a: string }, arg1: string, arg2: number) => boolean, gamma: number | null, delta: number) {
     x; y; z; alpha; beta; gamma; delta;
 }`,
 });

tests/cases/fourslash/codeFixClassImplementInterfaceObjectLiteral.ts

@@ -18,6 +18,6 @@ verify.codeFix({
     }
 }
 class Person implements IPerson {
-    coordinate: { x: number; y: number; };
+    coordinate: { x: number; y: number };
 }`,
 });

tests/cases/fourslash/codeFixClassImplementInterfacePropertySignatures.ts

@@ -43,13 +43,13 @@ class C implements I {
     a0: {};
     a1: (b1: number, c1: string) => number;
     a2: (b2: number, c2: string) => number;
-    a3: { (b3: number, c3: string): number; x: number; };
+    a3: { (b3: number, c3: string): number; x: number };
     a4: new (b1: number, c1: string) => number;
     a5: new (b2: number, c2: string) => number;
-    a6: { new(b3: number, c3: string): number; x: number; };
-    a7: { foo(b7: number, c7: string): number; };
-    a8: { (b81: number, c81: string): number; new(b82: number, c82: string): number; };
-    a9: { (b9: number, c9: string): number;[d9: number]: I; };
-    a10: { (b10: number, c10: string): number;[d10: string]: I; };
+    a6: { new(b3: number, c3: string): number; x: number };
+    a7: { foo(b7: number, c7: string): number };
+    a8: { (b81: number, c81: string): number; new(b82: number, c82: string): number };
+    a9: { (b9: number, c9: string): number;[d9: number]: I };
+    a10: { (b10: number, c10: string): number;[d10: string]: I };
 }`,
 });

tests/cases/fourslash/codeFixClassImplementInterfaceSomePropertiesPresent.ts

@@ -12,5 +12,5 @@
 //// }
 
 verify.rangeAfterCodeFix(`
-z: number & { __iBrand: any; };
+z: number & { __iBrand: any };
 `);

tests/cases/fourslash/codeFixClassImplementInterfaceTypeParamInstantiateDeeply.ts

@@ -12,6 +12,6 @@ verify.codeFix({
     x: { y: T, z: T[] };
 }
 class C implements I<number> {
-    x: { y: number; z: number[]; };
+    x: { y: number; z: number[] };
 }`,
 });

tests/cases/fourslash/codeFixInferFromCallInAssignment.ts

@@ -6,4 +6,4 @@
 ////     return result
 //// }
 
-verify.rangeAfterCodeFix("app: { use: (arg0: string) => any; }");
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => any }");

tests/cases/fourslash/codeFixInferFromExpressionStatement.ts

@@ -5,4 +5,4 @@
 ////     app.use('hi')
 //// }
 
-verify.rangeAfterCodeFix("app: { use: (arg0: string) => void; }");
+verify.rangeAfterCodeFix("app: { use: (arg0: string) => void }");

tests/cases/fourslash/codeFixInferFromFunctionThisUsageImplicitAny.ts

@@ -21,5 +21,5 @@
 verify.codeFix({
     description: "Infer 'this' type of 'returnThisMember' from usage",
     index: 0,
-    newRangeContent: "this: { member: string; returnThisMember: () => any; } ",
+    newRangeContent: "this: { member: string; returnThisMember: () => any } ",
 });

tests/cases/fourslash/codeFixInferFromFunctionThisUsageLiteral.ts

@@ -13,5 +13,5 @@
 verify.codeFix({
     description: "Infer 'this' type of 'returnThisMember' from usage",
     index: 0,
-    newRangeContent: "this: { member: string; returnThisMember: () => any; } ",
+    newRangeContent: "this: { member: string; returnThisMember: () => any } ",
 });

tests/cases/fourslash/codeFixInferFromFunctionUsage.ts

@@ -6,4 +6,4 @@
 //// }
 
 // https://github.com/Microsoft/TypeScript/issues/29330
-verify.rangeAfterCodeFix("arr: { other: (arg0: (a: number, b: number) => 1 | -1) => void; }");
+verify.rangeAfterCodeFix("arr: { other: (arg0: (a: number, b: number) => 1 | -1) => void }");

tests/cases/fourslash/codeFixInferFromUsageEmptyTypePriority.ts

@@ -10,4 +10,4 @@
 ////  var beforeExpr = !!conf.beforeExpr;
 ////};
 
-verify.rangeAfterCodeFix("label: any, conf: { keyword?: any; beforeExpr?: any; } | undefined",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("label: any, conf: { keyword?: any; beforeExpr?: any } | undefined",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

tests/cases/fourslash/codeFixInferFromUsageJSXElement.ts

@@ -30,4 +30,4 @@
 //// }
 
 
-verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => any; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("props: { isLoading: any; update: (arg0: any) => any }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

tests/cases/fourslash/codeFixInferFromUsageMultipleParameters.ts

@@ -6,4 +6,4 @@
 //// f(1, "string", { a: 1 }, {shouldNotBeHere: 2}, {shouldNotBeHere: 2}, 3, "string");
 
 
-verify.rangeAfterCodeFix("a: number, b: string, c: { a: number; }, d: number, e = 0, ...d: (string | number)[]", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);
+verify.rangeAfterCodeFix("a: number, b: string, c: { a: number }, d: number, e = 0, ...d: (string | number)[]", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);

tests/cases/fourslash/codeFixInferFromUsagePropertyAccess.ts

@@ -12,4 +12,4 @@
 ////    return x.y.z
 ////}
 
-verify.rangeAfterCodeFix("a: { b: { c: void; }; }, m: { n: () => number; }, x: { y: { z: number[]; }; }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);
+verify.rangeAfterCodeFix("a: { b: { c: void } }, m: { n: () => number }, x: { y: { z: number[] } }", /*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, /*index*/0);

tests/cases/fourslash/codeFixInferFromUsageStringIndexSignature.ts

@@ -5,4 +5,4 @@
 ////    return a['hi'];
 ////}
 
-verify.rangeAfterCodeFix("a: { [x: string]: any; }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("a: { [x: string]: any }",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

tests/cases/fourslash/codeFixInferFromUsageUnifyAnonymousType.ts

@@ -16,4 +16,4 @@
 ////kw("6", { beforeExpr: true, prefix: true, startsExpr: true })
 
 
-verify.rangeAfterCodeFix("name: string, options: { startsExpr?: boolean; beforeExpr?: boolean; isLoop?: boolean; prefix?: boolean; keyword?: any; } | undefined",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);
+verify.rangeAfterCodeFix("name: string, options: { startsExpr?: boolean; beforeExpr?: boolean; isLoop?: boolean; prefix?: boolean; keyword?: any } | undefined",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

tests/cases/fourslash/codeFixUndeclaredMethodObjectLiteralArgs.ts

@@ -12,7 +12,7 @@ verify.codeFix({
     description: "Declare method 'foo1'",
     index: 0,
     newRangeContent: `
-    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string; }) {
+    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string }) {
         throw new Error("Method not implemented.");
     }
     `,
@@ -23,10 +23,10 @@ verify.codeFix({
     description: "Declare method 'foo2'",
     index: 0,
     newRangeContent: `
-    foo2(arg0: null, arg1: {}, arg2: { a: number; b: string; }) {
+    foo2(arg0: null, arg1: {}, arg2: { a: number; b: string }) {
         throw new Error("Method not implemented.");
     }
-    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string; }) {
+    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string }) {
         throw new Error("Method not implemented.");
     }
     `,
@@ -37,13 +37,13 @@ verify.codeFix({
     description: "Declare method 'foo3'",
     index: 0,
     newRangeContent: `
-    foo3(arg0: null, arg1: {}, arg2: { a: number; b: string; }): number {
+    foo3(arg0: null, arg1: {}, arg2: { a: number; b: string }): number {
         throw new Error("Method not implemented.");
     }
-    foo2(arg0: null, arg1: {}, arg2: { a: number; b: string; }) {
+    foo2(arg0: null, arg1: {}, arg2: { a: number; b: string }) {
         throw new Error("Method not implemented.");
     }
-    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string; }) {
+    foo1(arg0: null, arg1: {}, arg2: { a: number; b: string }) {
         throw new Error("Method not implemented.");
     }
     `