6973279734

Committed 23 Nov 2023 06:32PM UTC coverage: 90.255% (-0.02%) from 90.277%

Build # 6973279734

Build Type

push

github

Committed by

overlookmotel

Commit Message

Allow freezing individual external vars (prep for `with ()` support)

Run Details

4743 of 5104 branches covered (0.0%)

Branch coverage included in aggregate %.

23 of 36 new or added lines in 5 files covered. (63.89%)

4 existing lines in 1 file now uncovered.

12668 of 14187 relevant lines covered (89.29%)

12822.91 hits per line

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

57.75

/lib/instrument/visitors/eval.js

/* --------------------
 * livepack module
 * Code instrumentation visitors for `eval`
 * ------------------*/

'use strict';

// Export
module.exports = visitEval;

// Modules
const t = require('@babel/types');

// Imports
const {
                activateSuperBinding, getParentFullFunction, createInternalVarForThis, createExternalVarForThis,
                setSuperIsProtoOnFunctions
        } = require('./super.js'),
        {getOrCreateExternalVar, activateBlock, activateBinding} = require('../blocks.js'),
        {createTempVarNode} = require('../internalVars.js'),
        {flagAllAncestorFunctions, copyLocAndComments} = require('../utils.js'),
        {isReservedWord, getProp} = require('../../shared/functions.js');

// Exports

/**
 * Visit `eval` identifier.
 * @param {Object} node - `eval` identifier AST node
 * @param {Object|Array} parent - Parent AST node/container
 * @param {string|number} key - Node's key on parent AST node/container
 * @param {Object} state - State object
 * @returns {undefined}
 */
function visitEval(node, parent, key, state) {
        // Flag that `eval()` used in this function and all functions above
        let isEvalCall = key === 'callee' && parent.type === 'CallExpression';
        const fn = state.currentFunction;
        let canUseSuper = false;
        if (isEvalCall && parent.arguments.length > 0) {
                // If called with spread element as first arg (`eval(...x)`), acts as indirect `eval`
                if (parent.arguments[0].type === 'SpreadElement') {
                        isEvalCall = false;
                } else {
                        flagAllAncestorFunctions(fn, 'containsEval');
                        canUseSuper = activateSuperIfIsUsable(fn, state);
                }
        }

        // Flag that `eval` is used in file
        state.fileContainsFunctionsOrEval = true;

        // Queue instrumentation on 2nd pass
        state.secondPass(
                instrumentEval, node, isEvalCall, parent, key, state.currentBlock, fn,
                state.isStrict, canUseSuper, state.currentSuperIsProto, state
        );
}

/**
 * Instrument `eval` - either direct `eval()` or e.g. `x = eval;` / `(0, eval)('...')`.
 * @param {Object} node - `eval` identifier AST node
 * @param {boolean} isEvalCall - `true` if is eval call
 * @param {Object|Array<Object>} parent - Parent AST node/container
 * @param {string|number} key - Node's key on parent AST node/container
 * @param {Object} block - Block object for block `eval` is in
 * @param {Object} [fn] - Function object for function `eval` is in (`undefined` if not in a function)
 * @param {boolean} isStrict - `true` if is strict mode
 * @param {boolean} canUseSuper - `true` if `super()` can be used in `eval()`
 * @param {boolean} superIsProto - `true` if `super` refers to class prototype
 * @param {Object} state - State object
 * @returns {undefined}
 */
function instrumentEval(
        node, isEvalCall, parent, key, block, fn, isStrict, canUseSuper, superIsProto, state
) {
        // Check `eval` is global
        if (!isGlobalEval(block)) return;

        // Handle either `eval()` call or `eval` identifier
        if (isEvalCall) {
                instrumentEvalCall(parent, block, fn, isStrict, canUseSuper, superIsProto, state);
        } else {
                instrumentEvalIdentifier(node, parent, key, state);
        }
}

