Remove unnecessary defensive checks and redundant as-unknown casts

- Remove defensive ?. and ?? on padding properties in visitRightPadded
  and visitLeftPadded (padding is always present)
- Remove unnecessary as-unknown-as casts where intersection types
  already make padded values assignable to the target type
- Clean up tabs-and-indents-visitor: remove dead DEBUG logging,
  unused findMarker import, and inline trivial wrapper methods
- Remove stale "For tree types" comments

Author: knutwannheden

rewrite-javascript/rewrite/src/java/visitor.ts

@@ -1231,30 +1231,25 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     public async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: P): Promise<J.RightPadded<T> | undefined> {
         this.cursor = new Cursor(right, this.cursor);
 
-        // Check if this is a primitive wrapper (has 'element' property) or intersection type (tree node)
         const hasElement = 'element' in right;
         const visitedElement: T | undefined = hasElement
             ? (right as { element: boolean }).element as T
             : await this.visitDefined(right as J, p) as T | undefined;
 
-        // Handle missing padding (can happen with template-generated trees)
-        const after = await this.visitSpace(right.padding?.after ?? emptySpace, p);
-        const paddingMarkers = await this.visitMarkers(right.padding?.markers ?? emptyMarkers, p);
+        const after = await this.visitSpace(right.padding.after, p);
+        const paddingMarkers = await this.visitMarkers(right.padding.markers, p);
         this.cursor = this.cursor.parent!;
 
         if (visitedElement === undefined) {
             return undefined;
         }
 
-        // Build padding, preserving identity if unchanged
-        const beforePadding = right.padding;
-        const paddingUnchanged = after === beforePadding?.after && paddingMarkers === beforePadding?.markers;
-        const padding: J.Suffix = paddingUnchanged ? beforePadding! : { after, markers: paddingMarkers };
+        const paddingUnchanged = after === right.padding.after && paddingMarkers === right.padding.markers;
+        const padding: J.Suffix = paddingUnchanged ? right.padding : { after, markers: paddingMarkers };
 
         if (hasElement) {
             return updateIfChanged(right, { element: visitedElement, padding } as any);
         }
-        // Tree node - merge visited element with padding using updateIfChanged
         return updateIfChanged(visitedElement as J & { padding: J.Suffix }, { padding }) as J.RightPadded<T>;
     }
 
@@ -1279,10 +1274,8 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T> | undefined>;
     public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T> | undefined> {
         this.cursor = new Cursor(left, this.cursor);
-        // Handle missing padding (can happen with template-generated trees)
-        const before = await this.visitSpace(left.padding?.before ?? emptySpace, p);
+        const before = await this.visitSpace(left.padding.before, p);
 
-        // Check if this is a primitive wrapper (has 'element' property) or intersection type (tree node/Space)
         const hasElement = 'element' in left;
         let visitedElement: T | undefined;
 
@@ -1294,22 +1287,19 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             visitedElement = await this.visitDefined(left as J, p) as T | undefined;
         }
 
-        const paddingMarkers = await this.visitMarkers(left.padding?.markers ?? emptyMarkers, p);
+        const paddingMarkers = await this.visitMarkers(left.padding.markers, p);
         this.cursor = this.cursor.parent!;
 
         if (visitedElement === undefined) {
             return undefined;
         }
 
-        // Build padding, preserving identity if unchanged
-        const beforePadding = left.padding;
-        const paddingUnchanged = before === beforePadding?.before && paddingMarkers === beforePadding?.markers;
-        const padding: J.Prefix = paddingUnchanged ? beforePadding! : { before, markers: paddingMarkers };
+        const paddingUnchanged = before === left.padding.before && paddingMarkers === left.padding.markers;
+        const padding: J.Prefix = paddingUnchanged ? left.padding : { before, markers: paddingMarkers };
 
         if (hasElement) {
             return updateIfChanged(left, { element: visitedElement, padding } as any);
         }
-        // Tree node or Space - merge visited element with padding using updateIfChanged
         return updateIfChanged(visitedElement as (J | J.Space) & { padding: J.Prefix }, { padding }) as J.LeftPadded<T>;
     }
 

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

@@ -54,7 +54,6 @@ 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.
-                // For tree types, the padded value IS the element (intersection type)
                 const falsePart = visited.falsePart as unknown as Expression;
                 const isUndefinedFalse = falsePart.kind === J.Kind.Identifier &&
                     (falsePart as J.Identifier).simpleName === 'undefined';
