Add reason for a disabled code action (#37871)

* add reason for a disabled code action

* add addOrRemoveBracesToArrowFunction

* use user preferences

* add error reason

* accept baseline changes

* fix lint rules

* move messages to diagnosticMessages.json

* rename 'error' to 'notApplicableReason'

* accept baseline change

* address comments

Author: PranavSenthilnathan

src/compiler/diagnosticMessages.json

@@ -5755,6 +5755,50 @@
         "category": "Message",
         "code": 95126
     },
+    "Could not find a containing arrow function": {
+        "category": "Message",
+        "code": 95127
+    },
+    "Containing function is not an arrow function": {
+        "category": "Message",
+        "code": 95128
+    },
+    "Could not find export statement": {
+        "category": "Message",
+        "code": 95129
+    },
+    "This file already has a default export": {
+        "category": "Message",
+        "code": 95130
+    },
+    "Could not find import clause": {
+        "category": "Message",
+        "code": 95131
+    },
+    "Could not find namespace import or named imports": {
+        "category": "Message",
+        "code": 95132
+    },
+    "Selection is not a valid type node": {
+        "category": "Message",
+        "code": 95133
+    },
+    "No type could be extracted from this type node": {
+        "category": "Message",
+        "code": 95134
+    },
+    "Could not find property for which to generate accessor": {
+        "category": "Message",
+        "code": 95135
+    },
+    "Name is not valid": {
+        "category": "Message",
+        "code": 95136
+    },
+    "Can only convert property with modifier": {
+        "category": "Message",
+        "code": 95137
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/types.ts

@@ -8024,6 +8024,7 @@ namespace ts {
         readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
         readonly allowTextChangesInNewFiles?: boolean;
         readonly providePrefixAndSuffixTextForRename?: boolean;
+        readonly provideRefactorNotApplicableReason?: boolean;
     }
 
     /** Represents a bigint literal value without requiring bigint support */

src/services/codefixes/generateAccessors.ts

@@ -16,12 +16,20 @@ namespace ts.codefix {
         readonly renameAccessor: boolean;
     }
 
+    type InfoOrError = {
+        info: Info,
+        error?: never
+    } | {
+        info?: never,
+        error: string
+    };
+
     export function generateAccessorFromProperty(file: SourceFile, start: number, end: number, context: textChanges.TextChangesContext, _actionName: string): FileTextChanges[] | undefined {
         const fieldInfo = getAccessorConvertiblePropertyAtPosition(file, start, end);
-        if (!fieldInfo) return undefined;
+        if (!fieldInfo || !fieldInfo.info) return undefined;
 
         const changeTracker = textChanges.ChangeTracker.fromContext(context);
-        const { isStatic, isReadonly, fieldName, accessorName, originalName, type, container, declaration } = fieldInfo;
+        const { isStatic, isReadonly, fieldName, accessorName, originalName, type, container, declaration } = fieldInfo.info;
 
         suppressLeadingAndTrailingTrivia(fieldName);
         suppressLeadingAndTrailingTrivia(accessorName);
@@ -104,29 +112,47 @@ namespace ts.codefix {
         return modifierFlags;
     }
 
-    export function getAccessorConvertiblePropertyAtPosition(file: SourceFile, start: number, end: number, considerEmptySpans = true): Info | undefined {
+    export function getAccessorConvertiblePropertyAtPosition(file: SourceFile, start: number, end: number, considerEmptySpans = true): InfoOrError | undefined {
         const node = getTokenAtPosition(file, start);
         const cursorRequest = start === end && considerEmptySpans;
         const declaration = findAncestor(node.parent, isAcceptedDeclaration);
         // make sure declaration have AccessibilityModifier or Static Modifier or Readonly Modifier
         const meaning = ModifierFlags.AccessibilityModifier | ModifierFlags.Static | ModifierFlags.Readonly;
-        if (!declaration || !(nodeOverlapsWithStartEnd(declaration.name, file, start, end) || cursorRequest)
-            || !isConvertibleName(declaration.name) || (getEffectiveModifierFlags(declaration) | meaning) !== meaning) return undefined;
+
+        if (!declaration || (!(nodeOverlapsWithStartEnd(declaration.name, file, start, end) || cursorRequest))) {
+            return {
+                error: getLocaleSpecificMessage(Diagnostics.Could_not_find_property_for_which_to_generate_accessor)
+            };
+        }
+
+        if (!isConvertibleName(declaration.name)) {
+            return {
+                error: getLocaleSpecificMessage(Diagnostics.Name_is_not_valid)
+            };
+        }
+
+        if ((getEffectiveModifierFlags(declaration) | meaning) !== meaning) {
+            return {
+                error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_property_with_modifier)
+            };
+        }
 
         const name = declaration.name.text;
         const startWithUnderscore = startsWithUnderscore(name);
         const fieldName = createPropertyName(startWithUnderscore ? name : getUniqueName(`_${name}`, file), declaration.name);
         const accessorName = createPropertyName(startWithUnderscore ? getUniqueName(name.substring(1), file) : name, declaration.name);
         return {
-            isStatic: hasStaticModifier(declaration),
-            isReadonly: hasEffectiveReadonlyModifier(declaration),
-            type: getTypeAnnotationNode(declaration),
-            container: declaration.kind === SyntaxKind.Parameter ? declaration.parent.parent : declaration.parent,
-            originalName: (<AcceptedNameType>declaration.name).text,
-            declaration,
-            fieldName,
-            accessorName,
-            renameAccessor: startWithUnderscore
+            info: {
+                isStatic: hasStaticModifier(declaration),
+                isReadonly: hasEffectiveReadonlyModifier(declaration),
+                type: getTypeAnnotationNode(declaration),
+                container: declaration.kind === SyntaxKind.Parameter ? declaration.parent.parent : declaration.parent,
+                originalName: (<AcceptedNameType>declaration.name).text,
+                declaration,
+                fieldName,
+                accessorName,
+                renameAccessor: startWithUnderscore
+            }
         };
     }
 

src/services/refactors/addOrRemoveBracesToArrowFunction.ts

@@ -15,33 +15,61 @@ namespace ts.refactor.addOrRemoveBracesToArrowFunction {
         addBraces: boolean;
     }
 
+    type InfoOrError = {
+        info: Info,
+        error?: never
+    } | {
+        info?: never,
+        error: string
+    };
+
     function getAvailableActions(context: RefactorContext): readonly ApplicableRefactorInfo[] {
         const { file, startPosition, triggerReason } = context;
         const info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked");
         if (!info) return emptyArray;
 
-        return [{
-            name: refactorName,
-            description: refactorDescription,
-            actions: [
-                info.addBraces ?
-                    {
-                        name: addBracesActionName,
-                        description: addBracesActionDescription
-                    } : {
-                        name: removeBracesActionName,
-                        description: removeBracesActionDescription
-                    }
-            ]
-        }];
+        if (info.error === undefined) {
+            return [{
+                name: refactorName,
+                description: refactorDescription,
+                actions: [
+                    info.info.addBraces ?
+                        {
+                            name: addBracesActionName,
+                            description: addBracesActionDescription
+                        } : {
+                            name: removeBracesActionName,
+                            description: removeBracesActionDescription
+                        }
+                ]
+            }];
+        }
+
+        if (context.preferences.provideRefactorNotApplicableReason) {
+            return [{
+                name: refactorName,
+                description: refactorDescription,
+                actions: [{
+                    name: addBracesActionName,
+                    description: addBracesActionDescription,
+                    notApplicableReason: info.error
+                }, {
+                    name: removeBracesActionName,
+                    description: removeBracesActionDescription,
+                    notApplicableReason: info.error
+                }]
+            }];
+        }
+
+        return emptyArray;
     }
 
     function getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined {
         const { file, startPosition } = context;
         const info = getConvertibleArrowFunctionAtPosition(file, startPosition);
-        if (!info) return undefined;
+        if (!info || !info.info) return undefined;
 
-        const { expression, returnStatement, func } = info;
+        const { expression, returnStatement, func } = info.info;
 
         let body: ConciseBody;
 
@@ -70,28 +98,45 @@ namespace ts.refactor.addOrRemoveBracesToArrowFunction {
         return { renameFilename: undefined, renameLocation: undefined, edits };
     }
 
-    function getConvertibleArrowFunctionAtPosition(file: SourceFile, startPosition: number, considerFunctionBodies = true): Info | undefined {
+    function getConvertibleArrowFunctionAtPosition(file: SourceFile, startPosition: number, considerFunctionBodies = true): InfoOrError | undefined {
         const node = getTokenAtPosition(file, startPosition);
         const func = getContainingFunction(node);
-        // Only offer a refactor in the function body on explicit refactor requests.
-        if (!func || !isArrowFunction(func) || (!rangeContainsRange(func, node)
-            || (rangeContainsRange(func.body, node) && !considerFunctionBodies))) return undefined;
+
+        if (!func) {
+            return {
+                error: getLocaleSpecificMessage(Diagnostics.Could_not_find_a_containing_arrow_function)
+            };
+        }
+
+        if (!isArrowFunction(func)) {
+            return {
+                error: getLocaleSpecificMessage(Diagnostics.Containing_function_is_not_an_arrow_function)
+            };
+        }
+
+        if ((!rangeContainsRange(func, node) || rangeContainsRange(func.body, node) && !considerFunctionBodies)) {
+            return undefined;
+        }
 
         if (isExpression(func.body)) {
             return {
-                func,
-                addBraces: true,
-                expression: func.body
+                info: {
+                    func,
+                    addBraces: true,
+                    expression: func.body
+                }
             };
         }
         else if (func.body.statements.length === 1) {
             const firstStatement = first(func.body.statements);
             if (isReturnStatement(firstStatement)) {
                 return {
-                    func,
-                    addBraces: false,
-                    expression: firstStatement.expression,
-                    returnStatement: firstStatement
+                    info: {
+                        func,
+                        addBraces: false,
+                        expression: firstStatement.expression,
+                        returnStatement: firstStatement
+                    }
                 };
             }
         }

src/services/refactors/convertExport.ts

@@ -3,17 +3,30 @@ namespace ts.refactor {
     const refactorName = "Convert export";
     const actionNameDefaultToNamed = "Convert default export to named export";
     const actionNameNamedToDefault = "Convert named export to default export";
+
     registerRefactor(refactorName, {
         getAvailableActions(context): readonly ApplicableRefactorInfo[] {
             const info = getInfo(context, context.triggerReason === "invoked");
             if (!info) return emptyArray;
-            const description = info.wasDefault ? Diagnostics.Convert_default_export_to_named_export.message : Diagnostics.Convert_named_export_to_default_export.message;
-            const actionName = info.wasDefault ? actionNameDefaultToNamed : actionNameNamedToDefault;
-            return [{ name: refactorName, description, actions: [{ name: actionName, description }] }];
+
+            if (info.error === undefined) {
+                const description = info.info.wasDefault ? Diagnostics.Convert_default_export_to_named_export.message : Diagnostics.Convert_named_export_to_default_export.message;
+                const actionName = info.info.wasDefault ? actionNameDefaultToNamed : actionNameNamedToDefault;
+                return [{ name: refactorName, description, actions: [{ name: actionName, description }] }];
+            }
+
+            if (context.preferences.provideRefactorNotApplicableReason) {
+                return [
+                    { name: refactorName, description: Diagnostics.Convert_default_export_to_named_export.message, actions: [{ name: actionNameDefaultToNamed, description: Diagnostics.Convert_default_export_to_named_export.message, notApplicableReason: info.error }] },
+                    { name: refactorName, description: Diagnostics.Convert_named_export_to_default_export.message, actions: [{ name: actionNameNamedToDefault, description: Diagnostics.Convert_named_export_to_default_export.message, notApplicableReason: info.error }] },
+                ];
+            }
+
+            return emptyArray;
         },
         getEditsForAction(context, actionName): RefactorEditInfo {
             Debug.assert(actionName === actionNameDefaultToNamed || actionName === actionNameNamedToDefault, "Unexpected action name");
-            const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, Debug.checkDefined(getInfo(context), "context must have info"), t, context.cancellationToken));
+            const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, Debug.checkDefined(getInfo(context)?.info, "context must have info"), t, context.cancellationToken));
             return { edits, renameFilename: undefined, renameLocation: undefined };
         },
     });
@@ -27,13 +40,21 @@ namespace ts.refactor {
         readonly exportingModuleSymbol: Symbol;
     }
 
-    function getInfo(context: RefactorContext, considerPartialSpans = true): Info | undefined {
+    type InfoOrError = {
+        info: Info,
+        error?: never
+    } | {
+        info?: never,
+        error: string
+    };
+
+    function getInfo(context: RefactorContext, considerPartialSpans = true): InfoOrError | undefined {
         const { file } = context;
         const span = getRefactorContextSpan(context);
         const token = getTokenAtPosition(file, span.start);
         const exportNode = !!(token.parent && getSyntacticModifierFlags(token.parent) & ModifierFlags.Export) && considerPartialSpans ? token.parent : getParentNodeInSpan(token, file, span);
         if (!exportNode || (!isSourceFile(exportNode.parent) && !(isModuleBlock(exportNode.parent) && isAmbientModule(exportNode.parent.parent)))) {
-            return undefined;
+            return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_export_statement) };
         }
 
         const exportingModuleSymbol = isSourceFile(exportNode.parent) ? exportNode.parent.symbol : exportNode.parent.parent.symbol;
@@ -42,7 +63,7 @@ namespace ts.refactor {
         const wasDefault = !!(flags & ModifierFlags.Default);
         // If source file already has a default export, don't offer refactor.
         if (!(flags & ModifierFlags.Export) || !wasDefault && exportingModuleSymbol.exports!.has(InternalSymbolName.Default)) {
-            return undefined;
+            return { error: getLocaleSpecificMessage(Diagnostics.This_file_already_has_a_default_export) };
         }
 
         switch (exportNode.kind) {
@@ -53,7 +74,7 @@ namespace ts.refactor {
             case SyntaxKind.TypeAliasDeclaration:
             case SyntaxKind.ModuleDeclaration: {
                 const node = exportNode as FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | EnumDeclaration | TypeAliasDeclaration | NamespaceDeclaration;
-                return node.name && isIdentifier(node.name) ? { exportNode: node, exportName: node.name, wasDefault, exportingModuleSymbol } : undefined;
+                return node.name && isIdentifier(node.name) ? { info: { exportNode: node, exportName: node.name, wasDefault, exportingModuleSymbol } } : undefined;
             }
             case SyntaxKind.VariableStatement: {
                 const vs = exportNode as VariableStatement;
@@ -64,7 +85,7 @@ namespace ts.refactor {
                 const decl = first(vs.declarationList.declarations);
                 if (!decl.initializer) return undefined;
                 Debug.assert(!wasDefault, "Can't have a default flag here");
-                return isIdentifier(decl.name) ? { exportNode: vs, exportName: decl.name, wasDefault, exportingModuleSymbol } : undefined;
+                return isIdentifier(decl.name) ? { info: { exportNode: vs, exportName: decl.name, wasDefault, exportingModuleSymbol } } : undefined;
             }
             default:
                 return undefined;