8580048012

Committed 06 Apr 2024 08:56AM UTC coverage: 81.645% (+0.05%) from 81.591%

Build # 8580048012

Build Type

Pull #1637

github

Committed by

web-flow

Commit Message

Merge 41afd59a9 into 8747fd53b

Pull Request Pull Request #1637: Remove Synchronous Module Loading

Run Details

3303 of 4409 branches covered (74.91%)

Branch coverage included in aggregate %.

282 of 309 new or added lines in 22 files covered. (91.26%)

14 existing lines in 6 files now uncovered.

10615 of 12638 relevant lines covered (83.99%)

135976.01 hits per line

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

14.29

/src/utils/statementSeqTransform.ts

import * as es from 'estree'

import { Node, StatementSequence } from '../types'
import * as ast from './ast/astCreator'
function hasDeclarations(node: es.BlockStatement | es.Program): boolean {
  for (const statement of node.body) {
    if (statement.type === 'VariableDeclaration' || statement.type === 'FunctionDeclaration') {
      return true
    }
  }
  return false
}

function hasImportDeclarations(node: es.Program): boolean {
  for (const statement of node.body) {
    if (statement.type === 'ImportDeclaration') {
      return true
    }
  }
  return false
}

type NodeTransformer = (node: Node) => Node

type ASTTransformers = Map<string, NodeTransformer>

const transformers: ASTTransformers = new Map<string, NodeTransformer>([
  [
    'Program',
    (node: es.Program) => {
      if (hasDeclarations(node) || hasImportDeclarations(node)) {
        return node
      } else {
        return ast.statementSequence(node.body as es.Statement[], node.loc)
      }
    }
  ],

  [
    'BlockStatement',
    (node: es.BlockStatement) => {
      node.body = node.body.map(x => transform(x))
      if (hasDeclarations(node)) {
        return node
      } else {
        return ast.statementSequence(node.body, node.loc)
      }
    }
  ],

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

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

  [
    'IfStatement',
    (node: es.IfStatement) => {
      node.test = transform(node.test)
      node.consequent = transform(node.consequent)
      if (node.alternate) {
        node.alternate = transform(node.alternate)
      }
      return node
    }
  ],

  [
    'FunctionDeclaration',
    (node: es.FunctionDeclaration) => {
      node.params = node.params.map(x => transform(x))
      node.body = transform(node.body)
      if (node.id) {
        node.id = transform(node.id)
      }
      return node
    }
  ],

  [
    'VariableDeclarator',
    (node: es.VariableDeclarator) => {
      node.id = transform(node.id)
      if (node.init) {
        node.init = transform(node.init)
      }
      return node
    }
  ],

  [
    'VariableDeclaration',
    (node: es.VariableDeclaration) => {
      node.declarations = node.declarations.map(x => transform(x))
      return node
    }
  ],

  [
    'ReturnStatement',
    (node: es.ReturnStatement) => {
      if (node.argument) {
        node.argument = transform(node.argument)
      }
      return node
    }
  ],

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

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

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

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

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

  [
    'ArrowFunctionExpression',
    (node: es.ArrowFunctionExpression) => {
      node.params = node.params.map(x => transform(x))
      node.body = transform(node.body)
      return node
    }
  ],

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

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

  [
    'ArrayExpression',
    (node: es.ArrayExpression) => {
      node.elements = node.elements.map(x => (x ? transform(x) : null))
      return node
    }
  ],

  [
    'AssignmentExpression',
    (node: es.AssignmentExpression) => {
      node.left = transform(node.left)
      node.right = transform(node.right)
      return node
    }
  ],

  [
    'ForStatement',
    (node: es.ForStatement) => {
      if (node.init) {
        node.init = transform(node.init)
      }
      if (node.test) {
        node.test = transform(node.test)
      }
      if (node.update) {
        node.update = transform(node.update)
      }
      node.body = transform(node.body)
      return node
    }
  ],

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

  [
    'BreakStatement',
    (node: es.BreakStatement) => {
      if (node.label) {
        node.label = transform(node.label)
      }
      return node
    }
  ],

  [
    'ContinueStatement',
    (node: es.ContinueStatement) => {
      if (node.label) {
        node.label = transform(node.label)
      }
      return node
    }
  ],

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

  [
    'MemberExpression',
    (node: es.MemberExpression) => {
      node.object = transform(node.object)
      node.property = transform(node.property)
      return node
    }
  ],

  [
    'Property',
    (node: es.Property) => {
      node.key = transform(node.key)
      node.value = transform(node.value)
      return node
    }
  ],

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

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

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

  [
    'ExportNamedDeclaration',
    (node: es.ExportNamedDeclaration) => {
      if (node.declaration) {
        node.declaration = transform(node.declaration)
      }
      node.specifiers = node.specifiers.map(x => transform(x))
      if (node.source) {
        transform(node.source)
      }
      return node
    }
  ],

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

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

  [
    'ClassDeclaration',
    (node: es.ClassDeclaration) => {
      if (node.id) {
        node.id = transform(node.id)
      }
      if (node.superClass) {
        node.superClass = transform(node.superClass)
      }
      node.body = transform(node.body)
      return node
    }
  ],

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

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

  [
    'FunctionExpression',
    (node: es.FunctionExpression) => {
      if (node.id) {
        node.id = transform(node.id)
      }
      node.params = node.params.map(x => transform(x))
      node.body = transform(node.body)
      return node
    }
  ],

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

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

  [
    'TryStatement',
    (node: es.TryStatement) => {
      node.block = transform(node.block)
      if (node.handler) {
        node.handler = transform(node.handler)
      }
      if (node.finalizer) {
        node.finalizer = transform(node.finalizer)
      }
      return node
    }
  ],
  [
    'ThrowStatement',
    (node: es.ThrowStatement) => {
      node.argument = transform(node.argument)
      return node
    }
  ],
  [
    'SpreadElement',
    (node: es.SpreadElement) => {
      node.argument = transform(node.argument)
      return node
    }
  ],
  [
    'RestElement',
    (node: es.RestElement) => {
      node.argument = transform(node.argument)
      return node
    }
  ]
])

