Dead Code

in reviewThis lesson is complete and being validated before release - details may still change.

Dead code

Loading interactive demo…

A small fixture program drawn as boxes of members, and a reachability search walking it: the entry points are alive by definition, every live call from an alive method makes its callee alive, and whatever is left over is dead. Fowler lists Dead Code among the smells; a compiler runs the same search as dead-code elimination. Four kinds are listed: methods nothing reaches, fields nothing reads, statements after a block has returned, and stores into fields no one reads back. The remove knob applies Remove Dead Code one item at a time, in the order the library allows, and the search runs again. The refactorings are the library's own toy forms: one item goes per step, and a block the deletion empties goes with it.Take the tour, or press and explore. Legend:

The panel beside the stage is the real DeadCode class from the published library executing in your browser, with the current line highlighted.

An entry point, from the moment it is announced until the walk has worked from it; also the member and edge in progress.
A method the search reached: an entry, or the target of a live call.
A call that reached its target for the first time.
A dead method or field, and the never-followed call a dead statement holds.
A live method holding a dead statement: a call after its return, or a store nothing reads.
A method not yet visited, a call not yet followed, or a call to a method already reached.

reached counts the methods alive so far, dead the items listed and what the original had, lines the printed length of the program and what the original printed, verdict whether anything is left over, member what the tapped member is: an entry point, reached and through which call, or dead and why. Tap a member to pick it.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

What the search counts. A program names the methods the outside world calls, its entry points, and those are alive by definition. Everything else is alive only if an alive method calls it: the search queues the entries, takes one method at a time, follows every call in it that lands on a method of the program, and queues what is new. It is the breadth-first walk of the graph traversal lesson, and the mark phase of a garbage collector, run over code instead of objects. Along the way it notes every field a live statement reads. What is left over is dead, in four kinds: methods never reached, fields never read, statements after a block has returned, and stores into fields nobody reads back.

A mention is not a call. Shop.sell names Inventory.add in its restock line, but that line sits after the sale's return, so control never gets there. The search reads a block only up to its first exit, hands the rest to the dead list, and follows nothing from it. That is why add counts as unreached although the text mentions it, and why deleting the stranded line does not change what is alive.

Why the cure cascades. Remove Dead Code deletes one item per step, and each deletion exposes the next: the stranded restock goes first, which leaves add with no caller at all; add goes, and with audit gone after it, log has no writer left; then log goes. The library refuses the other order: a method something still calls, or a field something still touches, stays. So the slider only walks forward along the plan, and the dead count falls by exactly one per step.

There is no threshold. Other smells have a limit to argue about; here one leftover is enough. The verdict reads dead code whenever the list is not empty, and all live when every method is reached and every field read.

The control. The app service reaches everything: handle calls load on a UserStore, the search climbs to Store where it is declared, and load's return sits inside its loop, so it exits only the loop and the throw after it stays live. Nothing to remove, and the plan is empty.

What the stage does not show. The refactoring here is the library's toy form: one item per step, in the plan's order, with a block the deletion empties going along. The search follows declared types only: no reflection, no dynamic dispatch beyond the extends chain, no data-flow through locals. Real tools and bundlers do the same walk with more ways for a call to land.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

partition is the control-flow rule in one place. It walks a block up to and including its first return or throw, recurses into the blocks live statements open, and hands the statements after the exit to onDead without looking into them; a call there revives nothing, so the count stays monotone as items are removed.
A write is told from a read by position. scan reports an assignment's own target as the one written access; every other field expression is a read, so this.cache = text is a store and this.hits + 1 a read of hits.
A call lands on the class that declares the method. callee types the call's target through the program query and climbs the extends chain, so users.load on a UserStore reaches Store.load and the report names it that way.
One emit site for four kinds. The items are listed in deletion order, unreached methods, unread fields, after-exit statements, dead stores, through a single dead emit whose payload carries the kind and the reason, so the stage can tone a statement's holder apart.
users is the refactoring's guard. RemoveDead asks it who still calls a method or touches a field, live or not, and refuses with the first name; the program is spread rather than rebuilt, so the entry points ride along through every step.