/**
 * Instrument `eval()` call.
 * Convert `eval()` to `livepack_tracker.evalDirect()`.
 * Capture all vars which can be accessed by `eval()` and pass details to `evalDirect()`.
 * `evalDirect()` will reconstruct the scopes and instrument the `eval()`-ed code.
 * If `eval()` is within a function, flag all vars which `eval()` can access as used by the function.
 *
 * @param {Object} callNode - Call expression AST node
 * @param {Object} block - Block object for block `eval` is in
 * @param {Object} [fn] - Function object for function `eval` is in (`undefined` if not in a function)
 * @param {boolean} isStrict - `true` if is strict mode
 * @param {boolean} canUseSuper - `true` if `super()` can be used in `eval()`
 * @param {boolean} superIsProto - `true` if `super` refers to class prototype
 * @param {Object} state - State object
 * @returns {undefined}
 */
function instrumentEvalCall(callNode, block, fn, isStrict, canUseSuper, superIsProto, state) {
        // If no arguments, leave as is
        const argNodes = callNode.arguments;
        if (argNodes.length === 0) return;

        // Capture all vars in scopes above
        const scopeNodes = [],
                varNamesUsed = new Set();
        let externalVars;
        do {
                // Check if block is external to function
                if (!externalVars && fn && block.id < fn.id) externalVars = fn.externalVars;

                const varDefsNodes = [];
                for (const [varName, binding] of Object.entries(block.bindings)) {
                        // Freeze binding to prevent var being renamed when used internally in a function.
                        // All vars in scope need to be frozen, even if not accessible to `eval()`
                        // because if they're renamed, they would become accessible to `eval()` when they weren't before.
                        // `this` should not be frozen internally, as it can be replaced with a variable
                        // in a class constructor when `super()` is transpiled.
                        // For `super` and `new.target`, the var name can't actually be frozen, but flagged here
                        // as frozen anyway, to indicate that replacement var name should be prefixed with `_`.
                        // Frozen `new.target` is not currently supported.
                        // https://github.com/overlookmotel/livepack/issues/448
                        if (varName !== 'this') {
                                binding.isFrozenName = true;
                                binding.trails.length = 0;
                        }

                        // Skip var if it's shadowed by var with same name in higher scope
                        if (varNamesUsed.has(varName)) continue;

                        // If `eval()` is strict mode, skip vars which are illegal to use in strict mode (e.g. `package`)
                        // as `eval()` won't be able to access them
                        if (isStrict && varName !== 'this' && varName !== 'super' && isReservedWord(varName)) continue;

                        // Ignore `require` as it would render the function containing `eval()` un-serializable.
                        // Also ignore CommonJS wrapper function's `arguments` as that contains `require` too.
                        if ((varName === 'require' || varName === 'arguments') && block === state.fileBlock) continue;

                        // Ignore `super` if it's not accessible
                        if (varName === 'super' && !canUseSuper) continue;

                        varNamesUsed.add(varName);

                        // Create array for var `[varName, isConst, isSilentConst, argNames, tempVarValue]`.
                        // NB: Assignment to var called `arguments` or `eval` is illegal in strict mode.
                        // This is relevant as it affects whether var is flagged as mutable or not.
                        const isConst = binding.isConst || (isStrict && (varName === 'arguments' || varName === 'eval'));
                        const varDefNodes = [t.stringLiteral(varName)];
                        if (isConst) varDefNodes.push(t.numericLiteral(1));
                        if (binding.isSilentConst) varDefNodes.push(t.numericLiteral(1));
                        if (binding.argNames) {
                                while (varDefNodes.length !== 3) varDefNodes.push(null);
                                varDefNodes.push(t.arrayExpression(binding.argNames.map(argName => t.stringLiteral(argName))));
                        }
                        if (varName === 'super') {
                                while (varDefNodes.length !== 4) varDefNodes.push(null);
                                varDefNodes.push(binding.varNode);
                        }
                        varDefsNodes.push(t.arrayExpression(varDefNodes));

                        // If var is external to function, record function as using this var.
                        // Ignore `new.target` and `super` as they're not possible to recreate.
                        // https://github.com/overlookmotel/livepack/issues/448
                        if (externalVars) {
                                if (varName === 'new.target' || varName === 'super') {
                                        const externalVar = externalVars.get(block)?.[varName];
                                        if (externalVar) externalVar.isFrozenName = true;
                                } else {
                                        activateBinding(binding, varName);
                                        const externalVar = getOrCreateExternalVar(externalVars, block, varName, binding);
                                        externalVar.isReadFrom = true;
                                        if (!isConst) externalVar.isAssignedTo = true;
                                        if (!externalVar.isFrozenName) {
                                                externalVar.isFrozenName = true;
                                                externalVar.trails.length = 0;
                                        }
                                }
                        }
                }

                // If some vars from block used, add to scopes definitions
                if (varDefsNodes.length !== 0) {
                        activateBlock(block, state);

                        scopeNodes.push(t.arrayExpression([
                                t.numericLiteral(block.id),
                                block.name ? t.stringLiteral(block.name) : null,
                                block.varsBlock.scopeIdVarNode,
                                ...varDefsNodes
                        ]));
                }
        } while (block = block.parent); // eslint-disable-line no-cond-assign

        // Replace `eval(x)` with
        // `livepack_tracker.evalDirect(
        //   x,
        //   eval,
        //   livepack_temp_1 => eval(livepack_temp_1),
        //   livepack_temp_1 => eval(...livepack_temp_1),
        //   [...], // Scope vars
        //   true // `isStrict` flag
        // )`
        callNode.callee = copyLocAndComments(
                t.memberExpression(state.trackerVarNode, t.identifier('evalDirect')),
                callNode.callee
        );

        const tempVarNode = createTempVarNode(state);
        argNodes.push(
                t.identifier('eval'),
                t.arrowFunctionExpression([tempVarNode], t.callExpression(t.identifier('eval'), [tempVarNode])),
                t.arrowFunctionExpression(
                        [tempVarNode], t.callExpression(t.identifier('eval'), [t.spreadElement(tempVarNode)])
                ),
                t.arrayExpression(scopeNodes.reverse()),
                t.booleanLiteral(isStrict),
                t.booleanLiteral(canUseSuper && superIsProto)
        );
}

