add support for heritageClauses

Author: Kingwl

src/services/codefixes/convertToMappedObjectType.ts

@@ -49,7 +49,7 @@ namespace ts.codefix {
         if (!isIndexSignatureParameterName(token)) return undefined;
 
         const indexSignature = <IndexSignatureDeclaration>token.parent.parent;
-        const container: FixableDeclaration = isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : <TypeAliasDeclaration>indexSignature.parent.parent;
+        const container = isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : <TypeAliasDeclaration>indexSignature.parent.parent;
         const members = isInterfaceDeclaration(container) ? container.members : (<TypeLiteralNode>container.type).members;
         const otherMembers = filter(members, member => !isIndexSignatureDeclaration(member));
         const parameter = first(indexSignature.parameters);
@@ -63,21 +63,33 @@ namespace ts.codefix {
         };
     }
 
+    function getInterfaceHeritageClauses(declaration: FixableDeclaration): NodeArray<ExpressionWithTypeArguments> | undefined {
+        if (!isInterfaceDeclaration(declaration)) return undefined;
+
+        const heritageClause = getHeritageClause(declaration.heritageClauses, SyntaxKind.ExtendsKeyword);
+        return heritageClause && heritageClause.types;
+    }
+
     function createTypeAliasFromInterface(indexSignature: IndexSignatureDeclaration, declaration: FixableDeclaration, otherMembers: ReadonlyArray<TypeElement>, parameterName: Identifier, parameterType: TypeNode) {
-        const mappedIntersectionType: TypeNode[] = [
-            createMappedTypeNode(
-                hasReadonlyModifier(indexSignature) ? createModifier(SyntaxKind.ReadonlyKeyword) : undefined,
-                createTypeParameterDeclaration(parameterName, parameterType),
-                indexSignature.questionToken,
-                indexSignature.type)
-        ];
+        const heritageClauses = getInterfaceHeritageClauses(declaration);
+        const mappedTypeParameter = createTypeParameterDeclaration(parameterName, parameterType);
+        const mappedIntersectionType = createMappedTypeNode(
+            hasReadonlyModifier(indexSignature) ? createModifier(SyntaxKind.ReadonlyKeyword) : undefined,
+            mappedTypeParameter,
+            indexSignature.questionToken,
+            indexSignature.type);
 
         return createTypeAliasDeclaration(
             declaration.decorators,
             declaration.modifiers,
             declaration.name,
             declaration.typeParameters,
-            createIntersectionTypeNode(append(mappedIntersectionType, otherMembers.length ? createTypeLiteralNode(otherMembers) : undefined))
+            createIntersectionTypeNode(
+                concatenate(
+                    heritageClauses,
+                    append<TypeNode>([mappedIntersectionType], otherMembers.length ? createTypeLiteralNode(otherMembers) : undefined)
+                )
+            )
         );
     }
 

tests/cases/fourslash/codeFixConvertToMappedObjectType10.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar<T> { bar: T; }
+//// interface SomeType<T> extends Foo, Bar<T> {
+////     a: number;
+////     b: T;
+////     [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+interface Bar<T> { bar: T; }
+type SomeType<T> = Foo & Bar<T> & {
+    [prop in K]: any;
+} & {
+        a: number;
+        b: T;
+    };`
+})

tests/cases/fourslash/codeFixConvertToMappedObjectType11.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar<T> { bar: T; }
+//// interface SomeType<T> extends Foo, Bar<T> {
+////     a: number;
+////     b: T;
+////     readonly [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+interface Bar<T> { bar: T; }
+type SomeType<T> = Foo & Bar<T> & {
+    readonly [prop in K]: any;
+} & {
+        a: number;
+        b: T;
+    };`
+})

tests/cases/fourslash/codeFixConvertToMappedObjectType12.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar<T> { bar: T; }
+//// interface SomeType<T> extends Foo, Bar<T> {
+////     a: number;
+////     b: T;
+////     readonly [prop: K]?: any;
+//// }
+
+verify.not.codeFixAvailable()

tests/cases/fourslash/codeFixConvertToMappedObjectType6.ts

@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface SomeType extends Foo {
+////     [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+type SomeType = Foo & {
+    [prop in K]: any;
+};`
+})

tests/cases/fourslash/codeFixConvertToMappedObjectType7.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar { }
+//// interface SomeType extends Foo, Bar {
+////     [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+interface Bar { }
+type SomeType = Foo & Bar & {
+    [prop in K]: any;
+};`
+})

tests/cases/fourslash/codeFixConvertToMappedObjectType8.ts

@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar { }
+//// interface SomeType extends Foo, Bar {
+////     a: number;
+////     [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+interface Bar { }
+type SomeType = Foo & Bar & {
+    [prop in K]: any;
+} & {
+        a: number;
+    };`
+})

tests/cases/fourslash/codeFixConvertToMappedObjectType9.ts

@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts' />
+
+//// type K = "foo" | "bar";
+//// interface Foo { }
+//// interface Bar<T> { bar: T; }
+//// interface SomeType extends Foo, Bar<number> {
+////     a: number;
+////     [prop: K]: any;
+//// }
+
+verify.codeFix({
+    description: `Convert 'SomeType' to mapped object type`,
+    newFileContent: `type K = "foo" | "bar";
+interface Foo { }
+interface Bar<T> { bar: T; }
+type SomeType = Foo & Bar<number> & {
+    [prop in K]: any;
+} & {
+        a: number;
+    };`
+})