15235726114

Committed 25 May 2025 07:55AM UTC coverage: 77.048%. First build

Build # 15235726114

Build Type

Pull #1742

github

Committed by

web-flow

Commit Message

Merge d7783cf1e into 0be74e78c

Pull Request Pull Request #1742: Rewrite: Stepper

Run Details

3433 of 4826 branches covered (71.14%)

Branch coverage included in aggregate %.

1032 of 1260 new or added lines in 27 files covered. (81.9%)

10099 of 12737 relevant lines covered (79.29%)

140954.8 hits per line

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

95.0

/src/tracer/nodes/Statement/ExpressionStatement.ts

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

export class StepperExpressionStatement implements ExpressionStatement, StepperBaseNode {
  type: 'ExpressionStatement'
  expression: StepperExpression
  leadingComments?: Comment[] | undefined
  trailingComments?: Comment[] | undefined
  loc?: SourceLocation | null | undefined
  range?: [number, number] | undefined

  constructor(
    expression: StepperExpression,
    leadingComments?: Comment[] | undefined,
    trailingComments?: Comment[] | undefined,
    loc?: SourceLocation | null | undefined,
    range?: [number, number] | undefined
  ) {
    this.type = 'ExpressionStatement'
    this.expression = expression
    this.leadingComments = leadingComments
    this.trailingComments = trailingComments
    this.loc = loc
    this.range = range
  }

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

  isContractible(): boolean {
    return this.expression.isContractible()
  }
  isOneStepPossible(): boolean {
    return this.expression.isOneStepPossible()
  }
  contract(): StepperExpressionStatement {
    return new StepperExpressionStatement(
      this.expression.oneStep(),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range
    )
  }

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

  oneStep(): StepperExpressionStatement {
    return new StepperExpressionStatement(
      this.expression.oneStep(),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range
    )
  }

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

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

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

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

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

source-academy / js-slang / 15235726114

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