convert JSDoc typedef to type, issue#50644

Author: Brenda Huang

src/compiler/diagnosticMessages.json

@@ -7548,5 +7548,13 @@
     "The value '{0}' cannot be used here.": {
         "category": "Error",
         "code": 18050
+    },
+    "Convert typedef to type": {
+        "category": "Message",
+        "code": 18051
+    },
+    "Convert all typedefs to types": {
+        "category": "Message",
+        "code": 18052
     }
 }

src/services/_namespaces/ts.codefix.ts

@@ -17,6 +17,7 @@ export * from "../codefixes/convertToEsModule";
 export * from "../codefixes/correctQualifiedNameToIndexedAccessType";
 export * from "../codefixes/convertToTypeOnlyExport";
 export * from "../codefixes/convertToTypeOnlyImport";
+export * from "../codefixes/convertTypedefToType";
 export * from "../codefixes/convertLiteralTypeToMappedType";
 export * from "../codefixes/fixClassIncorrectlyImplementsInterface";
 export * from "../codefixes/importFixes";

src/services/codefixes/convertTypedefToType.ts

@@ -0,0 +1,187 @@
+import {
+    Diagnostics, factory, SourceFile, SyntaxKind, Node, JSDocTypedefTag,
+    JSDocTypeLiteral, JSDocPropertyTag, JSDocTypeExpression, InterfaceDeclaration,
+    TypeAliasDeclaration, ParenthesizedTypeNode, UnionTypeNode, PropertySignature,
+    TypeNodeSyntaxKind, TypeNode, HasJSDoc, isJSDocTypedefTag, hasJSDocNodes,
+    isInJSDoc, getTokenAtPosition, textChanges, flatMap
+} from "../_namespaces/ts";
+import { codeFixAll, createCodeFixAction, registerCodeFix } from "../_namespaces/ts.codefix";
+
+const fixId = "convertTypedefToType";
+const errorCodes = [Diagnostics.Convert_typedef_to_type.code];
+registerCodeFix({
+    fixIds: [fixId],
+    errorCodes,
+    getCodeActions(context) {
+        const node = getTokenAtPosition(
+            context.sourceFile,
+            context.span.start
+        );
+        if (!node) return;
+        const changes = textChanges.ChangeTracker.with(context, t => doChange(t, node, context.sourceFile));
+
+        if (changes.length > 0) {
+            return [
+                createCodeFixAction(
+                    fixId,
+                    changes,
+                    Diagnostics.Convert_typedef_to_type,
+                    fixId,
+                    Diagnostics.Convert_all_typedefs_to_types
+                ),
+            ];
+        }
+    },
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+        const node = getTokenAtPosition(diag.file, diag.start);
+        if (node) doChange(changes, node, diag.file);
+    })
+});
+
+function doChange(changes: textChanges.ChangeTracker, node: Node, sourceFile: SourceFile) {
+    if (containsTypeDefTag(node)) {
+        fixSingleTypeDef(changes, node, sourceFile);
+    }
+}
+
+function fixSingleTypeDef(
+    changes: textChanges.ChangeTracker,
+    typeDefNode: JSDocTypedefTag | undefined,
+    sourceFile: SourceFile,
+) {
+    if (!typeDefNode) return;
+
+    const declaration = createDeclaration(typeDefNode);
+    if(!declaration) return;
+
+    const comment = typeDefNode.parent;
+
+    changes.replaceNode(
+        sourceFile,
+        comment,
+        declaration
+    );
+}
+
+function createDeclaration(tagNode: JSDocTypedefTag): InterfaceDeclaration | TypeAliasDeclaration | undefined {
+    const typeName = tagNode.name?.getFullText().trim();
+    const typeExpression = tagNode.typeExpression;
+    if (!typeName || !typeExpression) return;
+
+    // for use case @typedef {object}Foo @property{bar}number
+    if (typeExpression.kind === SyntaxKind.JSDocTypeLiteral) {
+        return createDeclarationFromTypeLiteral(typeName, typeExpression);
+    }
+    // for use case @typedef {(number|string|undefined)} Foo or @typedef {number|string|undefined} Foo
+    else if (typeExpression.kind === SyntaxKind.JSDocTypeExpression) {
+        return createDeclarationFromTypeExpression(typeName, typeExpression);
+    }
+}
+
+function createDeclarationFromTypeLiteral(typeName: string, typeExpression: JSDocTypeLiteral): InterfaceDeclaration | undefined {
+    if (!typeName || !typeExpression) return;
+    const propertyTags = typeExpression.jsDocPropertyTags;
+    if (!propertyTags) return;
+
+    const propertySignatures = createPropertySignatures(propertyTags as JSDocPropertyTag[]);
+
+    if(!propertySignatures || propertySignatures.length === 0) return;
+    const interfaceDeclaration = factory.createInterfaceDeclaration(
+        [],
+        typeName,
+        [],
+        [],
+        propertySignatures,
+    );
+    return interfaceDeclaration;
+}
+
+function createDeclarationFromTypeExpression(typeName: string, typeExpression: JSDocTypeExpression): TypeAliasDeclaration | undefined {
+    if (!typeName || !typeExpression) return;
+
+    let type = typeExpression.type;
+    if (type.kind === SyntaxKind.ParenthesizedType) {
+        type = (type as ParenthesizedTypeNode).type;
+    }
+
+    if (type.kind === SyntaxKind.UnionType) {
+        return createTypeAliasForUnionType(type as UnionTypeNode, typeName);
+    }
+}
+
+function createPropertySignatures(tags: JSDocPropertyTag[]): PropertySignature[] | undefined{
+    const props = tags.reduce((signatures: PropertySignature[], tag: JSDocPropertyTag) => {
+        const propertyName = tag.name.getFullText().trim();
+        const propertyType = (tag.typeExpression?.type)?.getFullText().trim();
+        if(propertyName && propertyType) {
+            const prop = factory.createPropertySignature(
+                [],
+                propertyName,
+                // eslint-disable-next-line local/boolean-trivia
+                undefined,
+                factory.createTypeReferenceNode(propertyType)
+            );
+            return [...signatures, prop];
+        }
+
+    }, []);
+    return props;
+}
+
+function createTypeAliasForUnionType(type: UnionTypeNode, typeName: string): TypeAliasDeclaration | undefined {
+    const elements = type.types;
+        const nodes = elements.reduce((nodeArray, element) => {
+            const node = transformUnionTypeKeyword(element.kind);
+            if (node) return [...nodeArray, node];
+        }, []);
+        if (!nodes) return;
+        const typeReference = factory.createUnionTypeNode(nodes);
+        const unionDeclaration = factory.createTypeAliasDeclaration(
+            [],
+            factory.createIdentifier(typeName),
+            [],
+            typeReference
+        );
+        return unionDeclaration;
+}
+
+function transformUnionTypeKeyword(keyword: TypeNodeSyntaxKind): TypeNode | undefined {
+    switch (keyword) {
+        case SyntaxKind.NumberKeyword:
+            return factory.createTypeReferenceNode("number");
+        case SyntaxKind.StringKeyword:
+            return factory.createTypeReferenceNode("string");
+        case SyntaxKind.UndefinedKeyword:
+            return factory.createTypeReferenceNode("undefined");
+        case SyntaxKind.ObjectKeyword:
+            return factory.createTypeReferenceNode("object");
+        case SyntaxKind.VoidKeyword:
+            return factory.createTypeReferenceNode("void");
+        default:
+            return;
+    }
+}
+
+export function _containsJSDocTypedef(node: Node): node is HasJSDoc {
+    if (hasJSDocNodes(node)) {
+        const jsDocNodes = node.jsDoc || [];
+        return jsDocNodes.some((node) => {
+            const tags = node.tags || [];
+            return tags.some((tag) => isJSDocTypedefTag(tag));
+        });
+    }
+    return false;
+}
+
+export function getJSDocTypedefNode(node: HasJSDoc): JSDocTypedefTag {
+    const jsDocNodes = node.jsDoc || [];
+
+    return flatMap(jsDocNodes, (node) => {
+        const tags = node.tags || [];
+        return tags.filter((tag) => isJSDocTypedefTag(tag));
+    })[0] as unknown as JSDocTypedefTag;
+}
+
+export function containsTypeDefTag(node: Node): node is JSDocTypedefTag {
+    return isInJSDoc(node) && isJSDocTypedefTag(node);
+}

src/services/suggestionDiagnostics.ts

@@ -66,6 +66,11 @@ export function computeSuggestionDiagnostics(sourceFile: SourceFile, program: Pr
                 }
             }
 
+            if (codefix._containsJSDocTypedef(node)) {
+                const jsdocTypedefNode = codefix.getJSDocTypedefNode(node);
+                diags.push(createDiagnosticForNode(jsdocTypedefNode, Diagnostics.Convert_typedef_to_type));
+            }
+
             if (codefix.parameterShouldGetTypeFromJSDoc(node)) {
                 diags.push(createDiagnosticForNode(node.name || node, Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types));
             }

src/services/tsconfig.json

@@ -7,4 +7,4 @@
         { "path": "../jsTyping" }
     ],
     "include": ["**/*"]
-}
+}

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

@@ -9834,6 +9834,11 @@ declare namespace ts {
         emit(writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): EmitResult | BuildInvalidedProject<T> | undefined;
     }
     type InvalidatedProject<T extends BuilderProgram> = UpdateOutputFileStampsProject | BuildInvalidedProject<T> | UpdateBundleProject<T>;
+    namespace codefix {
+        function _containsJSDocTypedef(node: Node): node is HasJSDoc;
+        function getJSDocTypedefNode(node: HasJSDoc): JSDocTypedefTag;
+        function containsTypeDefTag(node: Node): node is JSDocTypedefTag;
+    }
     function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
     /**
      * Represents an immutable snapshot of a script at a specified time.Once acquired, the

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

@@ -5969,6 +5969,11 @@ declare namespace ts {
             readonly kind: ActionSet;
         }
     }
+    namespace codefix {
+        function _containsJSDocTypedef(node: Node): node is HasJSDoc;
+        function getJSDocTypedefNode(node: HasJSDoc): JSDocTypedefTag;
+        function containsTypeDefTag(node: Node): node is JSDocTypedefTag;
+    }
     function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
     /**
      * Represents an immutable snapshot of a script at a specified time.Once acquired, the

tests/cases/fourslash/codeFixConvertTypedefToType2.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+////
+//// /**
+////  * @typedef {(number|string|undefined)} Foo
+////  */
+////
+
+verify.codeFix({
+  description: ts.Diagnostics.Convert_typedef_to_type.message,
+  index: 0,
+  newFileContent: `
+type Foo = number | string | undefined;
+`,
+});

tests/cases/fourslash/codeFixConvertTypedefToType3.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+////
+//// /**
+////  * @typedef Foo
+////  * type {object}
+////  * @property {string} id - person's ID
+////  * @property {string} name - person's name
+////  * @property {number} age - person's age
+////  */
+////
+
+verify.codeFix({
+  description: ts.Diagnostics.Convert_typedef_to_type.message,
+  index: 0,
+  newFileContent: `
+interface Foo {
+    id: string;
+    name: string;
+    age: number;
+}
+`,
+});

tests/cases/fourslash/codeFixConverttypedefToType1.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////
+//// /**
+////  * @typedef {Object}Foo
+////  * @property {number}bar
+////  */
+////
+
+verify.codeFix({
+  description: ts.Diagnostics.Convert_typedef_to_type.message,
+  index: 0,
+  newFileContent: `
+interface Foo {
+    bar: number;
+}
+`,
+});