Add noUnnecessaryCasts compiler option, quickfix

Author: weswigham

src/compiler/checker.ts

@@ -19882,6 +19882,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     }
                 }
                 if (sourceFlags & TypeFlags.Conditional) {
+                    if ((source as ConditionalType).root === (target as ConditionalType).root) {
+                        // Two instantiations of the same conditional type, just check instantiated outer type parameter equality
+                        const params = (source as ConditionalType).root.outerTypeParameters || [];
+                        const sourceTypeArguments = map(params, t => (source as ConditionalType).mapper ? getMappedType(t, (source as ConditionalType).mapper!) : t);
+                        const targetTypeArguments = map(params, t => (target as ConditionalType).mapper ? getMappedType(t, (target as ConditionalType).mapper!) : t);
+                        return typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, map(params, () => VarianceFlags.Unmeasurable), /*reportErrors*/ false, IntersectionState.None);
+                    }
                     if ((source as ConditionalType).root.isDistributive === (target as ConditionalType).root.isDistributive) {
                         if (result = isRelatedTo((source as ConditionalType).checkType, (target as ConditionalType).checkType, RecursionFlags.Both, /*reportErrors*/ false)) {
                             if (result &= isRelatedTo((source as ConditionalType).extendsType, (target as ConditionalType).extendsType, RecursionFlags.Both, /*reportErrors*/ false)) {
@@ -32779,6 +32786,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     checkTypeComparableTo(exprType, targetType, errNode,
                         Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
                 }
+                else if (isTypeIdenticalTo(targetType, widenedType)) {
+                    errorOrSuggestion(!!compilerOptions.noUnnecessaryCasts, errNode, Diagnostics.Type_cast_has_no_effect_on_the_type_of_this_expression);
+                }
             });
         }
         return targetType;

src/compiler/commandLineParser.ts

@@ -800,6 +800,15 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         description: Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
         defaultValueDescription: false,
     },
+    {
+        name: "noUnnecessaryCasts",
+        type: "boolean",
+        affectsSemanticDiagnostics: true,
+        affectsBuildInfo: true,
+        category: Diagnostics.Type_Checking,
+        description: Diagnostics.Raise_an_error_when_a_type_cast_does_not_affect_the_type_of_an_expression,
+        defaultValueDescription: false,
+    },
     {
         name: "exactOptionalPropertyTypes",
         type: "boolean",

src/compiler/diagnosticMessages.json

@@ -5919,6 +5919,10 @@
         "category": "Message",
         "code": 6803
     },
+    "Raise an error when a type cast does not affect the type of an expression.": {
+        "category": "Message",
+        "code": 6804
+    },
 
     "one of:": {
         "category": "Message",
@@ -6534,6 +6538,10 @@
         "category": "Suggestion",
         "code": 80008
     },
+    "Type cast has no effect on the type of this expression.": {
+        "category": "Error",
+        "code": 80009
+    },
 
     "Add missing 'super()' call": {
         "category": "Message",
@@ -7392,6 +7400,14 @@
         "category": "Message",
         "code": 95175
     },
+    "Remove unnecessary type cast.": {
+        "category": "Message",
+        "code": 95176
+    },
+    "Remove all unnecessary type casts.": {
+        "category": "Message",
+        "code": 95177
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/types.ts

@@ -6713,6 +6713,7 @@ export interface CompilerOptions {
     noImplicitReturns?: boolean;
     noImplicitThis?: boolean;  // Always combine with strict property
     noStrictGenericChecks?: boolean;
+    noUnnecessaryCasts?: boolean;
     noUnusedLocals?: boolean;
     noUnusedParameters?: boolean;
     noImplicitUseStrict?: boolean;

src/services/_namespaces/ts.codefix.ts

@@ -66,6 +66,7 @@ export * from "../codefixes/wrapJsxInFragment";
 export * from "../codefixes/convertToMappedObjectType";
 export * from "../codefixes/removeAccidentalCallParentheses";
 export * from "../codefixes/removeUnnecessaryAwait";
+export * from "../codefixes/removeUnnecessaryCast";
 export * from "../codefixes/splitTypeOnlyImport";
 export * from "../codefixes/convertConstToLet";
 export * from "../codefixes/fixExpectedComma";

src/services/codefixes/removeUnnecessaryCast.ts

@@ -0,0 +1,44 @@
+import {
+    Diagnostics, findAncestor, isAssertionExpression, isInJSDoc, Node,
+    isParenthesizedExpression, ParenthesizedExpression, SourceFile, textChanges, TextSpan, tryCast, HasJSDoc, first, last, needsParentheses,
+} from "../_namespaces/ts";
+import { codeFixAll, createCodeFixAction, findAncestorMatchingSpan, registerCodeFix } from "../_namespaces/ts.codefix";
+
+const fixId = "removeUnnecessaryCast";
+const errorCodes = [
+    Diagnostics.Type_cast_has_no_effect_on_the_type_of_this_expression.code,
+];
+
+registerCodeFix({
+    errorCodes,
+    getCodeActions: function getCodeActionsToRemoveUnnecessaryCast(context) {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span));
+        if (changes.length > 0) {
+            return [createCodeFixAction(fixId, changes, Diagnostics.Remove_unnecessary_type_cast, fixId, Diagnostics.Remove_all_unnecessary_type_casts)];
+        }
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => {
+        return codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag));
+    },
+});
+
+function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, span: TextSpan) {
+    let node: Node | undefined = findAncestorMatchingSpan(sourceFile, span);
+    if (node && isInJSDoc(node)) {
+        node = findAncestor(node, isParenthesizedExpression);
+        if (node) {
+            changeTracker.deleteNodeRange(sourceFile, first((node as HasJSDoc).jsDoc!), last((node as HasJSDoc).jsDoc!));
+            if (!needsParentheses((node as ParenthesizedExpression).expression)) {
+                changeTracker.replaceNode(sourceFile, node, (node as ParenthesizedExpression).expression);
+            }
+        }
+        return;
+    }
+    const castExpr = tryCast(node, isAssertionExpression);
+    if (!castExpr) {
+        return;
+    }
+
+    changeTracker.replaceNode(sourceFile, castExpr, castExpr.expression);
+}

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

