Replace as unknown as casts with as BaseType as SpecificType pattern

The intermediate `as unknown` cast is unnecessary when going through a
common base type. Using `as Statement as JS.Import` instead of
`as unknown as JS.Import` is both more readable and self-documenting.

Author: knutwannheden

rewrite-javascript/rewrite/src/javascript/cleanup/prefer-optional-chain.ts

@@ -54,7 +54,7 @@ export class PreferOptionalChain extends Recipe {
                 // Check if the false part is undefined
                 // Note: We only convert when the false part is undefined, not null,
                 // because optional chaining returns undefined (not null) when the target is nullish.
-                const falsePart = visited.falsePart as unknown as Expression;
+                const falsePart = visited.falsePart as Expression;
                 const isUndefinedFalse = falsePart.kind === J.Kind.Identifier &&
                     (falsePart as J.Identifier).simpleName === 'undefined';
 
@@ -63,7 +63,7 @@ export class PreferOptionalChain extends Recipe {
                 }
 
                 // Check if the true part accesses a property/method on the condition
-                const truePart = visited.truePart as unknown as Expression;
+                const truePart = visited.truePart as Expression;
                 const result = this.extractOptionalChainTarget(truePart, conditionName);
 
                 if (!result) {
@@ -118,7 +118,7 @@ export class PreferOptionalChain extends Recipe {
                 // Handle MethodInvocation: foo.bar()
                 if (expr.kind === J.Kind.MethodInvocation) {
                     const methodInvocation = expr as J.MethodInvocation;
-                    const selectExpr = methodInvocation.select as unknown as Expression | undefined;
+                    const selectExpr = methodInvocation.select as Expression | undefined;
                     if (selectExpr?.kind === J.Kind.Identifier) {
                         const select = selectExpr as J.Identifier;
                         if (select.simpleName === targetName) {

rewrite-javascript/rewrite/src/javascript/cleanup/use-object-property-shorthand.ts

@@ -18,7 +18,7 @@ import {Recipe} from "../../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {JavaScriptVisitor} from "../visitor";
-import {Expression, J} from "../../java";
+import {Expression, J, Statement} from "../../java";
 import {JS} from "../tree";
 import {create as produce} from "mutative";
 import {findMarker} from "../../markers";
@@ -54,8 +54,8 @@ export class UseObjectPropertyShorthand extends Recipe {
                 // For tree types, the padded value IS the element (intersection type)
                 const simplifiedBindings = visited.bindings.elements.map(right => {
                     if (right.kind === JS.Kind.BindingElement) {
-                        const binding = right as unknown as JS.BindingElement;
-                        const propNameExpr = binding.propertyName as unknown as Expression | undefined;
+                        const binding = right as J as JS.BindingElement;
+                        const propNameExpr = binding.propertyName as Expression | undefined;
                         if (propNameExpr?.kind === J.Kind.Identifier) {
                             const propName = (propNameExpr as J.Identifier).simpleName;
 
@@ -111,8 +111,8 @@ export class UseObjectPropertyShorthand extends Recipe {
 
                 const simplifiedStatements = statements.map(stmt => {
                     if (stmt.kind === JS.Kind.PropertyAssignment) {
-                        const prop = stmt as unknown as JS.PropertyAssignment;
-                        const nameExpr = prop.name as unknown as Expression;
+                        const prop = stmt as Statement as JS.PropertyAssignment;
+                        const nameExpr = prop.name as Expression;
                         if (nameExpr.kind === J.Kind.Identifier) {
                             const propName = (nameExpr as J.Identifier).simpleName;
 

rewrite-javascript/rewrite/src/javascript/migrate/es6/remove-duplicate-object-keys.ts

@@ -51,7 +51,7 @@ export class RemoveDuplicateObjectKeys extends Recipe {
                 for (let i = 0; i < statements.length; i++) {
                     const stmt = statements[i];
                     if (stmt.kind === JS.Kind.PropertyAssignment) {
-                        const prop = stmt as unknown as JS.PropertyAssignment;
+                        const prop = stmt as Statement as JS.PropertyAssignment;
                         const propName = this.getPropertyName(prop);
                         propertyNames.push(propName);
 
@@ -98,7 +98,7 @@ export class RemoveDuplicateObjectKeys extends Recipe {
             }
 
             private getPropertyName(prop: JS.PropertyAssignment): string | null {
-                const name = prop.name as unknown as Expression;
+                const name = prop.name as Expression;
 
                 // Handle identifier: { foo: 1 }
                 if (name.kind === J.Kind.Identifier) {

rewrite-javascript/rewrite/src/javascript/recipes/change-import.ts

@@ -130,7 +130,7 @@ export class ChangeImport extends Recipe {
 
                 // First pass: check if the old import exists and capture any alias
                 for (const statement of cu.statements) {
-                    const stmt = statement as unknown as Statement;
+                    const stmt = statement as Statement;
                     if (stmt.kind === JS.Kind.Import) {
                         const jsImport = stmt as JS.Import;
                         const aliasInfo = this.checkForOldImport(jsImport);

rewrite-javascript/rewrite/src/javascript/templating/placeholder-replacement.ts

@@ -106,7 +106,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
     override async visitBlock(block: J.Block, p: any): Promise<J | undefined> {
         const hasPlaceholder = block.statements.some(stmt => {
             if (stmt.kind === JS.Kind.ExpressionStatement) {
-                const exprStmt = stmt as unknown as JS.ExpressionStatement;
+                const exprStmt = stmt as Statement as JS.ExpressionStatement;
                 return this.isPlaceholder(exprStmt.expression);
             }
             return this.isPlaceholder(stmt);

rewrite-javascript/rewrite/src/javascript/templating/rewrite.ts

@@ -273,7 +273,7 @@ export function flattenBlock<P>(
             const newStatements: typeof parentBlock.statements = [];
 
             for (const stmt of parentBlock.statements) {
-                const stmtElement = stmt as unknown as Statement;
+                const stmtElement = stmt as Statement;
                 if (stmtElement === block || stmtElement.id === block.id) {
                     // Splice in the inner block's statements
                     for (let i = 0; i < block.statements.length; i++) {

rewrite-javascript/rewrite/src/javascript/templating/utils.ts

@@ -300,7 +300,7 @@ export class PlaceholderUtils {
                 if (body.statements.length === 0) {
                     throw new Error(`${contextName} function body is empty`);
                 } else if (body.statements.length === 1) {
-                    const stmt = body.statements[0] as unknown as Statement;
+                    const stmt = body.statements[0] as Statement;
 
                     // Single expression statement → extract the expression
                     if (stmt.kind === JS.Kind.ExpressionStatement) {