/**
 * Instrument `eval` not used standalone (not as an `eval()` call).
 * Replace `eval` with `livepack_tracker.evalIndirect`.
 * @param {Object} node - `eval` identifier AST node
 * @param {Object|Array} parent - Parent AST node/container
 * @param {string|number} key - Node's key on parent AST node/container
 * @param {Object} state - State object
 * @returns {undefined}
 */
function instrumentEvalIdentifier(node, parent, key, state) {
        parent[key] = copyLocAndComments(
                t.memberExpression(state.trackerVarNode, t.identifier('evalIndirect')),
                node
        );
}

/**
 * Determine if `eval` identifier refers to global `eval` (not var called `eval` defined in file).
 * @param {Object} block - Block object that `eval` in in.
 * @returns {boolean} - `true` if `eval` is a global var
 */
function isGlobalEval(block) {
        do {
                if (block.bindings.eval) return false;
        } while (block = block.parent); // eslint-disable-line no-cond-assign
        return true;
}

/**
 * If `super` is usable in this `eval()`, activate `super` block,
 * create an internal / external var for `this`, and set `superIsProto` on function.
 * @param {Object} [fn] - Function object
 * @param {Object} state - State object
 * @returns {boolean} - `true` if `super` is usable
 */
function activateSuperIfIsUsable(fn, state) {
        const superBlock = state.currentSuperBlock;
        if (!superBlock) return false;

        // If no function, this code must be within `eval()` and `super` is outside `eval()`, so it is usable
        if (fn) {
                const fnType = fn.node.type;
                if (fnType === 'FunctionDeclaration' || fnType === 'FunctionExpression') return false;
                if (fnType === 'ArrowFunctionExpression') {
                        const fullFunction = getParentFullFunction(fn);
                        if (fullFunction) {
                                const fullFnType = fullFunction.node.type;
                                if (fullFnType === 'FunctionDeclaration' || fullFnType === 'FunctionExpression') return false;
                        }
                        createExternalVarForThis(fn, state);
                } else if (fnType === 'ClassDeclaration' || fnType === 'ClassExpression') {
                        const {trail} = state;
                        if (trail.length > 6) {
                                const maybeConstructorNode = getProp(fn.node, trail, 3);
                                if (maybeConstructorNode.type === 'ClassMethod' && maybeConstructorNode.kind === 'constructor') {
                                        // In class constructor - need internal var for `this` as `eval()` code might include `super()`
                                        createInternalVarForThis(fn, state);
                                }
                        }
                }

                setSuperIsProtoOnFunctions(superBlock, fn, state);
        }

        activateSuperBinding(superBlock, state);
        return true;
}

