Merge branch 'master' of https://github.com/Microsoft/TypeScript into feature/eslint

Author: a-tarasyuk

src/compiler/checker.ts

@@ -3519,7 +3519,7 @@ namespace ts {
                 const sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName);
                 const printer = createPrinter({ removeComments: true, omitTrailingSemicolon: true });
                 const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
-                printer.writeNode(EmitHint.Unspecified, sig!, /*sourceFile*/ sourceFile, getTrailingSemicolonOmittingWriter(writer)); // TODO: GH#18217
+                printer.writeNode(EmitHint.Unspecified, sig!, /*sourceFile*/ sourceFile, getTrailingSemicolonDeferringWriter(writer)); // TODO: GH#18217
                 return writer;
             }
         }

src/compiler/diagnosticMessages.json

@@ -5120,6 +5120,10 @@
         "category": "Message",
         "code": 95089
     },
+    "Extract to interface": {
+        "category": "Message",
+        "code": 95090
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -1053,7 +1053,7 @@ namespace ts {
 
         function setWriter(_writer: EmitTextWriter | undefined, _sourceMapGenerator: SourceMapGenerator | undefined) {
             if (_writer && printerOptions.omitTrailingSemicolon) {
-                _writer = getTrailingSemicolonOmittingWriter(_writer);
+                _writer = getTrailingSemicolonDeferringWriter(_writer);
             }
 
             writer = _writer!; // TODO: GH#18217
@@ -2510,7 +2510,7 @@ namespace ts {
             }
 
             emitWhileClause(node, node.statement.end);
-            writePunctuation(";");
+            writeTrailingSemicolon();
         }
 
         function emitWhileStatement(node: WhileStatement) {

src/compiler/utilities.ts

@@ -3378,7 +3378,11 @@ namespace ts {
         };
     }
 
-    export function getTrailingSemicolonOmittingWriter(writer: EmitTextWriter): EmitTextWriter {
+    export interface TrailingSemicolonDeferringWriter extends EmitTextWriter {
+        resetPendingTrailingSemicolon(): void;
+    }
+
+    export function getTrailingSemicolonDeferringWriter(writer: EmitTextWriter): TrailingSemicolonDeferringWriter {
         let pendingTrailingSemicolon = false;
 
         function commitPendingTrailingSemicolon() {
@@ -3444,10 +3448,24 @@ namespace ts {
             decreaseIndent() {
                 commitPendingTrailingSemicolon();
                 writer.decreaseIndent();
+            },
+            resetPendingTrailingSemicolon() {
+                pendingTrailingSemicolon = false;
             }
         };
     }
 
+    export function getTrailingSemicolonOmittingWriter(writer: EmitTextWriter): EmitTextWriter {
+        const deferringWriter = getTrailingSemicolonDeferringWriter(writer);
+        return {
+            ...deferringWriter,
+            writeLine() {
+                deferringWriter.resetPendingTrailingSemicolon();
+                writer.writeLine();
+            },
+        };
+    }
+
     export function getResolvedExternalModuleName(host: EmitHost, file: SourceFile, referenceFile?: SourceFile): string {
         return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
     }

src/services/refactors/extractType.ts

@@ -2,6 +2,7 @@
 namespace ts.refactor {
     const refactorName = "Extract type";
     const extractToTypeAlias = "Extract to type alias";
+    const extractToInterface = "Extract to interface";
     const extractToTypeDef = "Extract to typedef";
     registerRefactor(refactorName, {
         getAvailableActions(context): readonly ApplicableRefactorInfo[] {
@@ -11,31 +12,51 @@ namespace ts.refactor {
             return [{
                 name: refactorName,
                 description: getLocaleSpecificMessage(Diagnostics.Extract_type),
-                actions: [info.isJS ? {
+                actions: info.isJS ? [{
                     name: extractToTypeDef, description: getLocaleSpecificMessage(Diagnostics.Extract_to_typedef)
-                } : {
+                }] : append([{
                     name: extractToTypeAlias, description: getLocaleSpecificMessage(Diagnostics.Extract_to_type_alias)
-                }]
+                }], info.typeElements && {
+                    name: extractToInterface, description: getLocaleSpecificMessage(Diagnostics.Extract_to_interface)
+                })
             }];
         },
         getEditsForAction(context, actionName): RefactorEditInfo {
-            Debug.assert(actionName === extractToTypeAlias || actionName === extractToTypeDef, "Unexpected action name");
             const { file } = context;
             const info = Debug.assertDefined(getRangeToExtract(context), "Expected to find a range to extract");
-            Debug.assert(actionName === extractToTypeAlias && !info.isJS || actionName === extractToTypeDef && info.isJS, "Invalid actionName/JS combo");
 
             const name = getUniqueName("NewType", file);
-            const edits = textChanges.ChangeTracker.with(context, changes => info.isJS ?
-                doTypedefChange(changes, file, name, info.firstStatement, info.selection, info.typeParameters) :
-                doTypeAliasChange(changes, file, name, info.firstStatement, info.selection, info.typeParameters));
+            const edits = textChanges.ChangeTracker.with(context, changes => {
+                switch (actionName) {
+                    case extractToTypeAlias:
+                        Debug.assert(!info.isJS, "Invalid actionName/JS combo");
+                        return doTypeAliasChange(changes, file, name, info);
+                    case extractToTypeDef:
+                        Debug.assert(info.isJS, "Invalid actionName/JS combo");
+                        return doTypedefChange(changes, file, name, info);
+                    case extractToInterface:
+                        Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo");
+                        return doInterfaceChange(changes, file, name, info as InterfaceInfo);
+                    default:
+                        Debug.fail("Unexpected action name");
+                }
+            });
 
             const renameFilename = file.fileName;
             const renameLocation = getRenameLocation(edits, renameFilename, name, /*preferLastLocation*/ false);
             return { edits, renameFilename, renameLocation };
         }
     });
 
-    interface Info { isJS: boolean; selection: TypeNode; firstStatement: Statement; typeParameters: readonly TypeParameterDeclaration[]; }
+    interface TypeAliasInfo {
+        isJS: boolean; selection: TypeNode; firstStatement: Statement; typeParameters: readonly TypeParameterDeclaration[]; typeElements?: readonly TypeElement[];
+    }
+
+    interface InterfaceInfo {
+        isJS: boolean; selection: TypeNode; firstStatement: Statement; typeParameters: readonly TypeParameterDeclaration[]; typeElements: readonly TypeElement[];
+    }
+
+    type Info = TypeAliasInfo | InterfaceInfo;
 
     function getRangeToExtract(context: RefactorContext): Info | undefined {
         const { file, startPosition } = context;
@@ -51,7 +72,32 @@ namespace ts.refactor {
         const typeParameters = collectTypeParameters(checker, selection, firstStatement, file);
         if (!typeParameters) return undefined;
 
-        return { isJS, selection, firstStatement, typeParameters };
+        const typeElements = flattenTypeLiteralNodeReference(checker, selection);
+        return { isJS, selection, firstStatement, typeParameters, typeElements };
+    }
+
+    function flattenTypeLiteralNodeReference(checker: TypeChecker, node: TypeNode | undefined): readonly TypeElement[] | undefined {
+        if (!node) return undefined;
+        if (isIntersectionTypeNode(node)) {
+            const result: TypeElement[] = [];
+            const seen = createMap<true>();
+            for (const type of node.types) {
+                const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type);
+                if (!flattenedTypeMembers || !flattenedTypeMembers.every(type => type.name && addToSeen(seen, getNameFromPropertyName(type.name) as string))) {
+                    return undefined;
+                }
+
+                addRange(result, flattenedTypeMembers);
+            }
+            return result;
+        }
+        else if (isParenthesizedTypeNode(node)) {
+            return flattenTypeLiteralNodeReference(checker, node.type);
+        }
+        else if (isTypeLiteralNode(node)) {
+            return node.members;
+        }
+        return undefined;
     }
 
     function isStatementAndHasJSDoc(n: Node): n is (Statement & HasJSDoc) {
@@ -107,7 +153,9 @@ namespace ts.refactor {
         }
     }
 
-    function doTypeAliasChange(changes: textChanges.ChangeTracker, file: SourceFile, name: string, firstStatement: Statement, selection: TypeNode, typeParameters: readonly TypeParameterDeclaration[]) {
+    function doTypeAliasChange(changes: textChanges.ChangeTracker, file: SourceFile, name: string, info: TypeAliasInfo) {
+        const { firstStatement, selection, typeParameters } = info;
+
         const newTypeNode = createTypeAliasDeclaration(
             /* decorators */ undefined,
             /* modifiers */ undefined,
@@ -119,7 +167,24 @@ namespace ts.refactor {
         changes.replaceNode(file, selection, createTypeReferenceNode(name, typeParameters.map(id => createTypeReferenceNode(id.name, /* typeArguments */ undefined))));
     }
 
-    function doTypedefChange(changes: textChanges.ChangeTracker, file: SourceFile, name: string, firstStatement: Statement, selection: TypeNode, typeParameters: readonly TypeParameterDeclaration[]) {
+    function doInterfaceChange(changes: textChanges.ChangeTracker, file: SourceFile, name: string, info: InterfaceInfo) {
+        const { firstStatement, selection, typeParameters, typeElements } = info;
+
+        const newTypeNode = createInterfaceDeclaration(
+            /* decorators */ undefined,
+            /* modifiers */ undefined,
+            name,
+            typeParameters,
+            /* heritageClauses */ undefined,
+            typeElements
+        );
+        changes.insertNodeBefore(file, firstStatement, newTypeNode, /* blankLineBetween */ true);
+        changes.replaceNode(file, selection, createTypeReferenceNode(name, typeParameters.map(id => createTypeReferenceNode(id.name, /* typeArguments */ undefined))));
+    }
+
+    function doTypedefChange(changes: textChanges.ChangeTracker, file: SourceFile, name: string, info: Info) {
+        const { firstStatement, selection, typeParameters } = info;
+
         const node = <JSDocTypedefTag>createNode(SyntaxKind.JSDocTypedefTag);
         node.tagName = createIdentifier("typedef"); // TODO: jsdoc factory https://github.com/Microsoft/TypeScript/pull/29539
         node.fullName = createIdentifier(name);

src/services/textChanges.ts

@@ -854,7 +854,7 @@ namespace ts.textChanges {
             const omitTrailingSemicolon = !!sourceFile && !probablyUsesSemicolons(sourceFile);
             const writer = createWriter(newLineCharacter, omitTrailingSemicolon);
             const newLine = newLineCharacter === "\n" ? NewLineKind.LineFeed : NewLineKind.CarriageReturnLineFeed;
-            createPrinter({ newLine, neverAsciiEscape: true, omitTrailingSemicolon }, writer).writeNode(EmitHint.Unspecified, node, sourceFile, writer);
+            createPrinter({ newLine, neverAsciiEscape: true }, writer).writeNode(EmitHint.Unspecified, node, sourceFile, writer);
             return { text: writer.getText(), node: assignPositionsToNode(node) };
         }
     }