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

47.92

/src/tracer/nodes/Expression/ArrayExpression.ts

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

export class StepperArrayExpression implements ArrayExpression, StepperBaseNode {
  type: 'ArrayExpression'
  elements: (StepperExpression | null)[]
  leadingComments?: Comment[]
  trailingComments?: Comment[]
  loc?: SourceLocation | null
  range?: [number, number]

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

  static create(node: ArrayExpression) {
    return new StepperArrayExpression(
      node.elements.map(element => (element ? (convert(element) as StepperExpression) : null)),
      node.leadingComments,
      node.trailingComments,
      node.loc,
      node.range
    )
  }

  isContractible(): boolean {
    return false
  }

  isOneStepPossible(): boolean {
    return this.elements.some(element => element && element.isOneStepPossible())
  }

  contract(): StepperExpression {
    redex.preRedex = [this]
    throw new Error('Array expressions cannot be contracted')
  }

  oneStep(): StepperExpression {
    if (this.isContractible()) {
      return this.contract()
    }

    for (let i = 0; i < this.elements.length; i++) {
      const element = this.elements[i]
      if (element && element.isOneStepPossible()) {
        const newElements = [...this.elements]
        newElements[i] = element.oneStep()
        return new StepperArrayExpression(
          newElements,
          this.leadingComments,
          this.trailingComments,
          this.loc,
          this.range
        )
      }
    }

    throw new Error('No one step possible')
  }

  substitute(id: StepperPattern, value: StepperExpression): StepperExpression {
    return new StepperArrayExpression(
      this.elements.map(element => (element ? element.substitute(id, value) : null)),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range
    )
  }

  freeNames(): string[] {
    const names = this.elements
      .filter(element => element !== null)
      .map(element => element!.freeNames())
      .flat()
    return Array.from(new Set(names))
  }

  allNames(): string[] {
    const names = this.elements
      .filter(element => element !== null)
      .map(element => element!.allNames())
      .flat()
    return Array.from(new Set(names))
  }

  rename(before: string, after: string): StepperExpression {
    return new StepperArrayExpression(
      this.elements.map(element => (element ? element.rename(before, after) : null)),
      this.leadingComments,
      this.trailingComments,
      this.loc,
      this.range
    )
  }
}

1	import { ArrayExpression, Comment, SourceLocation } from 'estree'
2	import { StepperBaseNode } from '../../interface'
3	import { redex } from '../..'	61✔
4	import { StepperExpression, StepperPattern } from '..'
5	import { convert } from '../../generator'	61✔
6
7	export class StepperArrayExpression implements ArrayExpression, StepperBaseNode {	61✔
8	type: 'ArrayExpression'
9	elements: (StepperExpression \| null)[]
10	leadingComments?: Comment[]
11	trailingComments?: Comment[]
12	loc?: SourceLocation \| null
13	range?: [number, number]
14
15	constructor(
16	elements: (StepperExpression \| null)[],
17	leadingComments?: Comment[],
18	trailingComments?: Comment[],
19	loc?: SourceLocation \| null,
20	range?: [number, number]
21	) {
22	this.type = 'ArrayExpression'	1,281✔
23	this.elements = elements	1,281✔
24	this.leadingComments = leadingComments	1,281✔
25	this.trailingComments = trailingComments	1,281✔
26	this.loc = loc	1,281✔
27	this.range = range	1,281✔
28	}
29
30	static create(node: ArrayExpression) {
NEW 31	return new StepperArrayExpression(	×
NEW 32	node.elements.map(element => (element ? (convert(element) as StepperExpression) : null)),	×
33	node.leadingComments,
34	node.trailingComments,
35	node.loc,
36	node.range
37	)
38	}
39
40	isContractible(): boolean {
NEW 41	return false	×
42	}
43
44	isOneStepPossible(): boolean {
45	return this.elements.some(element => element && element.isOneStepPossible())	37,216✔
46	}
47
48	contract(): StepperExpression {
NEW 49	redex.preRedex = [this]	×
NEW 50	throw new Error('Array expressions cannot be contracted')	×
51	}
52
53	oneStep(): StepperExpression {
NEW 54	if (this.isContractible()) {	×
NEW 55	return this.contract()	×
56	}
57
NEW 58	for (let i = 0; i < this.elements.length; i++) {	×
NEW 59	const element = this.elements[i]	×
NEW 60	if (element && element.isOneStepPossible()) {	×
NEW 61	const newElements = [...this.elements]	×
NEW 62	newElements[i] = element.oneStep()	×
NEW 63	return new StepperArrayExpression(	×
64	newElements,
65	this.leadingComments,
66	this.trailingComments,
67	this.loc,
68	this.range
69	)
70	}
71	}
72
NEW 73	throw new Error('No one step possible')	×
74	}
75
76	substitute(id: StepperPattern, value: StepperExpression): StepperExpression {
77	return new StepperArrayExpression(	1,210✔
78	this.elements.map(element => (element ? element.substitute(id, value) : null)),	2,420!
79	this.leadingComments,
80	this.trailingComments,
81	this.loc,
82	this.range
83	)
84	}
85
86	freeNames(): string[] {
87	const names = this.elements	403✔
88	.filter(element => element !== null)	806✔
89	.map(element => element!.freeNames())	806✔
90	.flat()
91	return Array.from(new Set(names))	403✔
92	}
93
94	allNames(): string[] {
95	const names = this.elements	104✔
96	.filter(element => element !== null)	208✔
97	.map(element => element!.allNames())	208✔
98	.flat()
99	return Array.from(new Set(names))	104✔
100	}
101
102	rename(before: string, after: string): StepperExpression {
NEW 103	return new StepperArrayExpression(	×
NEW 104	this.elements.map(element => (element ? element.rename(before, after) : null)),	×
105	this.leadingComments,
106	this.trailingComments,
107	this.loc,
108	this.range
109	)
110	}
111	}

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