Code that can never run costs reading time, build time, and the occasional disaster when someone switches it back on. Compilers hunted it first: in the early seventies Allen and Cocke catalogued the optimizer's transformations, dead code elimination among them, while Knuth measured real FORTRAN programs and found the running time in a few lines. The 1999 smells catalogue, written with Kent Beck, warned of speculative generality; the second edition names Dead Code outright. This lesson runs the compiler's search over a small program and deletes what it finds, one item at a time.

1971Frances Allen and John Cocke - 'A Catalogue of Optimizing Transformations' lists the rewrites an optimizing compiler can apply to a program, among them the elimination of code whose result is never used or that control can never reach.source
1971Donald Knuth - 'An Empirical Study of FORTRAN Programs' profiles real programs and finds that a small fraction of the code accounts for most of the running time, the case for measuring where a program actually goes before working on it.source
2015Rich Harris - The Rollup bundler popularises tree shaking: with ES modules declaring their imports and exports statically, a bundler keeps only the code reachable from the entry point and drops the rest.source
2018Martin Fowler - The second edition of Refactoring lists Dead Code among the smells and Remove Dead Code among the refactorings: when code is no longer used, delete it, and trust version control to bring it back if it is ever needed.source

Used today

Tree shaking - Bundlers walk the import graph from the entry point and leave unreachable exports out of the shipped file.
Compiler passes - Dead-code elimination removes unreachable blocks and stores whose values are never read, and makes other optimizations cheaper.
Coverage-guided cleanup - Code that no test and no production trace ever reaches is the first candidate for deletion in a large codebase.

program

removeoriginal

reached: 2 of 4 methods
dead: 4
lines: 46
verdict: dead code
member: inventory: read, touched by sell

dead-code.ts

