24834367427

Committed 23 Apr 2026 12:09PM UTC coverage: 78.541% (+0.2%) from 78.391%

Build # 24834367427

Build Type

Pull #1893

github

Committed by

web-flow

Commit Message

Merge ab101147d into 715603479

Pull Request Pull Request #1893: Error Handling and Stringify Changes

Coverage Stats

3126 of 4197 branches covered (74.48%)

Branch coverage included in aggregate %.

801 of 975 new or added lines in 76 files covered. (82.15%)

20 existing lines in 11 files now uncovered.

7056 of 8767 relevant lines covered (80.48%)

173930.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

/src/stepper/nodes/Statement/ExpressionStatement.ts

import type { Comment, ExpressionStatement, SourceLocation } from 'estree';
import type { StepperExpression, StepperPattern } from '..';
import { convert } from '../../generator';
import { StepperBaseNode } from '../../interface';
import type { RedexInfo } from '../..';

export class StepperExpressionStatement
  extends StepperBaseNode<ExpressionStatement>
  implements ExpressionStatement
{
  constructor(
    public readonly expression: StepperExpression,
    leadingComments?: Comment[] | undefined,
    trailingComments?: Comment[] | undefined,
    loc?: SourceLocation | null | undefined,
    range?: [number, number] | undefined,
  ) {
    super('ExpressionStatement', leadingComments, trailingComments, loc, range);
  }

  static create(node: ExpressionStatement) {
    return new StepperExpressionStatement(
      convert(node.expression),
      node.leadingComments,
      node.trailingComments,
      node.loc,
      node.range,
    );
  }

  public override isContractible(redex: RedexInfo): boolean {
    return this.expression.isContractible(redex);
  }

  public override isOneStepPossible(redex: RedexInfo): boolean {
    return this.expression.isOneStepPossible(redex);
  }

  public override contract(redex: RedexInfo): StepperExpressionStatement {
    return new StepperExpressionStatement(
      this.expression.oneStep(redex),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range,
    );
  }

  contractEmpty(redex: RedexInfo) {
    // Handle cases such as 1; 2; -> 2;
    redex.preRedex = [this];
    redex.postRedex = [];
  }

  public override oneStep(redex: RedexInfo): StepperExpressionStatement {
    return new StepperExpressionStatement(
      this.expression.oneStep(redex),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range,
    );
  }

  public override substitute(
    id: StepperPattern,
    value: StepperExpression,
    redex: RedexInfo,
  ): StepperBaseNode {
    return new StepperExpressionStatement(
      this.expression.substitute(id, value, redex),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range,
    );
  }

  public override freeNames(): string[] {
    return this.expression.freeNames();
  }

  public override allNames(): string[] {
    return this.expression.allNames();
  }

  public override rename(before: string, after: string): StepperExpressionStatement {
    return new StepperExpressionStatement(
      this.expression.rename(before, after),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range,
    );
  }
}

1	import type { Comment, ExpressionStatement, SourceLocation } from 'estree';
2	import type { StepperExpression, StepperPattern } from '..';
3	import { convert } from '../../generator';
4	import { StepperBaseNode } from '../../interface';
5	import type { RedexInfo } from '../..';
6
7	export class StepperExpressionStatement
8	extends StepperBaseNode<ExpressionStatement>
9	implements ExpressionStatement
10	{
11	constructor(
12	public readonly expression: StepperExpression,	4,540✔
13	leadingComments?: Comment[] \| undefined,
14	trailingComments?: Comment[] \| undefined,
15	loc?: SourceLocation \| null \| undefined,
16	range?: [number, number] \| undefined,
17	) {
18	super('ExpressionStatement', leadingComments, trailingComments, loc, range);	4,540✔
19	}
20
21	static create(node: ExpressionStatement) {
22	return new StepperExpressionStatement(	527✔
23	convert(node.expression),
24	node.leadingComments,
25	node.trailingComments,
26	node.loc,
27	node.range,
28	);
29	}
30
31	public override isContractible(redex: RedexInfo): boolean {
32	return this.expression.isContractible(redex);	30✔
33	}
34
35	public override isOneStepPossible(redex: RedexInfo): boolean {
36	return this.expression.isOneStepPossible(redex);	5,226✔
37	}
38
39	public override contract(redex: RedexInfo): StepperExpressionStatement {
UNCOV 40	return new StepperExpressionStatement(	×
41	this.expression.oneStep(redex),
42	this.leadingComments,
43	this.trailingComments,
44	this.loc,
45	this.range,
46	);
47	}
48
49	contractEmpty(redex: RedexInfo) {
50	// Handle cases such as 1; 2; -> 2;
51	redex.preRedex = [this];	36✔
52	redex.postRedex = [];	36✔
53	}
54
55	public override oneStep(redex: RedexInfo): StepperExpressionStatement {
56	return new StepperExpressionStatement(	2,381✔
57	this.expression.oneStep(redex),
58	this.leadingComments,
59	this.trailingComments,
60	this.loc,
61	this.range,
62	);
63	}
64
65	public override substitute(
66	id: StepperPattern,
67	value: StepperExpression,
68	redex: RedexInfo,
69	): StepperBaseNode {
70	return new StepperExpressionStatement(	1,601✔
71	this.expression.substitute(id, value, redex),
72	this.leadingComments,
73	this.trailingComments,
74	this.loc,
75	this.range,
76	);
77	}
78
79	public override freeNames(): string[] {
80	return this.expression.freeNames();	53✔
81	}
82
83	public override allNames(): string[] {
84	return this.expression.allNames();	790✔
85	}
86
87	public override rename(before: string, after: string): StepperExpressionStatement {
88	return new StepperExpressionStatement(	1✔
89	this.expression.rename(before, after),
90	this.leadingComments,
91	this.trailingComments,
92	this.loc,
93	this.range,
94	);
95	}
96	}

source-academy / js-slang / 24834367427

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous