8344121055

Committed 19 Mar 2024 01:44PM UTC coverage: 81.196% (-0.7%) from 81.887%

Build # 8344121055

Build Type

Pull #1575

github

Committed by

web-flow

Commit Message

Merge c1ab01d75 into 746eb8b1e

Pull Request Pull Request #1575: Implement statement sequence for the CSE machine

Run Details

3407 of 4609 branches covered (73.92%)

Branch coverage included in aggregate %.

152 of 298 new or added lines in 46 files covered. (51.01%)

2 existing lines in 2 files now uncovered.

10402 of 12398 relevant lines covered (83.9%)

102796.17 hits per line

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

71.74

/src/stdlib/parser.ts

import * as es from 'estree'

import { parse as sourceParse } from '../parser/parser'
import { SourceParser } from '../parser/source'
import { libraryParserLanguage } from '../parser/source/syntax'
import { Context, ContiguousArrayElements, Node, StatementSequence, Value } from '../types'
import { oneLine } from '../utils/formatters'
import { vector_to_list } from './list'

class ParseError extends Error {
  constructor(message: string) {
    super(message)
    this.name = 'ParseError'
  }
}

function unreachable() {
  // tslint:disable-next-line:no-console
  console.error(oneLine`
    UNREACHABLE CODE REACHED!
    Please file an issue at
    https://github.com/source-academy/js-slang/issues
    if you see this.
  `)
}

// sequences of expressions of length 1
// can be represented by the element itself,
// instead of constructing a sequence

function makeSequenceIfNeeded(exs: Node[]) {
  return exs.length === 1
    ? transform(exs[0])
    : vector_to_list(['sequence', vector_to_list(exs.map(transform))])
}

function makeBlockIfNeeded(exs: Node[]) {
  return hasDeclarationAtToplevel(exs)
    ? vector_to_list(['block', makeSequenceIfNeeded(exs)])
    : makeSequenceIfNeeded(exs)
}

// checks if sequence has declaration at toplevel
// (outside of any block)
function hasDeclarationAtToplevel(exs: Node[]) {
  return exs.reduce(
    (b, ex) => b || ex.type === 'VariableDeclaration' || ex.type === 'FunctionDeclaration',
    false
  )
}

type ASTTransformers = Map<string, (node: Node) => Value>