@@ -64,7 +63,6 @@ export class PreferOptionalChain extends Recipe {
                 }
 
                 // Check if the true part accesses a property/method on the condition
-                // For tree types, the padded value IS the element (intersection type)
                 const truePart = visited.truePart as unknown as Expression;
                 const result = this.extractOptionalChainTarget(truePart, conditionName);
 
@@ -120,7 +118,6 @@ export class PreferOptionalChain extends Recipe {
                 // Handle MethodInvocation: foo.bar()
                 if (expr.kind === J.Kind.MethodInvocation) {
                     const methodInvocation = expr as J.MethodInvocation;
-                    // For tree types, the padded value IS the element (intersection type)
                     const selectExpr = methodInvocation.select as unknown as Expression | undefined;
                     if (selectExpr?.kind === J.Kind.Identifier) {
                         const select = selectExpr as J.Identifier;

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

@@ -53,11 +53,8 @@ export class UseObjectPropertyShorthand extends Recipe {
 
                 // For tree types, the padded value IS the element (intersection type)
                 const simplifiedBindings = visited.bindings.elements.map(right => {
-                    // right IS the element with padding mixed in
                     if (right.kind === JS.Kind.BindingElement) {
                         const binding = right as unknown as JS.BindingElement;
-
-                        // For tree types, propertyName IS the identifier with padding mixed in
                         const propNameExpr = binding.propertyName as unknown as Expression | undefined;
                         if (propNameExpr?.kind === J.Kind.Identifier) {
                             const propName = (propNameExpr as J.Identifier).simpleName;
@@ -112,13 +109,9 @@ export class UseObjectPropertyShorthand extends Recipe {
 
                 let hasChanges = false;
 
-                // For tree types, the padded value IS the element (intersection type)
                 const simplifiedStatements = statements.map(stmt => {
-                    // stmt IS the statement with padding mixed in
                     if (stmt.kind === JS.Kind.PropertyAssignment) {
                         const prop = stmt as unknown as JS.PropertyAssignment;
-
-                        // For tree types, name IS the identifier with padding mixed in
                         const nameExpr = prop.name as unknown as Expression;
                         if (nameExpr.kind === J.Kind.Identifier) {
                             const propName = (nameExpr as J.Identifier).simpleName;

rewrite-javascript/rewrite/src/javascript/comparator.ts

@@ -2260,8 +2260,7 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
      * Returns the simple name if the property is an identifier, undefined otherwise.
      */
     private getPropertyName(prop: JS.PropertyAssignment): string | undefined {
-        // For tree types, the padded value IS the element (no .element property)
-        const nameExpr = prop.name as unknown as Expression;
+        const nameExpr = prop.name;
         return isIdentifier(nameExpr) ? nameExpr.simpleName : undefined;
     }
 
@@ -2291,8 +2290,7 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
             return undefined;
         }
 
-        // With intersection types, the statement IS the padded value (no .element property)
-        const stmt = block.statements[0] as unknown as Statement;
+        const stmt = block.statements[0];
 
         if ((stmt as any).kind !== J.Kind.Return) {
             return undefined;

rewrite-javascript/rewrite/src/javascript/format/tabs-and-indents-visitor.ts

@@ -35,7 +35,6 @@ import {Cursor, isScope, isTree, Tree} from "../../tree";
 import {mapAsync} from "../../util";
 import {produceAsync} from "../../visitor";
 import {TabsAndIndentsStyle} from "../style";
-import {findMarker} from "../../markers";
 
 type IndentKind = 'block' | 'continuation' | 'align';
 type IndentContext = [number, IndentKind];  // [indent, kind]
@@ -215,10 +214,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
 
     private prefixContainsNewline(tree: J): boolean {
         // Check if the element starts on a new line (only the last whitespace matters)
-        if (tree.prefix && lastWhitespace(tree.prefix).includes("\n")) {
-            return true;
-        }
-        return false;
+        return !!(tree.prefix && lastWhitespace(tree.prefix).includes("\n"));
     }
 
     private isJsxChildElement(tree: J): boolean {
@@ -556,10 +552,6 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         // Restore cursor
         this.cursor = this.cursor.parent!;
 
-        // For tree types, ret IS the element (intersection type); check if undefined directly
-        if (ret === undefined) {
-            return undefined;
-        }
         return ret;
     }
 
@@ -627,8 +619,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         // PropertyAssignment wrapping a spread (for object spread like `...obj`)
         if (element.kind === JS.Kind.PropertyAssignment) {
             const propAssign = element as JS.PropertyAssignment;
-            // For tree types, name IS the expression with padding mixed in
-            const nameElement = propAssign.name as unknown as J | undefined;
+            const nameElement = propAssign.name;
             if (nameElement?.kind === JS.Kind.Spread) {
                 return true;
             }
@@ -654,8 +645,6 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         let anchorCursor: Cursor | undefined;
         let anchorIndent = 0;
 
-        const DEBUG = false; // Set to true to enable debug logging
-
         for (let c = this.cursor.parent; c; c = c.parent) {
             path.push(c);
             const v = c.value;
@@ -665,7 +654,6 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             if (isJavaWithPrefix && !anchorCursor) {
                 const ws = lastWhitespace(v.prefix);
                 const idx = ws.lastIndexOf('\n');
-                if (DEBUG) console.log(`  CHECK ${v.kind}: prefix=${JSON.stringify(ws.substring(0, 50))} hasNewline=${idx !== -1}`);
                 if (idx !== -1) {
                     anchorCursor = c;
                     anchorIndent = ws.length - idx - 1;
@@ -684,18 +672,6 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         if (path.length === 0) return;
         path.reverse();
 
-        if (DEBUG) {
-            console.log(`PATH (raw): ${path.map(p => {
-                const v = p.value as any;
-                const isRP = this.isRightPaddedWrapper(v);
-                const isLP = this.isLeftPaddedWrapper(v);
-                const isCont = v?.kind === J.Kind.Container;
-                const wrapper = isRP ? '[RP]' : isLP ? '[LP]' : isCont ? '[C]' : '';
-                return `${v?.kind || 'unknown'}${wrapper}`;
-            }).join(' -> ')}`);
-            console.log(`ANCHOR: ${anchorCursor ? (anchorCursor.value as any)?.kind : 'none'} at indent ${anchorIndent}`);
-        }
-
         // Process ancestors from root to leaf
         for (let i = 0; i < path.length; i++) {
             const c = path[i];
@@ -708,22 +684,21 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             if (c === anchorCursor && !c.messages.has("indentContext")) {
                 const ctx: IndentContext = [anchorIndent, 'align'];
                 c.messages.set("indentContext", ctx);
-                if (DEBUG) console.log(`SET (anchor): ${v.kind} -> [${ctx[0]}, ${ctx[1]}]`);
                 continue;
             }
 
             // Handle wrapper types (RightPadded, LeftPadded, Container)
             // These need their context set up for proper indent propagation
             // Note: RightPadded<J> intersection types have the element's kind, not J.Kind.RightPadded
             // So we detect them by checking for padding.after property
-            if (this.isRightPaddedWrapper(v)) {
+            if (isRightPadded(v)) {
                 const savedCursor = this.cursor;
                 this.cursor = c;
                 this.preVisitRightPadded(v);
                 this.cursor = savedCursor;
                 continue;
             }
-            if (this.isLeftPaddedWrapper(v)) {
+            if (isLeftPadded(v)) {
                 const savedCursor = this.cursor;
                 this.cursor = c;
                 this.preVisitLeftPadded(v);
@@ -745,11 +720,6 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             // Only set up context if not already set (e.g., by If->Block handling above)
             if (!c.messages.has("indentContext")) {
                 this.setupCursorMessagesForTree(c, v);
-                const ctx = c.messages.get("indentContext") as IndentContext;
-                if (DEBUG) console.log(`SET (computed): ${v.kind} -> [${ctx?.[0]}, ${ctx?.[1]}]`);
-            } else {
-                const ctx = c.messages.get("indentContext") as IndentContext;
-                if (DEBUG) console.log(`SKIP (already set): ${v.kind} -> [${ctx?.[0]}, ${ctx?.[1]}]`);
             }
             this.cursor = savedCursor;
 
@@ -763,7 +733,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                 if (nextCursor !== anchorCursor) {
                     const nextValue = nextCursor.value;
                     // Check if next is a statement (J node, not a wrapper type)
-                    if (this.isActualJNode(nextValue) && !this.isRightPaddedWrapper(nextValue)) {
+                    if (this.isActualJNode(nextValue) && !isRightPadded(nextValue)) {
                         // This is a Block child without explicit RightPadded wrapper in cursor chain
                         // Apply RightPadded-like context: add indent if statement has newline
                         const blockContext = c.messages.get("indentContext") as IndentContext | undefined;
@@ -776,10 +746,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                         // Create a synthetic cursor for the implied RightPadded context
                         // and set the context for the statement directly
                         nextCursor.messages.set("indentContext", [stmtIndent, 'align'] as IndentContext);
-                        if (DEBUG) console.log(`BLOCK->STMT: ${(nextValue as any).kind} hasNewline=${hasNewline} -> [${stmtIndent}, align]`);
                     }
-                } else {
-                    if (DEBUG) console.log(`BLOCK->ANCHOR: skipping (next is anchor)`);
                 }
             }
 
@@ -790,16 +757,13 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                 if (nextCursor !== anchorCursor) {
                     const nextValue = nextCursor.value;
                     // If thenPart is a Block and not wrapped in RightPadded in cursor chain
-                    if (this.isActualJNode(nextValue) && nextValue.kind === J.Kind.Block && !this.isRightPaddedWrapper(nextValue)) {
+                    if (this.isActualJNode(nextValue) && nextValue.kind === J.Kind.Block && !isRightPadded(nextValue)) {
                         const ifContext = c.messages.get("indentContext") as IndentContext | undefined;
                         const [ifIndent] = ifContext ?? [0, 'continuation'];
                         // thenPart Block doesn't have newline in prefix (it's { after condition)
                         // Keep same indent, use 'block' so children get proper indentation
                         nextCursor.messages.set("indentContext", [ifIndent, 'block'] as IndentContext);
-                        if (DEBUG) console.log(`IF->BLOCK: ifIndent=${ifIndent} -> [${ifIndent}, block]`);
                     }
-                } else {
-                    if (DEBUG) console.log(`IF->ANCHOR: skipping (next is anchor)`);
                 }
             }
         }
@@ -808,15 +772,8 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     private isActualJNode(v: any): v is J {
         return isJava(v) &&
             v.kind !== J.Kind.Container &&
-            !this.isRightPaddedWrapper(v) &&
-            !this.isLeftPaddedWrapper(v);
+            !isRightPadded(v) &&
+            !isLeftPadded(v);
     }
 
-    private isRightPaddedWrapper(v: any): v is J.RightPadded<J> {
-        return isRightPadded(v);
-    }
-
-    private isLeftPaddedWrapper(v: any): v is J.LeftPadded<J> {
-        return isLeftPadded(v);
-    }
 }

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

@@ -48,9 +48,8 @@ export class RemoveDuplicateObjectKeys extends Recipe {
                 const propertyNameToLastIndex = new Map<string, number>();
                 const propertyNames: (string | null)[] = [];
 
-                // For tree types, the padded value IS the element (intersection type)
                 for (let i = 0; i < statements.length; i++) {
-                    const stmt = statements[i] as unknown as Statement;
+                    const stmt = statements[i];
                     if (stmt.kind === JS.Kind.PropertyAssignment) {
                         const prop = stmt as unknown as JS.PropertyAssignment;
                         const propName = this.getPropertyName(prop);
@@ -76,15 +75,13 @@ export class RemoveDuplicateObjectKeys extends Recipe {
                         if (propName !== null) {
                             const lastIndex = propertyNameToLastIndex.get(propName)!;
                             if (i < lastIndex) {
-                                // For tree types, statements[i] IS the element with padding
-                                formatter.markRemoved(statements[i] as unknown as J);
+                                formatter.markRemoved(statements[i]);
                                 continue;
                             }
                         }
 
                         const stmt = statements[i];
-                        // For tree types, stmt IS the element with padding mixed in
-                        const adjustedElement = formatter.processKept(stmt as unknown as J);
+                        const adjustedElement = formatter.processKept(stmt);
                         // Merge adjusted element with padding
                         filteredStatements.push({
                             ...adjustedElement,
@@ -101,7 +98,6 @@ export class RemoveDuplicateObjectKeys extends Recipe {
             }
 
             private getPropertyName(prop: JS.PropertyAssignment): string | null {
-                // For tree types, name IS the expression with padding mixed in
                 const name = prop.name as unknown as Expression;
 
                 // Handle identifier: { foo: 1 }