@@ -7120,6 +7120,7 @@ declare namespace ts {
         noImplicitReturns?: boolean;
         noImplicitThis?: boolean;
         noStrictGenericChecks?: boolean;
+        noUnnecessaryCasts?: boolean;
         noUnusedLocals?: boolean;
         noUnusedParameters?: boolean;
         noImplicitUseStrict?: boolean;

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

@@ -3182,6 +3182,7 @@ declare namespace ts {
         noImplicitReturns?: boolean;
         noImplicitThis?: boolean;
         noStrictGenericChecks?: boolean;
+        noUnnecessaryCasts?: boolean;
         noUnusedLocals?: boolean;
         noUnusedParameters?: boolean;
         noImplicitUseStrict?: boolean;

tests/baselines/reference/config/initTSConfig/Default initialized TSConfig/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --help/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with --watch/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with advanced options/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     "noUnusedLocals": true,                              /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with enum value compiler options/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with files options/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/initTSConfig/Initialized TSConfig with list compiler options/tsconfig.json

@@ -87,6 +87,7 @@
     // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
     // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
     // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "noUnnecessaryCasts": true,                       /* Raise an error when a type cast does not affect the type of an expression. */
     // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
     // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
     // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */

tests/baselines/reference/config/showConfig/Shows tsconfig for single option/noUnnecessaryCasts/tsconfig.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "noUnnecessaryCasts": true
+    }
+}

tests/baselines/reference/noUnnecessaryCasts1.errors.txt

@@ -0,0 +1,34 @@
+tests/cases/conformance/additionalChecks/noUnnecessaryCasts1.ts(3,5): error TS80009: Type cast has no effect on the type of this expression.
+tests/cases/conformance/additionalChecks/noUnnecessaryCasts1.ts(8,19): error TS80009: Type cast has no effect on the type of this expression.
+tests/cases/conformance/additionalChecks/noUnnecessaryCasts1.ts(17,18): error TS80009: Type cast has no effect on the type of this expression.
+tests/cases/conformance/additionalChecks/noUnnecessaryCasts1.ts(18,18): error TS80009: Type cast has no effect on the type of this expression.
+
+
+==== tests/cases/conformance/additionalChecks/noUnnecessaryCasts1.ts (4 errors) ====
+    const a = {};
+    let b: {};
+    b = a as {};
+        ~~~~~~~
+!!! error TS80009: Type cast has no effect on the type of this expression.
+    interface Foo {
+      x?: string;
+    }
+    const foo1: Foo = {x: "ok"} as Foo; // cast technically erases type information, not a no-op
+    const foo2: Foo = foo1 as Foo;
+                      ~~~~~~~~~~~
+!!! error TS80009: Type cast has no effect on the type of this expression.
+    class A {
+      item: any;
+    }
+    class B {
+      item: any;
+    }
+    const aCls = new A();
+    const bCls = new B();
+    const aCls2: A = bCls as A;
+                     ~~~~~~~~~
+!!! error TS80009: Type cast has no effect on the type of this expression.
+    const bCls2: B = aCls as A;
+                     ~~~~~~~~~
+!!! error TS80009: Type cast has no effect on the type of this expression.
+    

tests/baselines/reference/noUnnecessaryCasts1.js

@@ -0,0 +1,41 @@
+//// [noUnnecessaryCasts1.ts]
+const a = {};
+let b: {};
+b = a as {};
+interface Foo {
+  x?: string;
+}
+const foo1: Foo = {x: "ok"} as Foo; // cast technically erases type information, not a no-op
+const foo2: Foo = foo1 as Foo;
+class A {
+  item: any;
+}
+class B {
+  item: any;
+}
+const aCls = new A();
+const bCls = new B();
+const aCls2: A = bCls as A;
+const bCls2: B = aCls as A;
+
+
+//// [noUnnecessaryCasts1.js]
+var a = {};
+var b;
+b = a;
+var foo1 = { x: "ok" }; // cast technically erases type information, not a no-op
+var foo2 = foo1;
+var A = /** @class */ (function () {
+    function A() {
+    }
+    return A;
+}());
+var B = /** @class */ (function () {
+    function B() {
+    }
+    return B;
+}());
+var aCls = new A();
+var bCls = new B();
+var aCls2 = bCls;
+var bCls2 = aCls;