8506821052

Committed 01 Apr 2024 10:13AM UTC coverage: 81.465% (+0.01%) from 81.451%

Build # 8506821052

Build Type

Pull #1628

github

Committed by

web-flow

Commit Message

Merge c3d5dacc2 into 8486835ec

Pull Request Pull Request #1628: 1622 stepper does not evaluate arguments when it should

Run Details

3231 of 4354 branches covered (74.21%)

Branch coverage included in aggregate %.

16 of 16 new or added lines in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

10636 of 12668 relevant lines covered (83.96%)

134472.93 hits per line

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

66.67

/src/errors/errors.ts

/* tslint:disable: max-classes-per-file */
/* tslint:disable:max-line-length */
import { baseGenerator, generate } from 'astring'
import * as es from 'estree'

import { UNKNOWN_LOCATION } from '../constants'
import { ErrorSeverity, ErrorType, Node, SourceError, Value } from '../types'
import { stringify } from '../utils/stringify'
import { RuntimeSourceError } from './runtimeSourceError'

//Wrap build-in function error in SourceError
export class BuiltInFunctionError extends RuntimeSourceError {
  constructor(node: Node, private explanation: String) {
    super(node)
    this.explanation = explanation
  }

  public explain() {
    return `${this.explanation}`
  }

  public elaborate() {
    return this.explain()
  }
}

export class InterruptedError extends RuntimeSourceError {
  constructor(node: Node) {
    super(node)
  }

  public explain() {
    return 'Execution aborted by user.'
  }

  public elaborate() {
    return 'TODO'
  }
}

export class ExceptionError implements SourceError {
  public type = ErrorType.RUNTIME
  public severity = ErrorSeverity.ERROR
  public location: es.SourceLocation

  constructor(public error: Error, location?: es.SourceLocation | null) {
    this.location = location ?? UNKNOWN_LOCATION
  }

  public explain() {
    return this.error.toString()
  }

  public elaborate() {
    return 'TODO'
  }
}

export class MaximumStackLimitExceeded extends RuntimeSourceError {
  public static MAX_CALLS_TO_SHOW = 3

  private customGenerator = {
    ...baseGenerator,
    CallExpression(node: any, state: any) {
      state.write(generate(node.callee))
      state.write('(')
      const argsRepr = node.arguments.map((arg: any) => stringify(arg.value))
      state.write(argsRepr.join(', '))
      state.write(')')
    }
  }

  constructor(node: Node, private calls: es.CallExpression[]) {
    super(node)
  }

  public explain() {
    const repr = (call: es.CallExpression) => generate(call, { generator: this.customGenerator })
    return (
      'Maximum call stack size exceeded\n  ' + this.calls.map(call => repr(call) + '..').join('  ')
    )
  }

  public elaborate() {
    return 'TODO'
  }
}

export class CallingNonFunctionValue extends RuntimeSourceError {
  constructor(private callee: Value, private node: Node) {
    super(node)
  }

  public explain() {
    return `Calling non-function value ${stringify(this.callee)}.`
  }

  public elaborate() {
    const calleeVal = this.callee
    const calleeStr = stringify(calleeVal)
    let argStr = ''

    const callArgs = (this.node as es.CallExpression).arguments

    argStr = callArgs.map(generate).join(', ')

    const elabStr = `Because ${calleeStr} is not a function, you cannot run ${calleeStr}(${argStr}).`
    const multStr = `If you were planning to perform multiplication by ${calleeStr}, you need to use the * operator.`

    if (Number.isFinite(calleeVal)) {
      return `${elabStr} ${multStr}`
    } else {
      return elabStr
    }
  }
}

export class UndefinedVariable extends RuntimeSourceError {
  constructor(public name: string, node: Node) {
    super(node)
  }

  public explain() {
    return `Name ${this.name} not declared.`
  }

  public elaborate() {
    return `Before you can read the value of ${this.name}, you need to declare it as a variable or a constant. You can do this using the let or const keywords.`
  }
}

export class UnassignedVariable extends RuntimeSourceError {
  constructor(public name: string, node: Node) {
    super(node)
  }

