6976064326

Committed 24 Nov 2023 02:04AM UTC coverage: 90.347% (+0.07%) from 90.278%

Build # 6976064326

Build Type

push

github

Committed by

overlookmotel

Commit Message

Instrument: Freeze all external vars of functions containing `eval()` [improve]

Run Details

4731 of 5092 branches covered (0.0%)

Branch coverage included in aggregate %.

13 of 14 new or added lines in 3 files covered. (92.86%)

64 existing lines in 6 files now uncovered.

12678 of 14177 relevant lines covered (89.43%)

12841.41 hits per line

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

71.52

/lib/instrument/visitors/module.js

/* --------------------
 * livepack module
 * Code instrumentation visitor for `import` / `export` statements and `import` expression
 * ------------------*/

'use strict';

// Export
module.exports = {
        ImportDeclaration,
        ExportDefaultDeclaration,
        ExportNamedDeclaration,
        ImportExpression
};

// Imports
const Expression = require('./expression.js'),
        VariableDeclaration = require('./variableDeclaration.js'),
        {FunctionDeclaration} = require('./function.js'),
        {ClassDeclaration} = require('./class.js'),
        {createBinding} = require('../blocks.js'),
        {visitKey, visitKeyMaybe, visitKeyContainer} = require('../visit.js');

// Exports

// NB: `ExportAllDeclaration` needs no visitor.
// It's a no-op as no need to visit `source` as is only a StringLiteral.

/**
 * Visitor for import declaration.
 * @param {Object} node - Import declaration AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ImportDeclaration(node, state) {
        visitKeyContainer(node, 'specifiers', ImportSpecifierAny, state);
        // No need to visit `source` as it's always StringLiteral
}

/**
 * Visitor for import declaration specifier.
 * @param {Object} node - Import specifier AST node
 * @param {Object} state - State object
 * @returns {undefined}
 * @throws {Error} - If unexpected AST node type
 */
function ImportSpecifierAny(node, state) {
        switch (node.type) {
                case 'ImportSpecifier':
                case 'ImportDefaultSpecifier':
                case 'ImportNamespaceSpecifier': return ImportSpecifier(node, state);
                default: throw new Error(`Unexpected import specifier type '${node.type}'`);
        }
}

/**
 * Visitor for import specifier.
 * @param {Object} node - Import specifier AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ImportSpecifier(node, state) {
        // No need to visit `imported` as it's always Identifier or StringLiteral
        createBinding(state.currentBlock, node.local.name, {isConst: true}, state);
}

/**
 * Visitor for export default declaration.
 * @param {Object} node - Export default declaration AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ExportDefaultDeclaration(node, state) {
        visitKey(node, 'declaration', ExportDefaultDeclarationValue, state);
}

/**
 * Visitor for export default declaration value.
 * @param {Object} node - Export default declaration value AST node
 * @param {Object} state - State object
 * @param {Object} parent - Export default declaration AST node
 * @returns {undefined}
 */
function ExportDefaultDeclarationValue(node, state, parent) {
        switch (node.type) {
                case 'FunctionDeclaration': return FunctionDeclaration(node, state, parent, 'declaration');
                case 'ClassDeclaration': return ClassDeclaration(node, state, parent, 'declaration');
                default: return Expression(node, state, parent, 'declaration');
        }
}

/**
 * Visitor for export named declaration.
 * @param {Object} node - Export named declaration AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ExportNamedDeclaration(node, state) {
        // No need to visit `specifiers` as only contains Identifiers.
        // No need to visit `source` as is only a StringLiteral.
        visitKeyMaybe(node, 'declaration', ExportNamedDeclarationValue, state);
}

/**
 * Visitor for export named declaration value.
 * @param {Object} node - Export named declaration value AST node
 * @param {Object} state - State object
 * @param {Object} parent - Export default declaration AST node
 * @returns {undefined}
 * @throws {Error} - If unexpected AST node type
 */
function ExportNamedDeclarationValue(node, state, parent) {
        switch (node.type) {
                case 'VariableDeclaration': return VariableDeclaration(node, state);
                case 'FunctionDeclaration': return FunctionDeclaration(node, state, parent, 'declaration');
                case 'ClassDeclaration': return ClassDeclaration(node, state, parent, 'declaration');
                default: throw new Error(`Unexpected named export declaration type '${node.type}'`);
        }
}