1	/* --------------------	62✔
2	* livepack module	62✔
3	* Code instrumentation visitors for `eval`	62✔
4	* ------------------*/	62✔
5		62✔
6	'use strict';	62✔
7		62✔
8	// Export	62✔
9	module.exports = visitEval;	62✔
10		62✔
11	// Modules	62✔
12	const t = require('@babel/types');	62✔
13		62✔
14	// Imports	62✔
15	const {	62✔
16	activateSuperBinding, getParentFullFunction, createInternalVarForThis, createExternalVarForThis,	62✔
17	setSuperIsProtoOnFunctions	62✔
18	} = require('./super.js'),	62✔
19	{getOrCreateExternalVar, activateBlock, activateBinding} = require('../blocks.js'),	62✔
20	{createTempVarNode} = require('../internalVars.js'),	62✔
21	{flagAllAncestorFunctions, copyLocAndComments} = require('../utils.js'),	62✔
22	{isReservedWord, getProp} = require('../../shared/functions.js');	62✔
23		62✔
24	// Exports	62✔
25		62✔
26	/**	62✔
27	* Visit `eval` identifier.	62✔
28	* @param {Object} node - `eval` identifier AST node	62✔
29	* @param {Object\|Array} parent - Parent AST node/container	62✔
30	* @param {string\|number} key - Node's key on parent AST node/container	62✔
31	* @param {Object} state - State object	62✔
32	* @returns {undefined}	62✔
33	*/	62✔
34	function visitEval(node, parent, key, state) {	2,290✔
35	// Flag that `eval()` used in this function and all functions above	2,290✔
36	let isEvalCall = key === 'callee' && parent.type === 'CallExpression';	2,290✔
37	const fn = state.currentFunction;	2,290✔
38	let canUseSuper = false;	2,290✔
39	if (isEvalCall && parent.arguments.length > 0) {	2,290✔
40	// If called with spread element as first arg (`eval(...x)`), acts as indirect `eval`	×
41	if (parent.arguments[0].type === 'SpreadElement') {	✔
42	isEvalCall = false;	×
43	} else {	✔
44	flagAllAncestorFunctions(fn, 'containsEval');	×
45	canUseSuper = activateSuperIfIsUsable(fn, state);	×
46	}	×
47	}	×
48		×
49	// Flag that `eval` is used in file	×
50	state.fileContainsFunctionsOrEval = true;	×
51		×
52	// Queue instrumentation on 2nd pass	×
53	state.secondPass(	×
54	instrumentEval, node, isEvalCall, parent, key, state.currentBlock, fn,	×
55	state.isStrict, canUseSuper, state.currentSuperIsProto, state	×
56	);	×
57	}	×
58		×
59	/**	×
60	* Instrument `eval` - either direct `eval()` or e.g. `x = eval;` / `(0, eval)('...')`.	×
61	* @param {Object} node - `eval` identifier AST node	×
62	* @param {boolean} isEvalCall - `true` if is eval call	×
63	* @param {Object\|Array<Object>} parent - Parent AST node/container	×
64	* @param {string\|number} key - Node's key on parent AST node/container	×
65	* @param {Object} block - Block object for block `eval` is in	×
66	* @param {Object} [fn] - Function object for function `eval` is in (`undefined` if not in a function)	×
67	* @param {boolean} isStrict - `true` if is strict mode	62✔
68	* @param {boolean} canUseSuper - `true` if `super()` can be used in `eval()`	62✔
69	* @param {boolean} superIsProto - `true` if `super` refers to class prototype	62✔
70	* @param {Object} state - State object	62✔
71	* @returns {undefined}	62✔
72	*/	62✔
73	function instrumentEval(	2,290✔
74	node, isEvalCall, parent, key, block, fn, isStrict, canUseSuper, superIsProto, state	2,290✔
75	) {	2,290✔
76	// Check `eval` is global	2,290✔
77	if (!isGlobalEval(block)) return;	2,290!
78		2,290✔
79	// Handle either `eval()` call or `eval` identifier	2,290✔
80	if (isEvalCall) {	2,290✔
81	instrumentEvalCall(parent, block, fn, isStrict, canUseSuper, superIsProto, state);	2,152✔
82	} else {	2,290✔
83	instrumentEvalIdentifier(node, parent, key, state);	138✔
84	}	138✔
85	}	2,290✔
86		62✔
87	/**	62✔
88	* Instrument `eval()` call.	62✔
89	* Convert `eval()` to `livepack_tracker.evalDirect()`.	62✔
90	* Capture all vars which can be accessed by `eval()` and pass details to `evalDirect()`.	62✔
91	* `evalDirect()` will reconstruct the scopes and instrument the `eval()`-ed code.	×
92	* If `eval()` is within a function, flag all vars which `eval()` can access as used by the function.	×
93	*	×
94	* @param {Object} callNode - Call expression AST node	×
95	* @param {Object} block - Block object for block `eval` is in	×
96	* @param {Object} [fn] - Function object for function `eval` is in (`undefined` if not in a function)	×
97	* @param {boolean} isStrict - `true` if is strict mode	×
98	* @param {boolean} canUseSuper - `true` if `super()` can be used in `eval()`	×
99	* @param {boolean} superIsProto - `true` if `super` refers to class prototype	62✔
100	* @param {Object} state - State object	62✔
101	* @returns {undefined}	62✔
102	*/	62✔
103	function instrumentEvalCall(callNode, block, fn, isStrict, canUseSuper, superIsProto, state) {	2,152✔
104	// If no arguments, leave as is	2,152✔
105	const argNodes = callNode.arguments;	2,152✔
106	if (argNodes.length === 0) return;	2,152!
107		2,152✔
108	// Capture all vars in scopes above	2,152✔
109	const scopeNodes = [],	2,152✔
110	varNamesUsed = new Set();	2,152✔
111	let externalVars;	2,152✔
112	do {	2,152✔
113	// Check if block is external to function	11,562✔
114	if (!externalVars && fn && block.id < fn.id) externalVars = fn.externalVars;	11,562✔
115		11,562✔
116	const varDefsNodes = [];	11,562✔
117	for (const [varName, binding] of Object.entries(block.bindings)) {	11,562✔
118	// Freeze binding to prevent var being renamed when used internally in a function.	22,802✔
119	// All vars in scope need to be frozen, even if not accessible to `eval()`	22,802✔
120	// because if they're renamed, they would become accessible to `eval()` when they weren't before.	22,802✔
121	// `this` should not be frozen internally, as it can be replaced with a variable	×
122	// in a class constructor when `super()` is transpiled.	×
123	// For `super` and `new.target`, the var name can't actually be frozen, but flagged here	×
124	// as frozen anyway, to indicate that replacement var name should be prefixed with `_`.	×
125	// Frozen `new.target` is not currently supported.	×
126	// https://github.com/overlookmotel/livepack/issues/448	×
127	if (varName !== 'this') {	✔
128	binding.isFrozenName = true;	×
129	binding.trails.length = 0;	×
130	}	×
131		×
132	// Skip var if it's shadowed by var with same name in higher scope	×
133	if (varNamesUsed.has(varName)) continue;	✔
134		✔
135	// If `eval()` is strict mode, skip vars which are illegal to use in strict mode (e.g. `package`)	×
136	// as `eval()` won't be able to access them	×
137	if (isStrict && varName !== 'this' && varName !== 'super' && isReservedWord(varName)) continue;	✔
138		✔
139	// Ignore `require` as it would render the function containing `eval()` un-serializable.	×
140	// Also ignore CommonJS wrapper function's `arguments` as that contains `require` too.	×
141	if ((varName === 'require' \|\| varName === 'arguments') && block === state.fileBlock) continue;	✔
142		✔
143	// Ignore `super` if it's not accessible	×
144	if (varName === 'super' && !canUseSuper) continue;	×
145		✔
146	varNamesUsed.add(varName);	×
147		×
148	// Create array for var `[varName, isConst, isSilentConst, argNames, tempVarValue]`.	×
149	// NB: Assignment to var called `arguments` or `eval` is illegal in strict mode.	×
150	// This is relevant as it affects whether var is flagged as mutable or not.	×
151	const isConst = binding.isConst \|\| (isStrict && (varName === 'arguments' \|\| varName === 'eval'));	✔
152	const varDefNodes = [t.stringLiteral(varName)];	×
153	if (isConst) varDefNodes.push(t.numericLiteral(1));	✔
154	if (binding.isSilentConst) varDefNodes.push(t.numericLiteral(1));	✔
155	if (binding.argNames) {	✔
156	while (varDefNodes.length !== 3) varDefNodes.push(null);	✔
157	varDefNodes.push(t.arrayExpression(binding.argNames.map(argName => t.stringLiteral(argName))));	✔
158	}	×
159	if (varName === 'super') {	✔
160	while (varDefNodes.length !== 4) varDefNodes.push(null);	✔
161	varDefNodes.push(binding.varNode);	×
162	}	×
163	varDefsNodes.push(t.arrayExpression(varDefNodes));	✔
164		×
165	// If var is external to function, record function as using this var.	×
166	// Ignore `new.target` and `super` as they're not possible to recreate.	×
167	// https://github.com/overlookmotel/livepack/issues/448	×
NEW 168	if (externalVars) {	✔
NEW 169	if (varName === 'new.target' \|\| varName === 'super') {	✔
NEW 170	const externalVar = externalVars.get(block)?.[varName];	✔
NEW 171	if (externalVar) externalVar.isFrozenName = true;	✔
NEW 172	} else {	✔
NEW 173	activateBinding(binding, varName);	×
NEW 174	const externalVar = getOrCreateExternalVar(externalVars, block, varName, binding);	×
NEW 175	externalVar.isReadFrom = true;	×
NEW 176	if (!isConst) externalVar.isAssignedTo = true;	✔
NEW 177	if (!externalVar.isFrozenName) {	✔
NEW 178	externalVar.isFrozenName = true;	×
NEW 179	externalVar.trails.length = 0;	×
NEW 180	}	×
181	}	×
182	}	×
183	}	×
184		×
185	// If some vars from block used, add to scopes definitions	×
186	if (varDefsNodes.length !== 0) {	✔
187	activateBlock(block, state);	×
188		×
189	scopeNodes.push(t.arrayExpression([	×
190	t.numericLiteral(block.id),	×
191	block.name ? t.stringLiteral(block.name) : null,	✔
192	block.varsBlock.scopeIdVarNode,	×
193	...varDefsNodes	×
194	]));	×
195	}	×
196	} while (block = block.parent); // eslint-disable-line no-cond-assign	×
197		×
198	// Replace `eval(x)` with	×
199	// `livepack_tracker.evalDirect(	×
200	// x,	×
201	// eval,	×
202	// livepack_temp_1 => eval(livepack_temp_1),	×
203	// livepack_temp_1 => eval(...livepack_temp_1),	×
204	// [...], // Scope vars	×
205	// true // `isStrict` flag	×
206	// )`	×
207	callNode.callee = copyLocAndComments(	×
208	t.memberExpression(state.trackerVarNode, t.identifier('evalDirect')),	×
209	callNode.callee	×
210	);	×
211		×
212	const tempVarNode = createTempVarNode(state);	×
213	argNodes.push(	×
214	t.identifier('eval'),	×
215	t.arrowFunctionExpression([tempVarNode], t.callExpression(t.identifier('eval'), [tempVarNode])),	×
216	t.arrowFunctionExpression(	×
217	[tempVarNode], t.callExpression(t.identifier('eval'), [t.spreadElement(tempVarNode)])	×
218	),	×
219	t.arrayExpression(scopeNodes.reverse()),	×
220	t.booleanLiteral(isStrict),	×
221	t.booleanLiteral(canUseSuper && superIsProto)	✔
222	);	×
223	}	×
224		×
225	/**	×
226	* Instrument `eval` not used standalone (not as an `eval()` call).	×
227	* Replace `eval` with `livepack_tracker.evalIndirect`.	×
228	* @param {Object} node - `eval` identifier AST node	×
229	* @param {Object\|Array} parent - Parent AST node/container	×
230	* @param {string\|number} key - Node's key on parent AST node/container	×
231	* @param {Object} state - State object	×
232	* @returns {undefined}	×
233	*/	×
234	function instrumentEvalIdentifier(node, parent, key, state) {	138✔
235	parent[key] = copyLocAndComments(	138✔
236	t.memberExpression(state.trackerVarNode, t.identifier('evalIndirect')),	138✔
237	node	138✔
238	);	138✔
239	}	138✔
240		×
241	/**	×
242	* Determine if `eval` identifier refers to global `eval` (not var called `eval` defined in file).	×
243	* @param {Object} block - Block object that `eval` in in.	×
244	* @returns {boolean} - `true` if `eval` is a global var	×
245	*/	×
246	function isGlobalEval(block) {	2,290✔
247	do {	2,290✔
248	if (block.bindings.eval) return false;	13,192!
249	} while (block = block.parent); // eslint-disable-line no-cond-assign	2,290✔
250	return true;	2,290✔
251	}	2,290✔
252		×
253	/**	×
254	* If `super` is usable in this `eval()`, activate `super` block,	×
255	* create an internal / external var for `this`, and set `superIsProto` on function.	×
256	* @param {Object} [fn] - Function object	×
257	* @param {Object} state - State object	×
258	* @returns {boolean} - `true` if `super` is usable	×
259	*/	×
260	function activateSuperIfIsUsable(fn, state) {	2,152✔
261	const superBlock = state.currentSuperBlock;	2,152✔
262	if (!superBlock) return false;	2,152✔
263		336✔
264	// If no function, this code must be within `eval()` and `super` is outside `eval()`, so it is usable	336✔
265	if (fn) {	1,856✔
266	const fnType = fn.node.type;	320✔
267	if (fnType === 'FunctionDeclaration' \|\| fnType === 'FunctionExpression') return false;	320✔
268	if (fnType === 'ArrowFunctionExpression') {	320✔
269	const fullFunction = getParentFullFunction(fn);	12✔
270	if (fullFunction) {	12✔
271	const fullFnType = fullFunction.node.type;	12✔
272	if (fullFnType === 'FunctionDeclaration' \|\| fullFnType === 'FunctionExpression') return false;	12!
273	}	12✔
274	createExternalVarForThis(fn, state);	×
275	} else if (fnType === 'ClassDeclaration' \|\| fnType === 'ClassExpression') {	✔
276	const {trail} = state;	×
277	if (trail.length > 6) {	×
278	const maybeConstructorNode = getProp(fn.node, trail, 3);	×
279	if (maybeConstructorNode.type === 'ClassMethod' && maybeConstructorNode.kind === 'constructor') {	×
280	// In class constructor - need internal var for `this` as `eval()` code might include `super()`	144✔
281	createInternalVarForThis(fn, state);	144✔
282	}	144✔
283	}	144✔
284	}	144✔
285		282✔
286	setSuperIsProtoOnFunctions(superBlock, fn, state);	282✔
287	}	282✔
288		298✔
289	activateSuperBinding(superBlock, state);	298✔
290	return true;	298✔
291	}	×

overlookmotel / livepack / 6973279734

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