  public explain() {
    return `Name ${this.name} declared later in current scope but not yet assigned`
  }

  public elaborate() {
    return `If you're trying to access the value of ${this.name} from an outer scope, please rename the inner ${this.name}. An easy way to avoid this issue in future would be to avoid declaring any variables or constants with the name ${this.name} in the same scope.`
  }
}

export class InvalidNumberOfArguments extends RuntimeSourceError {
  private calleeStr: string

  constructor(
    node: Node,
    private expected: number,
    private got: number,
    private hasVarArgs = false
  ) {
    super(node)
    this.calleeStr = generate((node as es.CallExpression).callee)
  }

  public explain() {
    return `Expected ${this.expected} ${this.hasVarArgs ? 'or more ' : ''}arguments, but got ${
      this.got
    }.`
  }

  public elaborate() {
    const calleeStr = this.calleeStr
    const pluralS = this.expected === 1 ? '' : 's'

    return `Try calling function ${calleeStr} again, but with ${this.expected} argument${pluralS} instead. Remember that arguments are separated by a ',' (comma).`
  }
}

export class VariableRedeclaration extends RuntimeSourceError {
  constructor(private node: Node, private name: string, private writable?: boolean) {
    super(node)
  }

  public explain() {
    return `Redeclaring name ${this.name}.`
  }

  public elaborate() {
    if (this.writable === true) {
      const elabStr = `Since ${this.name} has already been declared, you can assign a value to it without re-declaring.`

      let initStr = ''

      if (this.node.type === 'FunctionDeclaration') {
        initStr =
          '(' + (this.node as es.FunctionDeclaration).params.map(generate).join(',') + ') => {...'
      } else if (this.node.type === 'VariableDeclaration') {
        initStr = generate((this.node as es.VariableDeclaration).declarations[0].init)
      }

      return `${elabStr} As such, you can just do\n\n\t${this.name} = ${initStr};\n`
    } else if (this.writable === false) {
      return `You will need to declare another variable, as ${this.name} is read-only.`
    } else {
      return ''
    }
  }
}

export class ConstAssignment extends RuntimeSourceError {
  constructor(node: Node, private name: string) {
    super(node)
  }

  public explain() {
    return `Cannot assign new value to constant ${this.name}.`
  }

  public elaborate() {
    return `As ${this.name} was declared as a constant, its value cannot be changed. You will have to declare a new variable.`
  }
}

export class GetPropertyError extends RuntimeSourceError {
  constructor(node: Node, private obj: Value, private prop: string) {
    super(node)
  }

  public explain() {
    return `Cannot read property ${this.prop} of ${stringify(this.obj)}.`
  }

  public elaborate() {
    return 'TODO'
  }
}

export class GetInheritedPropertyError extends RuntimeSourceError {
  public type = ErrorType.RUNTIME
  public severity = ErrorSeverity.ERROR
  public location: es.SourceLocation

  constructor(node: Node, private obj: Value, private prop: string) {
    super(node)
    this.location = node.loc ?? UNKNOWN_LOCATION
  }

  public explain() {
    return `Cannot read inherited property ${this.prop} of ${stringify(this.obj)}.`
  }

  public elaborate() {
    return 'TODO'
  }
}

export class SetPropertyError extends RuntimeSourceError {
  constructor(node: Node, private obj: Value, private prop: string) {
    super(node)
  }

  public explain() {
    return `Cannot assign property ${this.prop} of ${stringify(this.obj)}.`
  }

  public elaborate() {
    return 'TODO'
  }
}