/**
 * Visitor for `import` expression or `import.meta`.
 * @param {Object} node - `import` expression or meta property AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ImportExpression(node, state) {
        // Flag current function and all above it as containing `import`
        let fn = state.currentFunction;
        while (fn && !fn.containsImport) {
                fn.containsImport = true;
                fn = fn.parent;
        }
}

1	/* --------------------	62✔
2	* livepack module	62✔
3	* Code instrumentation visitor for `import` / `export` statements and `import` expression	62✔
4	* ------------------*/	62✔
5		62✔
6	'use strict';	62✔
7		62✔
8	// Export	62✔
9	module.exports = {	62✔
10	ImportDeclaration,	62✔
11	ExportDefaultDeclaration,	62✔
12	ExportNamedDeclaration,	62✔
13	ImportExpression	62✔
14	};	62✔
15		62✔
16	// Imports	62✔
17	const Expression = require('./expression.js'),	62✔
18	VariableDeclaration = require('./variableDeclaration.js'),	62✔
19	{FunctionDeclaration} = require('./function.js'),	62✔
20	{ClassDeclaration} = require('./class.js'),	62✔
21	{createBinding} = require('../blocks.js'),	62✔
22	{visitKey, visitKeyMaybe, visitKeyContainer} = require('../visit.js');	62✔
23		62✔
24	// Exports	62✔
25		62✔
26	// NB: `ExportAllDeclaration` needs no visitor.	62✔
27	// It's a no-op as no need to visit `source` as is only a StringLiteral.	62✔
28		62✔
29	/**	62✔
30	* Visitor for import declaration.	62✔
31	* @param {Object} node - Import declaration AST node	62✔
32	* @param {Object} state - State object	62✔
33	* @returns {undefined}	62✔
34	*/	62✔
UNCOV 35	function ImportDeclaration(node, state) {	×
36	visitKeyContainer(node, 'specifiers', ImportSpecifierAny, state);	×
37	// No need to visit `source` as it's always StringLiteral	×
38	}	×
39		62✔
40	/**	62✔
41	* Visitor for import declaration specifier.	62✔
42	* @param {Object} node - Import specifier AST node	62✔
43	* @param {Object} state - State object	62✔
44	* @returns {undefined}	6✔
45	* @throws {Error} - If unexpected AST node type	6✔
46	*/	6✔
UNCOV 47	function ImportSpecifierAny(node, state) {	×
48	switch (node.type) {	×
49	case 'ImportSpecifier':	×
50	case 'ImportDefaultSpecifier':	×
51	case 'ImportNamespaceSpecifier': return ImportSpecifier(node, state);	×
52	default: throw new Error(`Unexpected import specifier type '${node.type}'`);	×
53	}	×
54	}	×
55		62✔
56	/**	62✔
57	* Visitor for import specifier.	62✔
58	* @param {Object} node - Import specifier AST node	62✔
59	* @param {Object} state - State object	62✔
60	* @returns {undefined}	62✔
61	*/	62✔
UNCOV 62	function ImportSpecifier(node, state) {	×
63	// No need to visit `imported` as it's always Identifier or StringLiteral	6✔
64	createBinding(state.currentBlock, node.local.name, {isConst: true}, state);	6✔
65	}	6✔
66		6✔
67	/**	6✔
68	* Visitor for export default declaration.	6✔
69	* @param {Object} node - Export default declaration AST node	6✔
70	* @param {Object} state - State object	6✔
71	* @returns {undefined}	6✔
72	*/	6✔
UNCOV 73	function ExportDefaultDeclaration(node, state) {	×
74	visitKey(node, 'declaration', ExportDefaultDeclarationValue, state);	×
75	}	×
76		×
77	/**	×
78	* Visitor for export default declaration value.	62✔
79	* @param {Object} node - Export default declaration value AST node	62✔
80	* @param {Object} state - State object	62✔
81	* @param {Object} parent - Export default declaration AST node	62✔
82	* @returns {undefined}	6✔
83	*/	6✔
UNCOV 84	function ExportDefaultDeclarationValue(node, state, parent) {	×
85	switch (node.type) {	×
86	case 'FunctionDeclaration': return FunctionDeclaration(node, state, parent, 'declaration');	×
87	case 'ClassDeclaration': return ClassDeclaration(node, state, parent, 'declaration');	×
88	default: return Expression(node, state, parent, 'declaration');	×
89	}	×
90	}	×
91		62✔
92	/**	62✔
93	* Visitor for export named declaration.	62✔
94	* @param {Object} node - Export named declaration AST node	62✔
95	* @param {Object} state - State object	62✔
96	* @returns {undefined}	2✔
97	*/	2✔
UNCOV 98	function ExportNamedDeclaration(node, state) {	×
99	// No need to visit `specifiers` as only contains Identifiers.	×
100	// No need to visit `source` as is only a StringLiteral.	×
101	visitKeyMaybe(node, 'declaration', ExportNamedDeclarationValue, state);	×
102	}	×
103		2✔
104	/**	2✔
105	* Visitor for export named declaration value.	62✔
106	* @param {Object} node - Export named declaration value AST node	62✔
107	* @param {Object} state - State object	62✔
108	* @param {Object} parent - Export default declaration AST node	62✔
109	* @returns {undefined}	62✔
110	* @throws {Error} - If unexpected AST node type	62✔
111	*/	2✔
UNCOV 112	function ExportNamedDeclarationValue(node, state, parent) {	×
113	switch (node.type) {	×
114	case 'VariableDeclaration': return VariableDeclaration(node, state);	×
115	case 'FunctionDeclaration': return FunctionDeclaration(node, state, parent, 'declaration');	×
116	case 'ClassDeclaration': return ClassDeclaration(node, state, parent, 'declaration');	×
117	default: throw new Error(`Unexpected named export declaration type '${node.type}'`);	×
118	}	×
119	}	×
120		×
121	/**	×
122	* Visitor for `import` expression or `import.meta`.	2!
123	* @param {Object} node - `import` expression or meta property AST node	62✔
124	* @param {Object} state - State object	62✔
125	* @returns {undefined}	62✔
126	*/	62✔
127	function ImportExpression(node, state) {	54✔
128	// Flag current function and all above it as containing `import`	54✔
129	let fn = state.currentFunction;	14✔
130	while (fn && !fn.containsImport) {	14✔
131	fn.containsImport = true;	14✔
132	fn = fn.parent;	14✔
133	}	14✔
134	}	14✔

overlookmotel / livepack / 6976064326

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