const transformers: ASTTransformers = new Map([
  [
    'Program',
    (node: Node) => {
      node = node as es.Program
      return makeSequenceIfNeeded(node.body)
    }
  ],

  [
    'BlockStatement',
    (node: es.BlockStatement) => {
      return makeBlockIfNeeded(node.body)
    }
  ],

  [
    'StatementSequence',
    (node: StatementSequence) => {
      return makeSequenceIfNeeded(node.body)
    }
  ],

  [
    'ExpressionStatement',
    (node: es.ExpressionStatement) => {
      return transform(node.expression)
    }
  ],

  [
    'IfStatement',
    (node: es.IfStatement) => {
      return vector_to_list([
        'conditional_statement',
        transform(node.test),
        transform(node.consequent),
        node.alternate === null
          ? makeSequenceIfNeeded([])
          : transform(node.alternate as es.Statement)
      ])
    }
  ],

  [
    'FunctionDeclaration',
    (node: es.FunctionDeclaration) => {
      return vector_to_list([
        'function_declaration',
        transform(node.id as es.Identifier),
        vector_to_list(node.params.map(transform)),
        makeBlockIfNeeded(node.body.body)
      ])
    }
  ],

  [
    'VariableDeclaration',
    (node: es.VariableDeclaration) => {
      if (node.kind === 'let') {
        return vector_to_list([
          'variable_declaration',
          transform(node.declarations[0].id),
          transform(node.declarations[0].init as es.Expression)
        ])
      } else if (node.kind === 'const') {
        return vector_to_list([
          'constant_declaration',
          transform(node.declarations[0].id),
          transform(node.declarations[0].init as es.Expression)
        ])
      } else {
        unreachable()
        throw new ParseError('Invalid declaration kind')
      }
    }
  ],

  [
    'ReturnStatement',
    (node: es.ReturnStatement) => {
      return vector_to_list(['return_statement', transform(node.argument as es.Expression)])
    }
  ],

  [
    'CallExpression',
    (node: es.CallExpression) => {
      return vector_to_list([
        'application',
        transform(node.callee),
        vector_to_list(node.arguments.map(transform))
      ])
    }
  ],

  [
    'UnaryExpression',
    (node: es.UnaryExpression) => {
      return vector_to_list([
        'unary_operator_combination',
        node.operator === '-' ? '-unary' : node.operator,
        transform(node.argument)
      ])
    }
  ],

  [
    'BinaryExpression',
    (node: es.BinaryExpression) => {
      return vector_to_list([
        'binary_operator_combination',
        node.operator,
        transform(node.left),
        transform(node.right)
      ])
    }
  ],

  [
    'LogicalExpression',
    (node: es.LogicalExpression) => {
      return vector_to_list([
        'logical_composition',
        node.operator,
        transform(node.left),
        transform(node.right)
      ])
    }
  ],

  [
    'ConditionalExpression',
    (node: es.ConditionalExpression) => {
      return vector_to_list([
        'conditional_expression',
        transform(node.test),
        transform(node.consequent),
        transform(node.alternate)
      ])
    }
  ],

  [
    'ArrowFunctionExpression',
    (node: es.ArrowFunctionExpression) => {
      return vector_to_list([
        'lambda_expression',
        vector_to_list(node.params.map(transform)),
        node.body.type === 'BlockStatement'
          ? // body.body: strip away one layer of block:
            // The body of a function is the statement
            // inside the curly braces.
            makeBlockIfNeeded(node.body.body)
          : vector_to_list(['return_statement', transform(node.body)])
      ])
    }
  ],

  [
    'Identifier',
    (node: es.Identifier) => {
      return vector_to_list(['name', node.name])
    }
  ],

  [
    'Literal',
    (node: es.Literal) => {
      return vector_to_list(['literal', node.value])
    }
  ],

  [
    'ArrayExpression',
    (node: es.ArrayExpression) => {
      return vector_to_list([
        'array_expression',
        vector_to_list((node.elements as ContiguousArrayElements).map(transform))
      ])
    }
  ],

  [
    'AssignmentExpression',
    (node: es.AssignmentExpression) => {
      if (node.left.type === 'Identifier') {
        return vector_to_list([
          'assignment',
          transform(node.left as es.Identifier),
          transform(node.right)
        ])
      } else if (node.left.type === 'MemberExpression') {
        return vector_to_list([
          'object_assignment',
          transform(node.left as es.Expression),
          transform(node.right)
        ])
      } else {
        unreachable()
        throw new ParseError('Invalid assignment')
      }
    }
  ],

  [
    'ForStatement',
    (node: es.ForStatement) => {
      return vector_to_list([
        'for_loop',
        transform(node.init as es.VariableDeclaration | es.Expression),
        transform(node.test as es.Expression),
        transform(node.update as es.Expression),
        transform(node.body)
      ])
    }
  ],

  [
    'WhileStatement',
    (node: es.WhileStatement) => {
      return vector_to_list(['while_loop', transform(node.test), transform(node.body)])
    }
  ],

  [
    'BreakStatement',
    (_node: es.BreakStatement) => {
      return vector_to_list(['break_statement'])
    }
  ],

  [
    'ContinueStatement',
    (_node: es.ContinueStatement) => {
      return vector_to_list(['continue_statement'])
    }
  ],

  [
    'ObjectExpression',
    (node: es.ObjectExpression) => {
      return vector_to_list(['object_expression', vector_to_list(node.properties.map(transform))])
    }
  ],

  [
    'MemberExpression',
    (node: es.MemberExpression) => {
      // "computed" property of MemberExpression distinguishes
      // between dot access (not computed) and
      // a[...] (computed)
      // the key in dot access is meant as string, and
      // represented by a "property" node in parse result
      return vector_to_list([
        'object_access',
        transform(node.object),
        !node.computed && node.property.type === 'Identifier'
          ? vector_to_list(['property', node.property.name])
          : transform(node.property)
      ])
    }
  ],

  [
    'Property',
    (node: es.Property) => {
      // identifiers before the ":" in literal objects are meant
      // as string, and represented by a "property" node in parse result
      return vector_to_list([
        'key_value_pair',
        node.key.type === 'Identifier'
          ? vector_to_list(['property', node.key.name])
          : transform(node.key),
        transform(node.value)
      ])
    }
  ],

  [
    'ImportDeclaration',
    (node: es.ImportDeclaration) => {
      return vector_to_list([
        'import_declaration',
        vector_to_list(node.specifiers.map(transform)),
        node.source.value
      ])
    }
  ],

  [
    'ImportSpecifier',
    (node: es.ImportSpecifier) => {
      return vector_to_list(['name', node.imported.name])
    }
  ],

  [
    'ImportDefaultSpecifier',
    (_node: es.ImportDefaultSpecifier) => {
      return vector_to_list(['default'])
    }
  ],

  [
    'ExportNamedDeclaration',
    (node: es.ExportNamedDeclaration) => {
      return vector_to_list([
        'export_named_declaration',
        node.declaration ? transform(node.declaration) : node.specifiers.map(transform)
      ])
    }
  ],

  [
    'ExportDefaultDeclaration',
    (node: es.ExportDefaultDeclaration) => {
      return vector_to_list(['export_default_declaration', transform(node.declaration)])
    }
  ],

  [
    'ExportSpecifier',
    (node: es.ExportSpecifier) => {
      return vector_to_list(['name', node.exported.name])
    }
  ],

  [
    'ClassDeclaration',
    (node: es.ClassDeclaration) => {
      return vector_to_list([
        'class_declaration',
        vector_to_list([
          'name',
          node.id === null ? null : node.id.name,
          node.superClass === null || node.superClass === undefined
            ? null
            : transform(node.superClass),
          node.body.body.map(transform)
        ])
      ])
    }
  ],

  [
    'NewExpression',
    (node: es.NewExpression) => {
      return vector_to_list([
        'new_expression',
        transform(node.callee),
        vector_to_list(node.arguments.map(transform))
      ])
    }
  ],

  [
    'MethodDefinition',
    (node: es.MethodDefinition) => {
      return vector_to_list([
        'method_definition',
        node.kind,
        node.static,
        transform(node.key),
        transform(node.value)
      ])
    }
  ],

  [
    'FunctionExpression',
    (node: es.FunctionExpression) => {
      return vector_to_list([
        'lambda_expression',
        vector_to_list(node.params.map(transform)),
        makeBlockIfNeeded(node.body.body)
      ])
    }
  ],

  [
    'ThisExpression',
    (_node: es.ThisExpression) => {
      return vector_to_list(['this_expression'])
    }
  ],

  [
    'Super',
    (_node: es.Super) => {
      return vector_to_list(['super_expression'])
    }
  ],

  [
    'TryStatement',
    (node: es.TryStatement) => {
      return vector_to_list([
        'try_statement',
        transform(node.block),
        node.handler === null || node.handler === undefined
          ? null
          : vector_to_list(['name', (node.handler.param as es.Identifier).name]),
        node.handler === null || node.handler === undefined ? null : transform(node.handler.body)
      ])
    }
  ],
  [
    'ThrowStatement',
    (node: es.ThrowStatement) => {
      return vector_to_list(['throw_statement', transform(node.argument)])
    }
  ],
  [
    'SpreadElement',
    (node: es.SpreadElement) => {
      return vector_to_list(['spread_element', transform(node.argument)])
    }
  ],
  [
    'RestElement',
    (node: es.RestElement) => {
      return vector_to_list(['rest_element', transform(node.argument)])
    }
  ]
])