1	/* tslint:disable: max-classes-per-file */
2	/* tslint:disable:max-line-length */
3	import { baseGenerator, generate } from 'astring'	70✔
4	import * as es from 'estree'
5
6	import { UNKNOWN_LOCATION } from '../constants'	70✔
7	import { ErrorSeverity, ErrorType, Node, SourceError, Value } from '../types'	70✔
8	import { stringify } from '../utils/stringify'	70✔
9	import { RuntimeSourceError } from './runtimeSourceError'	70✔
10
11	//Wrap build-in function error in SourceError
12	export class BuiltInFunctionError extends RuntimeSourceError {	70✔
UNCOV 13	constructor(node: Node, private explanation: String) {	×
UNCOV 14	super(node)	×
UNCOV 15	this.explanation = explanation	×
16	}
17
18	public explain() {
UNCOV 19	return `${this.explanation}`	×
20	}
21
22	public elaborate() {
23	return this.explain()	×
24	}
25	}
26
27	export class InterruptedError extends RuntimeSourceError {	70✔
28	constructor(node: Node) {
29	super(node)	×
30	}
31
32	public explain() {
33	return 'Execution aborted by user.'	×
34	}
35
36	public elaborate() {
37	return 'TODO'	×
38	}
39	}
40
41	export class ExceptionError implements SourceError {	70✔
42	public type = ErrorType.RUNTIME	111✔
43	public severity = ErrorSeverity.ERROR	111✔
44	public location: es.SourceLocation
45
46	constructor(public error: Error, location?: es.SourceLocation \| null) {	111✔
47	this.location = location ?? UNKNOWN_LOCATION	111!
48	}
49
50	public explain() {
51	return this.error.toString()	129✔
52	}
53
54	public elaborate() {
55	return 'TODO'	×
56	}
57	}
58
59	export class MaximumStackLimitExceeded extends RuntimeSourceError {	70✔
60	public static MAX_CALLS_TO_SHOW = 3	70✔
61
62	private customGenerator = {	15✔
63	...baseGenerator,
64	CallExpression(node: any, state: any) {
65	state.write(generate(node.callee))	45✔
66	state.write('(')	45✔
67	const argsRepr = node.arguments.map((arg: any) => stringify(arg.value))	51✔
68	state.write(argsRepr.join(', '))	45✔
69	state.write(')')	45✔
70	}
71	}
72
73	constructor(node: Node, private calls: es.CallExpression[]) {	15✔
74	super(node)	15✔
75	}
76
77	public explain() {
78	const repr = (call: es.CallExpression) => generate(call, { generator: this.customGenerator })	45✔
79	return (	15✔
80	'Maximum call stack size exceeded\n ' + this.calls.map(call => repr(call) + '..').join(' ')	45✔
81	)
82	}
83
84	public elaborate() {
85	return 'TODO'	×
86	}
87	}
88
89	export class CallingNonFunctionValue extends RuntimeSourceError {	70✔
90	constructor(private callee: Value, private node: Node) {	56✔
91	super(node)	56✔
92	}
93
94	public explain() {
95	return `Calling non-function value ${stringify(this.callee)}.`	56✔
96	}
97
98	public elaborate() {
99	const calleeVal = this.callee	19✔
100	const calleeStr = stringify(calleeVal)	19✔
101	let argStr = ''	19✔
102
103	const callArgs = (this.node as es.CallExpression).arguments	19✔
104
105	argStr = callArgs.map(generate).join(', ')	19✔
106
107	const elabStr = `Because ${calleeStr} is not a function, you cannot run ${calleeStr}(${argStr}).`	19✔
108	const multStr = `If you were planning to perform multiplication by ${calleeStr}, you need to use the * operator.`	19✔
109
110	if (Number.isFinite(calleeVal)) {	19✔
111	return `${elabStr} ${multStr}`	3✔
112	} else {
113	return elabStr	16✔
114	}
115	}
116	}
117
118	export class UndefinedVariable extends RuntimeSourceError {	70✔
119	constructor(public name: string, node: Node) {	259✔
120	super(node)	259✔
121	}
122
123	public explain() {
124	return `Name ${this.name} not declared.`	29✔
125	}
126
127	public elaborate() {
128	return `Before you can read the value of ${this.name}, you need to declare it as a variable or a constant. You can do this using the let or const keywords.`	3✔
129	}
130	}
131
132	export class UnassignedVariable extends RuntimeSourceError {	70✔
133	constructor(public name: string, node: Node) {	15✔
134	super(node)	15✔
135	}
136
137	public explain() {
138	return `Name ${this.name} declared later in current scope but not yet assigned`	15✔
139	}
140
141	public elaborate() {
142	return `If you're trying to access the value of ${this.name} from an outer scope, please rename the inner ${this.name}. An easy way to avoid this issue in future would be to avoid declaring any variables or constants with the name ${this.name} in the same scope.`	1✔
143	}
144	}
145
146	export class InvalidNumberOfArguments extends RuntimeSourceError {	70✔
147	private calleeStr: string
148
149	constructor(
150	node: Node,
151	private expected: number,	60✔
152	private got: number,	60✔
153	private hasVarArgs = false	60✔
154	) {
155	super(node)	60✔
156	this.calleeStr = generate((node as es.CallExpression).callee)	60✔
157	}
158
159	public explain() {
160	return `Expected ${this.expected} ${this.hasVarArgs ? 'or more ' : ''}arguments, but got ${	60✔
161	this.got
162	}.`
163	}
164
165	public elaborate() {
166	const calleeStr = this.calleeStr	12✔
167	const pluralS = this.expected === 1 ? '' : 's'	12✔
168
169	return `Try calling function ${calleeStr} again, but with ${this.expected} argument${pluralS} instead. Remember that arguments are separated by a ',' (comma).`	12✔
170	}
171	}
172
173	export class VariableRedeclaration extends RuntimeSourceError {	70✔
174	constructor(private node: Node, private name: string, private writable?: boolean) {	×
175	super(node)	×
176	}
177
178	public explain() {
179	return `Redeclaring name ${this.name}.`	×
180	}
181
182	public elaborate() {
183	if (this.writable === true) {	×
184	const elabStr = `Since ${this.name} has already been declared, you can assign a value to it without re-declaring.`	×
185
186	let initStr = ''	×
187
188	if (this.node.type === 'FunctionDeclaration') {	×
189	initStr =	×
190	'(' + (this.node as es.FunctionDeclaration).params.map(generate).join(',') + ') => {...'
191	} else if (this.node.type === 'VariableDeclaration') {	×
192	initStr = generate((this.node as es.VariableDeclaration).declarations[0].init)	×
193	}
194
195	return `${elabStr} As such, you can just do\n\n\t${this.name} = ${initStr};\n`	×
196	} else if (this.writable === false) {	×
197	return `You will need to declare another variable, as ${this.name} is read-only.`	×
198	} else {
199	return ''	×
200	}
201	}
202	}
203
204	export class ConstAssignment extends RuntimeSourceError {	70✔
205	constructor(node: Node, private name: string) {	13✔
206	super(node)	13✔
207	}
208
209	public explain() {
210	return `Cannot assign new value to constant ${this.name}.`	13✔
211	}
212
213	public elaborate() {
214	return `As ${this.name} was declared as a constant, its value cannot be changed. You will have to declare a new variable.`	4✔
215	}
216	}
217
218	export class GetPropertyError extends RuntimeSourceError {	70✔
219	constructor(node: Node, private obj: Value, private prop: string) {	×
220	super(node)	×
221	}
222
223	public explain() {
224	return `Cannot read property ${this.prop} of ${stringify(this.obj)}.`	×
225	}
226
227	public elaborate() {
228	return 'TODO'	×
229	}
230	}
231
232	export class GetInheritedPropertyError extends RuntimeSourceError {	70✔
233	public type = ErrorType.RUNTIME	2✔
234	public severity = ErrorSeverity.ERROR	2✔
235	public location: es.SourceLocation
236
237	constructor(node: Node, private obj: Value, private prop: string) {	2✔
238	super(node)	2✔
239	this.location = node.loc ?? UNKNOWN_LOCATION	2!
240	}
241
242	public explain() {
243	return `Cannot read inherited property ${this.prop} of ${stringify(this.obj)}.`	2✔
244	}
245
246	public elaborate() {
247	return 'TODO'	×
248	}
249	}
250
251	export class SetPropertyError extends RuntimeSourceError {	70✔
252	constructor(node: Node, private obj: Value, private prop: string) {	×
253	super(node)	×
254	}
255
256	public explain() {
257	return `Cannot assign property ${this.prop} of ${stringify(this.obj)}.`	×
258	}
259
260	public elaborate() {
261	return 'TODO'	×
262	}
263	}

source-academy / js-slang / 8506821052

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