import type { ClassDecl, Expr, MemberRef, Program, Stmt } from "./program";import { ProgramQuery } from "./program-query";import type { Tracer } from "../trace";import type { SmellDetector } from "./detector";export type DeadKind = "method" | "field" | "statement";export type DeadReason = "unreached" | "unread" | "after-exit" | "dead-store";export interface DeadItem {  readonly kind: DeadKind;  readonly className: string;  /** The method or field for a member item; the method holding the statement for a statement item. */  readonly member: string;  /** The statement's id for a statement item; null for a member. */  readonly nodeId: string | null;  readonly reason: DeadReason;}export interface DeadCodeReport {  readonly entries: readonly MemberRef[];  /** Every method control can reach, as "Class.method", entries first and then in the order the search found them. */  readonly reachable: readonly string[];  /** Unreached methods, then unread fields, then after-exit statements, then dead stores; declaration order within each. */  readonly items: readonly DeadItem[];  readonly smelly: boolean;}type CallExpr = Extract<Expr, { kind: "call" }>;type FieldExpr = Extract<Expr, { kind: "field" }>;/** A live assignment to a field, kept until the search knows whether the field is ever read. */interface Store {  readonly className: string;  readonly member: string;  readonly nodeId: string;  readonly field: string;}/** * Dead code, found by reachability analysis: the first half of the * dead-code elimination a compiler runs, applied to a whole program * from the methods the outside world calls. The search is a breadth- * first walk over the call graph from `program.entryPoints`: dequeue a * method, follow every call in it that resolves to a program method * (`this.m()` on the class or an ancestor, `x.m()` on the declared type * of `x`), enqueue what is new. Only live statements are walked: once a * block has returned or thrown, the statements after that point never * run, so a call there revives nothing and the count stays monotone as * the student removes items. Along the way the walk notes every field * a live statement reads, which is every `field` expression that is * not the target of an assignment. * * What is left over is dead, in four kinds and in the order a reader * should delete them: methods the search never reached, fields nothing * reads, statements after a block's exit, and stores into those unread * fields. Removing a caller may strand its callees and removing a store * may free its field, so the list cascades: each removal is one step, * and the next report shows what it exposed. * * Time: O(n) over n statements and expression nodes, each method walked * once. Space: O(methods + fields). */export class DeadCode implements SmellDetector<Program, DeadCodeReport> {  constructor(private readonly tracer?: Tracer) {}  analyze(program: Program): DeadCodeReport {    const query = new ProgramQuery(program);    const entries = program.entryPoints ?? [];    // ▸ an entry point: alive because the outside calls it    entries.forEach((entry, index) => this.tracer?.emit("entry", { className: entry.className, member: entry.member, index, count: entries.length }));    const reachable: string[] = [];    const queue: MemberRef[] = [];    for (const entry of entries) {      if (reachable.includes(DeadCode.key(entry))) continue;      reachable.push(DeadCode.key(entry));      queue.push(entry);    }    const read = new Set<string>();    const afterExit = new Map<string, DeadItem[]>();    const stores = new Map<string, Store[]>();    while (queue.length > 0) {      const ref = queue.shift()!;      const cls = query.class(ref.className);      const method = query.method(ref);      const locals = ProgramQuery.locals(method);      const from = DeadCode.key(ref);      const dead: DeadItem[] = [];      const stored: Store[] = [];      DeadCode.partition(        method.body,        (stmt) => {          DeadCode.scan(stmt, (call) => {            const callee = DeadCode.callee(query, cls, locals, call);            if (!callee) return;            const to = DeadCode.key(callee);            const reached = reachable.includes(to);            // ▸ a live call, and the program method it lands on            this.tracer?.emit("call", { from, to, nodeId: stmt.id, reached });            if (reached) return;            reachable.push(to);            queue.push(callee);            // ▸ a method reached for the first time: alive, and queued            this.tracer?.emit("reach", { className: callee.className, member: callee.member, via: from, count: reachable.length });          }, (field, written) => {            const target = DeadCode.fieldRef(query, cls, locals, field);            if (!target) return;            if (written) stored.push({ className: ref.className, member: ref.member, nodeId: stmt.id, field: DeadCode.key(target) });            else read.add(DeadCode.key(target));          });        },        (stmt) => dead.push({ kind: "statement", className: ref.className, member: ref.member, nodeId: stmt.id, reason: "after-exit" }),      );      afterExit.set(from, dead);      stores.set(from, stored);    }    const items: DeadItem[] = [];    const classes = query.classes();    let methods = 0;    for (const cls of classes) {      for (const method of cls.methods) {        methods++;        if (reachable.includes(`${cls.name}.${method.name}`)) continue;        // ▸ a method no live call ever landed on        this.tracer?.emit("unreachable", { className: cls.name, member: method.name });        items.push({ kind: "method", className: cls.name, member: method.name, nodeId: null, reason: "unreached" });      }    }    for (const cls of classes) {      for (const field of cls.fields) {        if (!read.has(`${cls.name}.${field.name}`)) items.push({ kind: "field", className: cls.name, member: field.name, nodeId: null, reason: "unread" });      }    }    for (const cls of classes) for (const method of cls.methods) items.push(...(afterExit.get(`${cls.name}.${method.name}`) ?? []));    for (const cls of classes) {      for (const method of cls.methods) {        for (const store of stores.get(`${cls.name}.${method.name}`) ?? []) {          if (!read.has(store.field)) items.push({ kind: "statement", className: store.className, member: store.member, nodeId: store.nodeId, reason: "dead-store" });        }      }    }    // ▸ one dead item, with the reason it is dead    items.forEach((item, index) => this.tracer?.emit("dead", { kind: item.kind, className: item.className, member: item.member, nodeId: item.nodeId ?? "", reason: item.reason, count: index + 1 }));    const smelly = items.length > 0;    // ▸ what was reached, what is dead, and the verdict    this.tracer?.emit("verdict", { entries: entries.length, methods, reached: reachable.length, dead: items.length, smelly });    return { entries, reachable, items, smelly };  }  /** "Class.member": how the report names a reached method and the search keys a field. */  static key(ref: MemberRef): string {    return `${ref.className}.${ref.member}`;  }  /**   * Walks a body the way control flow does: each block's statements up   * to and including its first return or throw are live and their own   * blocks are walked in turn; the statements after that point are   * handed to `onDead` and never looked into.   */  static partition(body: readonly Stmt[], onLive: (stmt: Stmt) => void, onDead: (stmt: Stmt) => void): void {    let exited = false;    for (const stmt of body) {      if (exited) {        onDead(stmt);        continue;      }      onLive(stmt);      for (const block of ProgramQuery.children(stmt)) DeadCode.partition(block, onLive, onDead);      if (stmt.kind === "return" || stmt.kind === "throw") exited = true;    }  }  /** Every call and every field access in the expressions a statement evaluates itself; an assignment's own target is the one access reported as written. */  static scan(stmt: Stmt, onCall: (call: CallExpr) => void, onField: (field: FieldExpr, written: boolean) => void): void {    ProgramQuery.exprs(stmt).forEach((expr, index) => {      const target = stmt.kind === "assign" && index === 0 ? expr : null;      ProgramQuery.visitExpr(expr, (e) => {        if (e.kind === "call") onCall(e);        if (e.kind === "field") onField(e, e === target);      });    });  }  /** The program method a call lands on, named by the class that declares it; null for a call the model cannot follow. */  static callee(query: ProgramQuery, cls: ClassDecl, locals: ReadonlyMap<string, string>, call: CallExpr): MemberRef | null {    const owner = query.typeOf(call.target, cls, locals);    return owner === null ? null : DeadCode.declaring(query, ProgramQuery.baseType(owner), (c) => c.methods.some((m) => m.name === call.method), call.method);  }  /** The program field an access names, by its declaring class; null when the target's type is outside the program. */  static fieldRef(query: ProgramQuery, cls: ClassDecl, locals: ReadonlyMap<string, string>, field: FieldExpr): MemberRef | null {    const owner = query.typeOf(field.target, cls, locals);    return owner === null ? null : DeadCode.declaring(query, ProgramQuery.baseType(owner), (c) => c.fields.some((f) => f.name === field.name), field.name);  }  /** Every method of the program that calls the member or touches the field, as "Class.method", in declaration order; live or not. */  static users(program: Program, target: MemberRef, kind: "method" | "field"): readonly string[] {    const query = new ProgramQuery(program);    const out: string[] = [];    for (const cls of query.classes()) {      for (const method of cls.methods) {        if (cls.name === target.className && method.name === target.member) continue;        const locals = ProgramQuery.locals(method);        let hit = false;        ProgramQuery.walk(method.body, (stmt) =>          DeadCode.scan(            stmt,            (call) => {              if (kind === "method" && DeadCode.same(DeadCode.callee(query, cls, locals, call), target)) hit = true;            },            (field) => {              if (kind === "field" && DeadCode.same(DeadCode.fieldRef(query, cls, locals, field), target)) hit = true;            },          ),        );        if (hit) out.push(`${cls.name}.${method.name}`);      }    }    return out;  }  private static same(a: MemberRef | null, b: MemberRef): boolean {    return a !== null && a.className === b.className && a.member === b.member;  }  private static declaring(query: ProgramQuery, className: string, has: (cls: ClassDecl) => boolean, member: string): MemberRef | null {    for (let cls = query.classOrNull(className); cls; cls = cls.extends ? query.classOrNull(cls.extends) : null) {      if (has(cls)) return { className: cls.name, member };    }    return null;  }}

dead =: 4

4 dead items; 46 printed lines. Still something to remove.

import type { ClassDecl, Expr, MemberRef, Program, Stmt } from "./program";import { ProgramQuery } from "./program-query";import type { Tracer } from "../trace";import type { SmellDetector } from "./detector";export type DeadKind = "method" | "field" | "statement";export type DeadReason = "unreached" | "unread" | "after-exit" | "dead-store";export interface DeadItem { readonly kind: DeadKind; readonly className: string; /** The method or field for a member item; the method holding the statement for a statement item. */ readonly member: string; /** The statement's id for a statement item; null for a member. */ readonly nodeId: string | null; readonly reason: DeadReason;}export interface DeadCodeReport { readonly entries: readonly MemberRef[]; /** Every method control can reach, as "Class.method", entries first and then in the order the search found them. */ readonly reachable: readonly string[]; /** Unreached methods, then unread fields, then after-exit statements, then dead stores; declaration order within each. */ readonly items: readonly DeadItem[]; readonly smelly: boolean;}type CallExpr = Extract<Expr, { kind: "call" }>;type FieldExpr = Extract<Expr, { kind: "field" }>;/** A live assignment to a field, kept until the search knows whether the field is ever read. */interface Store { readonly className: string; readonly member: string; readonly nodeId: string; readonly field: string;}/** * Dead code, found by reachability analysis: the first half of the * dead-code elimination a compiler runs, applied to a whole program * from the methods the outside world calls. The search is a breadth- * first walk over the call graph from `program.entryPoints`: dequeue a * method, follow every call in it that resolves to a program method * (`this.m()` on the class or an ancestor, `x.m()` on the declared type * of `x`), enqueue what is new. Only live statements are walked: once a * block has returned or thrown, the statements after that point never * run, so a call there revives nothing and the count stays monotone as * the student removes items. Along the way the walk notes every field * a live statement reads, which is every `field` expression that is * not the target of an assignment. * * What is left over is dead, in four kinds and in the order a reader * should delete them: methods the search never reached, fields nothing * reads, statements after a block's exit, and stores into those unread * fields. Removing a caller may strand its callees and removing a store * may free its field, so the list cascades: each removal is one step, * and the next report shows what it exposed. * * Time: O(n) over n statements and expression nodes, each method walked * once. Space: O(methods + fields). */export class DeadCode implements SmellDetector<Program, DeadCodeReport> { constructor(private readonly tracer?: Tracer) {} analyze(program: Program): DeadCodeReport { const query = new ProgramQuery(program); const entries = program.entryPoints ?? []; // ▸ an entry point: alive because the outside calls it entries.forEach((entry, index) => this.tracer?.emit("entry", { className: entry.className, member: entry.member, index, count: entries.length })); const reachable: string[] = []; const queue: MemberRef[] = []; for (const entry of entries) { if (reachable.includes(DeadCode.key(entry))) continue; reachable.push(DeadCode.key(entry)); queue.push(entry); } const read = new Set<string>(); const afterExit = new Map<string, DeadItem[]>(); const stores = new Map<string, Store[]>(); while (queue.length > 0) { const ref = queue.shift()!; const cls = query.class(ref.className); const method = query.method(ref); const locals = ProgramQuery.locals(method); const from = DeadCode.key(ref); const dead: DeadItem[] = []; const stored: Store[] = []; DeadCode.partition( method.body, (stmt) => { DeadCode.scan(stmt, (call) => { const callee = DeadCode.callee(query, cls, locals, call); if (!callee) return; const to = DeadCode.key(callee); const reached = reachable.includes(to); // ▸ a live call, and the program method it lands on this.tracer?.emit("call", { from, to, nodeId: stmt.id, reached }); if (reached) return; reachable.push(to); queue.push(callee); // ▸ a method reached for the first time: alive, and queued this.tracer?.emit("reach", { className: callee.className, member: callee.member, via: from, count: reachable.length }); }, (field, written) => { const target = DeadCode.fieldRef(query, cls, locals, field); if (!target) return; if (written) stored.push({ className: ref.className, member: ref.member, nodeId: stmt.id, field: DeadCode.key(target) }); else read.add(DeadCode.key(target)); }); }, (stmt) => dead.push({ kind: "statement", className: ref.className, member: ref.member, nodeId: stmt.id, reason: "after-exit" }), ); afterExit.set(from, dead); stores.set(from, stored); } const items: DeadItem[] = []; const classes = query.classes(); let methods = 0; for (const cls of classes) { for (const method of cls.methods) { methods++; if (reachable.includes(`${cls.name}.${method.name}`)) continue; // ▸ a method no live call ever landed on this.tracer?.emit("unreachable", { className: cls.name, member: method.name }); items.push({ kind: "method", className: cls.name, member: method.name, nodeId: null, reason: "unreached" }); } } for (const cls of classes) { for (const field of cls.fields) { if (!read.has(`${cls.name}.${field.name}`)) items.push({ kind: "field", className: cls.name, member: field.name, nodeId: null, reason: "unread" }); } } for (const cls of classes) for (const method of cls.methods) items.push(...(afterExit.get(`${cls.name}.${method.name}`) ?? [])); for (const cls of classes) { for (const method of cls.methods) { for (const store of stores.get(`${cls.name}.${method.name}`) ?? []) { if (!read.has(store.field)) items.push({ kind: "statement", className: store.className, member: store.member, nodeId: store.nodeId, reason: "dead-store" }); } } } // ▸ one dead item, with the reason it is dead items.forEach((item, index) => this.tracer?.emit("dead", { kind: item.kind, className: item.className, member: item.member, nodeId: item.nodeId ?? "", reason: item.reason, count: index + 1 })); const smelly = items.length > 0; // ▸ what was reached, what is dead, and the verdict this.tracer?.emit("verdict", { entries: entries.length, methods, reached: reachable.length, dead: items.length, smelly }); return { entries, reachable, items, smelly }; } /** "Class.member": how the report names a reached method and the search keys a field. */ static key(ref: MemberRef): string { return `${ref.className}.${ref.member}`; } /** * Walks a body the way control flow does: each block's statements up * to and including its first return or throw are live and their own * blocks are walked in turn; the statements after that point are * handed to `onDead` and never looked into. */ static partition(body: readonly Stmt[], onLive: (stmt: Stmt) => void, onDead: (stmt: Stmt) => void): void { let exited = false; for (const stmt of body) { if (exited) { onDead(stmt); continue; } onLive(stmt); for (const block of ProgramQuery.children(stmt)) DeadCode.partition(block, onLive, onDead); if (stmt.kind === "return" || stmt.kind === "throw") exited = true; } } /** Every call and every field access in the expressions a statement evaluates itself; an assignment's own target is the one access reported as written. */ static scan(stmt: Stmt, onCall: (call: CallExpr) => void, onField: (field: FieldExpr, written: boolean) => void): void { ProgramQuery.exprs(stmt).forEach((expr, index) => { const target = stmt.kind === "assign" && index === 0 ? expr : null; ProgramQuery.visitExpr(expr, (e) => { if (e.kind === "call") onCall(e); if (e.kind === "field") onField(e, e === target); }); }); } /** The program method a call lands on, named by the class that declares it; null for a call the model cannot follow. */ static callee(query: ProgramQuery, cls: ClassDecl, locals: ReadonlyMap<string, string>, call: CallExpr): MemberRef | null { const owner = query.typeOf(call.target, cls, locals); return owner === null ? null : DeadCode.declaring(query, ProgramQuery.baseType(owner), (c) => c.methods.some((m) => m.name === call.method), call.method); } /** The program field an access names, by its declaring class; null when the target's type is outside the program. */ static fieldRef(query: ProgramQuery, cls: ClassDecl, locals: ReadonlyMap<string, string>, field: FieldExpr): MemberRef | null { const owner = query.typeOf(field.target, cls, locals); return owner === null ? null : DeadCode.declaring(query, ProgramQuery.baseType(owner), (c) => c.fields.some((f) => f.name === field.name), field.name); } /** Every method of the program that calls the member or touches the field, as "Class.method", in declaration order; live or not. */ static users(program: Program, target: MemberRef, kind: "method" | "field"): readonly string[] { const query = new ProgramQuery(program); const out: string[] = []; for (const cls of query.classes()) { for (const method of cls.methods) { if (cls.name === target.className && method.name === target.member) continue; const locals = ProgramQuery.locals(method); let hit = false; ProgramQuery.walk(method.body, (stmt) => DeadCode.scan( stmt, (call) => { if (kind === "method" && DeadCode.same(DeadCode.callee(query, cls, locals, call), target)) hit = true; }, (field) => { if (kind === "field" && DeadCode.same(DeadCode.fieldRef(query, cls, locals, field), target)) hit = true; }, ), ); if (hit) out.push(`${cls.name}.${method.name}`); } } return out; } private static same(a: MemberRef | null, b: MemberRef): boolean { return a !== null && a.className === b.className && a.member === b.member; } private static declaring(query: ProgramQuery, className: string, has: (cls: ClassDecl) => boolean, member: string): MemberRef | null { for (let cls = query.classOrNull(className); cls; cls = cls.extends ? query.classOrNull(cls.extends) : null) { if (has(cls)) return { className: cls.name, member }; } return null; }}