function transform(node: Node) {
  if (transformers.has(node.type)) {
    const transformer = transformers.get(node.type) as (n: Node) => Value
    const transformed = transformer(node)
    // Attach location information
    if (
      transformed !== null &&
      transformed !== undefined &&
      typeof transformed === 'object' &&
      transformed.tag !== undefined
    ) {
      transformed.loc = node.loc
    }
    return transformed
  } else {
    unreachable()
    throw new ParseError('Cannot transform unknown type: ' + node.type)
  }
}

export function parse(x: string, context: Context): Value {
  context.chapter = libraryParserLanguage
  const program = sourceParse(x, context)
  if (context.errors.length > 0) {
    throw new ParseError(context.errors[0].explain())
  }

  if (program) {
    return transform(program)
  } else {
    unreachable()
    throw new ParseError('Invalid parse')
  }
}

export function tokenize(x: string, context: Context): Value {
  const tokensArr = SourceParser.tokenize(x, context).map(tok => x.substring(tok.start, tok.end))
  return vector_to_list(tokensArr)
}

1	import * as es from 'estree'
2
3	import { parse as sourceParse } from '../parser/parser'	67✔
4	import { SourceParser } from '../parser/source'	67✔
5	import { libraryParserLanguage } from '../parser/source/syntax'	67✔
6	import { Context, ContiguousArrayElements, Node, StatementSequence, Value } from '../types'
7	import { oneLine } from '../utils/formatters'	67✔
8	import { vector_to_list } from './list'	67✔
9
10	class ParseError extends Error {
11	constructor(message: string) {
12	super(message)	4✔
13	this.name = 'ParseError'	4✔
14	}
15	}
16
17	function unreachable() {
18	// tslint:disable-next-line:no-console
19	console.error(oneLine`	×
20	UNREACHABLE CODE REACHED!
21	Please file an issue at
22	https://github.com/source-academy/js-slang/issues
23	if you see this.
24	`)
25	}
26
27	// sequences of expressions of length 1
28	// can be represented by the element itself,
29	// instead of constructing a sequence
30
31	function makeSequenceIfNeeded(exs: Node[]) {
32	return exs.length === 1	189✔
33	? transform(exs[0])
34	: vector_to_list(['sequence', vector_to_list(exs.map(transform))])
35	}
36
37	function makeBlockIfNeeded(exs: Node[]) {
38	return hasDeclarationAtToplevel(exs)	58✔
39	? vector_to_list(['block', makeSequenceIfNeeded(exs)])
40	: makeSequenceIfNeeded(exs)
41	}
42
43	// checks if sequence has declaration at toplevel
44	// (outside of any block)
45	function hasDeclarationAtToplevel(exs: Node[]) {
46	return exs.reduce(	58✔
47	(b, ex) => b \|\| ex.type === 'VariableDeclaration' \|\| ex.type === 'FunctionDeclaration',	62✔
48	false
49	)
50	}
51
52	type ASTTransformers = Map<string, (node: Node) => Value>
53
54	const transformers: ASTTransformers = new Map([	67✔
55	[
56	'Program',
57	(node: Node) => {
58	node = node as es.Program	129✔
59	return makeSequenceIfNeeded(node.body)	129✔
60	}
61	],
62
63	[
64	'BlockStatement',
65	(node: es.BlockStatement) => {
66	return makeBlockIfNeeded(node.body)	40✔
67	}
68	],
69
70	[
71	'StatementSequence',
72	(node: StatementSequence) => {
NEW 73	return makeSequenceIfNeeded(node.body)	×
74	}
75	],
76
77	[
78	'ExpressionStatement',
79	(node: es.ExpressionStatement) => {
80	return transform(node.expression)	144✔
81	}
82	],
83
84	[
85	'IfStatement',
86	(node: es.IfStatement) => {
87	return vector_to_list([	16✔
88	'conditional_statement',
89	transform(node.test),
90	transform(node.consequent),
91	node.alternate === null	16✔
92	? makeSequenceIfNeeded([])
93	: transform(node.alternate as es.Statement)
94	])
95	}
96	],
97
98	[
99	'FunctionDeclaration',
100	(node: es.FunctionDeclaration) => {
101	return vector_to_list([	14✔
102	'function_declaration',
103	transform(node.id as es.Identifier),
104	vector_to_list(node.params.map(transform)),
105	makeBlockIfNeeded(node.body.body)
106	])
107	}
108	],
109
110	[
111	'VariableDeclaration',
112	(node: es.VariableDeclaration) => {
113	if (node.kind === 'let') {	52✔
114	return vector_to_list([	29✔
115	'variable_declaration',
116	transform(node.declarations[0].id),
117	transform(node.declarations[0].init as es.Expression)
118	])
119	} else if (node.kind === 'const') {	23!
120	return vector_to_list([	23✔
121	'constant_declaration',
122	transform(node.declarations[0].id),
123	transform(node.declarations[0].init as es.Expression)
124	])
125	} else {
126	unreachable()	×
127	throw new ParseError('Invalid declaration kind')	×
128	}
129	}
130	],
131
132	[
133	'ReturnStatement',
134	(node: es.ReturnStatement) => {
135	return vector_to_list(['return_statement', transform(node.argument as es.Expression)])	24✔
136	}
137	],
138
139	[
140	'CallExpression',
141	(node: es.CallExpression) => {
142	return vector_to_list([	36✔
143	'application',
144	transform(node.callee),
145	vector_to_list(node.arguments.map(transform))
146	])
147	}
148	],
149
150	[
151	'UnaryExpression',
152	(node: es.UnaryExpression) => {
153	return vector_to_list([	10✔
154	'unary_operator_combination',
155	node.operator === '-' ? '-unary' : node.operator,	10✔
156	transform(node.argument)
157	])
158	}
159	],
160
161	[
162	'BinaryExpression',
163	(node: es.BinaryExpression) => {
164	return vector_to_list([	88✔
165	'binary_operator_combination',
166	node.operator,
167	transform(node.left),
168	transform(node.right)
169	])
170	}
171	],
172
173	[
174	'LogicalExpression',
175	(node: es.LogicalExpression) => {
176	return vector_to_list([	14✔
177	'logical_composition',
178	node.operator,
179	transform(node.left),
180	transform(node.right)
181	])
182	}
183	],
184
185	[
186	'ConditionalExpression',
187	(node: es.ConditionalExpression) => {
188	return vector_to_list([	6✔
189	'conditional_expression',
190	transform(node.test),
191	transform(node.consequent),
192	transform(node.alternate)
193	])
194	}
195	],
196
197	[
198	'ArrowFunctionExpression',
199	(node: es.ArrowFunctionExpression) => {
200	return vector_to_list([	27✔
201	'lambda_expression',
202	vector_to_list(node.params.map(transform)),
203	node.body.type === 'BlockStatement'	27✔
204	? // body.body: strip away one layer of block:
205	// The body of a function is the statement
206	// inside the curly braces.
207	makeBlockIfNeeded(node.body.body)
208	: vector_to_list(['return_statement', transform(node.body)])
209	])
210	}
211	],
212
213	[
214	'Identifier',
215	(node: es.Identifier) => {
216	return vector_to_list(['name', node.name])	334✔
217	}
218	],
219
220	[
221	'Literal',
222	(node: es.Literal) => {
223	return vector_to_list(['literal', node.value])	307✔
224	}
225	],
226
227	[
228	'ArrayExpression',
229	(node: es.ArrayExpression) => {
230	return vector_to_list([	12✔
231	'array_expression',
232	vector_to_list((node.elements as ContiguousArrayElements).map(transform))
233	])
234	}
235	],
236
237	[
238	'AssignmentExpression',
239	(node: es.AssignmentExpression) => {
240	if (node.left.type === 'Identifier') {	42✔
241	return vector_to_list([	30✔
242	'assignment',
243	transform(node.left as es.Identifier),
244	transform(node.right)
245	])
246	} else if (node.left.type === 'MemberExpression') {	12!
247	return vector_to_list([	12✔
248	'object_assignment',
249	transform(node.left as es.Expression),
250	transform(node.right)
251	])
252	} else {
253	unreachable()	×
254	throw new ParseError('Invalid assignment')	×
255	}
256	}
257	],
258
259	[
260	'ForStatement',
261	(node: es.ForStatement) => {
262	return vector_to_list([	8✔
263	'for_loop',
264	transform(node.init as es.VariableDeclaration \| es.Expression),
265	transform(node.test as es.Expression),
266	transform(node.update as es.Expression),
267	transform(node.body)
268	])
269	}
270	],
271
272	[
273	'WhileStatement',
274	(node: es.WhileStatement) => {
275	return vector_to_list(['while_loop', transform(node.test), transform(node.body)])	4✔
276	}
277	],
278
279	[
280	'BreakStatement',
281	(_node: es.BreakStatement) => {
282	return vector_to_list(['break_statement'])	8✔
283	}
284	],
285
286	[
287	'ContinueStatement',
288	(_node: es.ContinueStatement) => {
289	return vector_to_list(['continue_statement'])	8✔
290	}
291	],
292
293	[
294	'ObjectExpression',
295	(node: es.ObjectExpression) => {
296	return vector_to_list(['object_expression', vector_to_list(node.properties.map(transform))])	21✔
297	}
298	],
299
300	[
301	'MemberExpression',
302	(node: es.MemberExpression) => {
303	// "computed" property of MemberExpression distinguishes
304	// between dot access (not computed) and
305	// a[...] (computed)
306	// the key in dot access is meant as string, and
307	// represented by a "property" node in parse result
308	return vector_to_list([	30✔
309	'object_access',
310	transform(node.object),
311	!node.computed && node.property.type === 'Identifier'	68✔
312	? vector_to_list(['property', node.property.name])
313	: transform(node.property)
314	])
315	}
316	],
317
318	[
319	'Property',
320	(node: es.Property) => {
321	// identifiers before the ":" in literal objects are meant
322	// as string, and represented by a "property" node in parse result
323	return vector_to_list([	39✔
324	'key_value_pair',
325	node.key.type === 'Identifier'	39✔
326	? vector_to_list(['property', node.key.name])
327	: transform(node.key),
328	transform(node.value)
329	])
330	}
331	],
332
333	[
334	'ImportDeclaration',
335	(node: es.ImportDeclaration) => {
336	return vector_to_list([	3✔
337	'import_declaration',
338	vector_to_list(node.specifiers.map(transform)),
339	node.source.value
340	])
341	}
342	],
343
344	[
345	'ImportSpecifier',
346	(node: es.ImportSpecifier) => {
347	return vector_to_list(['name', node.imported.name])	×
348	}
349	],
350
351	[
352	'ImportDefaultSpecifier',
353	(_node: es.ImportDefaultSpecifier) => {
354	return vector_to_list(['default'])	3✔
355	}
356	],
357
358	[
359	'ExportNamedDeclaration',
360	(node: es.ExportNamedDeclaration) => {
361	return vector_to_list([	11✔
362	'export_named_declaration',
363	node.declaration ? transform(node.declaration) : node.specifiers.map(transform)	11✔
364	])
365	}
366	],
367
368	[
369	'ExportDefaultDeclaration',
370	(node: es.ExportDefaultDeclaration) => {
371	return vector_to_list(['export_default_declaration', transform(node.declaration)])	6✔
372	}
373	],
374
375	[
376	'ExportSpecifier',
377	(node: es.ExportSpecifier) => {
378	return vector_to_list(['name', node.exported.name])	3✔
379	}
380	],
381
382	[
383	'ClassDeclaration',
384	(node: es.ClassDeclaration) => {
385	return vector_to_list([	×
386	'class_declaration',
387	vector_to_list([
388	'name',
389	node.id === null ? null : node.id.name,	×
390	node.superClass === null \|\| node.superClass === undefined	×
391	? null
392	: transform(node.superClass),
393	node.body.body.map(transform)
394	])
395	])
396	}
397	],
398
399	[
400	'NewExpression',
401	(node: es.NewExpression) => {
402	return vector_to_list([	×
403	'new_expression',
404	transform(node.callee),
405	vector_to_list(node.arguments.map(transform))
406	])
407	}
408	],
409
410	[
411	'MethodDefinition',
412	(node: es.MethodDefinition) => {
413	return vector_to_list([	×
414	'method_definition',
415	node.kind,
416	node.static,
417	transform(node.key),
418	transform(node.value)
419	])
420	}
421	],
422
423	[
424	'FunctionExpression',
425	(node: es.FunctionExpression) => {
426	return vector_to_list([	×
427	'lambda_expression',
428	vector_to_list(node.params.map(transform)),
429	makeBlockIfNeeded(node.body.body)
430	])
431	}
432	],
433
434	[
435	'ThisExpression',
436	(_node: es.ThisExpression) => {
437	return vector_to_list(['this_expression'])	×
438	}
439	],
440
441	[
442	'Super',
443	(_node: es.Super) => {
444	return vector_to_list(['super_expression'])	×
445	}
446	],
447
448	[
449	'TryStatement',
450	(node: es.TryStatement) => {
451	return vector_to_list([	×
452	'try_statement',
453	transform(node.block),
454	node.handler === null \|\| node.handler === undefined	×
455	? null
456	: vector_to_list(['name', (node.handler.param as es.Identifier).name]),
457	node.handler === null \|\| node.handler === undefined ? null : transform(node.handler.body)	×
458	])
459	}
460	],
461	[
462	'ThrowStatement',
463	(node: es.ThrowStatement) => {
464	return vector_to_list(['throw_statement', transform(node.argument)])	×
465	}
466	],
467	[
468	'SpreadElement',
469	(node: es.SpreadElement) => {
470	return vector_to_list(['spread_element', transform(node.argument)])	2✔
471	}
472	],
473	[
474	'RestElement',
475	(node: es.RestElement) => {
476	return vector_to_list(['rest_element', transform(node.argument)])	2✔
477	}
478	]
479	])
480
481	function transform(node: Node) {
482	if (transformers.has(node.type)) {	1,443!
483	const transformer = transformers.get(node.type) as (n: Node) => Value	1,443✔
484	const transformed = transformer(node)	1,443✔
485	// Attach location information
486	if (	1,443!
487	transformed !== null &&	5,772✔
488	transformed !== undefined &&
489	typeof transformed === 'object' &&
490	transformed.tag !== undefined
491	) {
492	transformed.loc = node.loc	×
493	}
494	return transformed	1,443✔
495	} else {
496	unreachable()	×
497	throw new ParseError('Cannot transform unknown type: ' + node.type)	×
498	}
499	}
500
501	export function parse(x: string, context: Context): Value {	67✔
502	context.chapter = libraryParserLanguage	133✔
503	const program = sourceParse(x, context)	133✔
504	if (context.errors.length > 0) {	133✔
505	throw new ParseError(context.errors[0].explain())	4✔
506	}
507
508	if (program) {	129!
509	return transform(program)	129✔
510	} else {
511	unreachable()	×
512	throw new ParseError('Invalid parse')	×
513	}
514	}
515
516	export function tokenize(x: string, context: Context): Value {	67✔
517	const tokensArr = SourceParser.tokenize(x, context).map(tok => x.substring(tok.start, tok.end))	58✔
518	return vector_to_list(tokensArr)	2✔
519	}

source-academy / js-slang / 8344121055

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