export function transform<NodeType extends Node>(node: NodeType): NodeType {
  if (transformers.has(node.type)) {
    const transformer = transformers.get(node.type) as (n: NodeType) => NodeType
    const transformed = transformer(node)
    return transformed
  } else {
    return node
  }
}

1	import * as es from 'estree'
2
3	import { Node, StatementSequence } from '../types'
4	import * as ast from './ast/astCreator'	53✔
5	function hasDeclarations(node: es.BlockStatement \| es.Program): boolean {
6	for (const statement of node.body) {	1,577✔
7	if (statement.type === 'VariableDeclaration' \|\| statement.type === 'FunctionDeclaration') {	1,607✔
8	return true	1,488✔
9	}
10	}
11	return false	89✔
12	}
13
14	function hasImportDeclarations(node: es.Program): boolean {
15	for (const statement of node.body) {	89✔
16	if (statement.type === 'ImportDeclaration') {	112!
UNCOV 17	return true	×
18	}
19	}
20	return false	89✔
21	}
22
23	type NodeTransformer = (node: Node) => Node
24
25	type ASTTransformers = Map<string, NodeTransformer>
26
27	const transformers: ASTTransformers = new Map<string, NodeTransformer>([	53✔
28	[
29	'Program',
30	(node: es.Program) => {
31	if (hasDeclarations(node) \|\| hasImportDeclarations(node)) {	1,577✔
32	return node	1,488✔
33	} else {
34	return ast.statementSequence(node.body as es.Statement[], node.loc)	89✔
35	}
36	}
37	],
38
39	[
40	'BlockStatement',
41	(node: es.BlockStatement) => {
42	node.body = node.body.map(x => transform(x))	×
43	if (hasDeclarations(node)) {	×
44	return node	×
45	} else {
46	return ast.statementSequence(node.body, node.loc)	×
47	}
48	}
49	],
50
51	[
52	'StatementSequence',
53	(node: StatementSequence) => {
54	node.body = node.body.map(x => transform(x))	×
55	return node	×
56	}
57	],
58
59	[
60	'ExpressionStatement',
61	(node: es.ExpressionStatement) => {
62	node.expression = transform(node.expression)	×
63	return node	×
64	}
65	],
66
67	[
68	'IfStatement',
69	(node: es.IfStatement) => {
70	node.test = transform(node.test)	×
71	node.consequent = transform(node.consequent)	×
72	if (node.alternate) {	×
73	node.alternate = transform(node.alternate)	×
74	}
75	return node	×
76	}
77	],
78
79	[
80	'FunctionDeclaration',
81	(node: es.FunctionDeclaration) => {
82	node.params = node.params.map(x => transform(x))	×
83	node.body = transform(node.body)	×
84	if (node.id) {	×
85	node.id = transform(node.id)	×
86	}
87	return node	×
88	}
89	],
90
91	[
92	'VariableDeclarator',
93	(node: es.VariableDeclarator) => {
94	node.id = transform(node.id)	×
95	if (node.init) {	×
96	node.init = transform(node.init)	×
97	}
98	return node	×
99	}
100	],
101
102	[
103	'VariableDeclaration',
104	(node: es.VariableDeclaration) => {
105	node.declarations = node.declarations.map(x => transform(x))	×
106	return node	×
107	}
108	],
109
110	[
111	'ReturnStatement',
112	(node: es.ReturnStatement) => {
113	if (node.argument) {	×
114	node.argument = transform(node.argument)	×
115	}
116	return node	×
117	}
118	],
119
120	[
121	'CallExpression',
122	(node: es.SimpleCallExpression) => {
123	node.callee = transform(node.callee)	×
124	node.arguments = node.arguments.map(x => transform(x))	×
125	return node	×
126	}
127	],
128
129	[
130	'UnaryExpression',
131	(node: es.UnaryExpression) => {
132	node.argument = transform(node.argument)	×
133	return node	×
134	}
135	],
136
137	[
138	'BinaryExpression',
139	(node: es.BinaryExpression) => {
140	node.left = transform(node.left)	×
141	node.right = transform(node.right)	×
142	return node	×
143	}
144	],
145
146	[
147	'LogicalExpression',
148	(node: es.LogicalExpression) => {
149	node.left = transform(node.left)	×
150	node.right = transform(node.right)	×
151	return node	×
152	}
153	],
154
155	[
156	'ConditionalExpression',
157	(node: es.ConditionalExpression) => {
158	node.test = transform(node.test)	×
159	node.consequent = transform(node.consequent)	×
160	node.alternate = transform(node.alternate)	×
161	return node	×
162	}
163	],
164
165	[
166	'ArrowFunctionExpression',
167	(node: es.ArrowFunctionExpression) => {
168	node.params = node.params.map(x => transform(x))	×
169	node.body = transform(node.body)	×
170	return node	×
171	}
172	],
173
174	[
175	'Identifier',
176	(node: es.Identifier) => {
177	return node	×
178	}
179	],
180
181	[
182	'Literal',
183	(node: es.Literal) => {
184	return node	×
185	}
186	],
187
188	[
189	'ArrayExpression',
190	(node: es.ArrayExpression) => {
191	node.elements = node.elements.map(x => (x ? transform(x) : null))	×
192	return node	×
193	}
194	],
195
196	[
197	'AssignmentExpression',
198	(node: es.AssignmentExpression) => {
199	node.left = transform(node.left)	×
200	node.right = transform(node.right)	×
201	return node	×
202	}
203	],
204
205	[
206	'ForStatement',
207	(node: es.ForStatement) => {
208	if (node.init) {	×
209	node.init = transform(node.init)	×
210	}
211	if (node.test) {	×
212	node.test = transform(node.test)	×
213	}
214	if (node.update) {	×
215	node.update = transform(node.update)	×
216	}
217	node.body = transform(node.body)	×
218	return node	×
219	}
220	],
221
222	[
223	'WhileStatement',
224	(node: es.WhileStatement) => {
225	node.test = transform(node.test)	×
226	node.body = transform(node.body)	×
227	return node	×
228	}
229	],
230
231	[
232	'BreakStatement',
233	(node: es.BreakStatement) => {
234	if (node.label) {	×
235	node.label = transform(node.label)	×
236	}
237	return node	×
238	}
239	],
240
241	[
242	'ContinueStatement',
243	(node: es.ContinueStatement) => {
244	if (node.label) {	×
245	node.label = transform(node.label)	×
246	}
247	return node	×
248	}
249	],
250
251	[
252	'ObjectExpression',
253	(node: es.ObjectExpression) => {
254	node.properties = node.properties.map(x => transform(x))	×
255	return node	×
256	}
257	],
258
259	[
260	'MemberExpression',
261	(node: es.MemberExpression) => {
262	node.object = transform(node.object)	×
263	node.property = transform(node.property)	×
264	return node	×
265	}
266	],
267
268	[
269	'Property',
270	(node: es.Property) => {
271	node.key = transform(node.key)	×
272	node.value = transform(node.value)	×
273	return node	×
274	}
275	],
276
277	[
278	'ImportDeclaration',
279	(node: es.ImportDeclaration) => {
280	node.specifiers = node.specifiers.map(x => transform(x))	×
281	node.source = transform(node.source)	×
282	return node	×
283	}
284	],
285
286	[
287	'ImportSpecifier',
288	(node: es.ImportSpecifier) => {
289	node.local = transform(node.local)	×
290	node.imported = transform(node.imported)	×
291	return node	×
292	}
293	],
294
295	[
296	'ImportDefaultSpecifier',
297	(node: es.ImportDefaultSpecifier) => {
298	node.local = transform(node.local)	×
299	return node	×
300	}
301	],
302
303	[
304	'ExportNamedDeclaration',
305	(node: es.ExportNamedDeclaration) => {
306	if (node.declaration) {	×
307	node.declaration = transform(node.declaration)	×
308	}
309	node.specifiers = node.specifiers.map(x => transform(x))	×
310	if (node.source) {	×
311	transform(node.source)	×
312	}
313	return node	×
314	}
315	],
316
317	[
318	'ExportDefaultDeclaration',
319	(node: es.ExportDefaultDeclaration) => {
320	node.declaration = transform(node.declaration)	×
321	return node	×
322	}
323	],
324
325	[
326	'ExportSpecifier',
327	(node: es.ExportSpecifier) => {
328	node.local = transform(node.local)	×
329	node.exported = transform(node.exported)	×
330	return node	×
331	}
332	],
333
334	[
335	'ClassDeclaration',
336	(node: es.ClassDeclaration) => {
337	if (node.id) {	×
338	node.id = transform(node.id)	×
339	}
340	if (node.superClass) {	×
341	node.superClass = transform(node.superClass)	×
342	}
343	node.body = transform(node.body)	×
344	return node	×
345	}
346	],
347
348	[
349	'NewExpression',
350	(node: es.NewExpression) => {
351	node.arguments = node.arguments.map(x => transform(x))	×
352	return node	×
353	}
354	],
355
356	[
357	'MethodDefinition',
358	(node: es.MethodDefinition) => {
359	node.key = transform(node.key)	×
360	node.value = transform(node.value)	×
361	return node	×
362	}
363	],
364
365	[
366	'FunctionExpression',
367	(node: es.FunctionExpression) => {
368	if (node.id) {	×
369	node.id = transform(node.id)	×
370	}
371	node.params = node.params.map(x => transform(x))	×
372	node.body = transform(node.body)	×
373	return node	×
374	}
375	],
376
377	[
378	'ThisExpression',
379	(_node: es.ThisExpression) => {
380	return _node	×
381	}
382	],
383
384	[
385	'Super',
386	(_node: es.Super) => {
387	return _node	×
388	}
389	],
390
391	[
392	'TryStatement',
393	(node: es.TryStatement) => {
394	node.block = transform(node.block)	×
395	if (node.handler) {	×
396	node.handler = transform(node.handler)	×
397	}
398	if (node.finalizer) {	×
399	node.finalizer = transform(node.finalizer)	×
400	}
401	return node	×
402	}
403	],
404	[
405	'ThrowStatement',
406	(node: es.ThrowStatement) => {
407	node.argument = transform(node.argument)	×
408	return node	×
409	}
410	],
411	[
412	'SpreadElement',
413	(node: es.SpreadElement) => {
414	node.argument = transform(node.argument)	×
415	return node	×
416	}
417	],
418	[
419	'RestElement',
420	(node: es.RestElement) => {
421	node.argument = transform(node.argument)	×
422	return node	×
423	}
424	]
425	])
426
427	export function transform<NodeType extends Node>(node: NodeType): NodeType {	53✔
428	if (transformers.has(node.type)) {	1,577!
429	const transformer = transformers.get(node.type) as (n: NodeType) => NodeType	1,577✔
430	const transformed = transformer(node)	1,577✔
431	return transformed	1,577✔
432	} else {
433	return node	×
434	}
435	}

source-academy / js-slang / 8580048012

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