6937731401

Committed 21 Nov 2023 12:55AM UTC coverage: 90.36% (-0.1%) from 90.485%

Build # 6937731401

Build Type

push

github

Committed by

overlookmotel

Commit Message

WIP 1

Run Details

4723 of 5073 branches covered (0.0%)

Branch coverage included in aggregate %.

82 of 104 new or added lines in 8 files covered. (78.85%)

17 existing lines in 3 files now uncovered.

12627 of 14128 relevant lines covered (89.38%)

12847.28 hits per line

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

57.52

/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)) {
                        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;

                        // Freeze binding to prevent var being renamed when used internally in a function.
                        // Needs to be frozen even if var is shadowed by another var with same name in deeper nested scope
                        // because otherwise it would become visible to `eval()` when it wasn'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;
                        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 && varName !== 'new.target' && varName !== 'super') {
                                activateBinding(binding, varName);
                                const externalVar = getOrCreateExternalVar(externalVars, block, varName, binding);
                                externalVar.isReadFrom = true;
                                if (!isConst) externalVar.isAssignedTo = true;
                                if (!externalVar.isFrozenName) {
                                        // TODO: Should also do same for all functions above - or should we?
                                        // TODO: Should also set `isFrozenName` for `super` and `new.target`
                                        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) {	1,942✔
35	// Flag that `eval()` used in this function and all functions above	1,942✔
36	let isEvalCall = key === 'callee' && parent.type === 'CallExpression';	1,942✔
37	const fn = state.currentFunction;	1,942✔
38	let canUseSuper = false;	1,942✔
39	if (isEvalCall && parent.arguments.length > 0) {	1,942✔
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(	1,942✔
74	node, isEvalCall, parent, key, block, fn, isStrict, canUseSuper, superIsProto, state	1,942✔
75	) {	1,942✔
76	// Check `eval` is global	1,942✔
77	if (!isGlobalEval(block)) return;	1,942!
78		1,942✔
79	// Handle either `eval()` call or `eval` identifier	1,942✔
80	if (isEvalCall) {	1,942✔
81	instrumentEvalCall(parent, block, fn, isStrict, canUseSuper, superIsProto, state);	1,800✔
82	} else {	1,942✔
83	instrumentEvalIdentifier(node, parent, key, state);	142✔
84	}	142✔
85	}	1,942✔
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) {	1,800✔
104	// If no arguments, leave as is	1,800✔
105	const argNodes = callNode.arguments;	1,800✔
106	if (argNodes.length === 0) return;	1,800!
107		1,800✔
108	// Capture all vars in scopes above	1,800✔
109	const scopeNodes = [],	1,800✔
110	varNamesUsed = new Set();	1,800✔
111	let externalVars;	1,800✔
112	do {	1,800✔
113	// Check if block is external to function	10,058✔
114	if (!externalVars && fn && block.id < fn.id) externalVars = fn.externalVars;	10,058✔
115		10,058✔
116	const varDefsNodes = [];	10,058✔
117	for (const [varName, binding] of Object.entries(block.bindings)) {	10,058✔
118	if (isStrict && varName !== 'this' && varName !== 'super' && isReservedWord(varName)) continue;	18,242✔
119		18,210✔
120	// Ignore `require` as it would render the function containing `eval()` un-serializable.	18,210✔
121	// Also ignore CommonJS wrapper function's `arguments` as that contains `require` too.	18,210✔
122	if ((varName === 'require' \|\| varName === 'arguments') && block === state.fileBlock) continue;	✔
123		✔
124	// Ignore `super` if it's not accessible	×
125	if (varName === 'super' && !canUseSuper) continue;	×
126		✔
NEW 127	// Freeze binding to prevent var being renamed when used internally in a function.	×
NEW 128	// Needs to be frozen even if var is shadowed by another var with same name in deeper nested scope	×
NEW 129	// because otherwise it would become visible to `eval()` when it wasn't before.	×
NEW 130	// `this` should not be frozen internally, as it can be replaced with a variable	×
NEW 131	// in a class constructor when `super()` is transpiled.	×
NEW 132	// For `super` and `new.target`, the var name can't actually be frozen, but flagged here	×
NEW 133	// as frozen anyway, to indicate that replacement var name should be prefixed with `_`.	×
NEW 134	// Frozen `new.target` is not currently supported.	×
NEW 135	// https://github.com/overlookmotel/livepack/issues/448	×
NEW 136	if (varName !== 'this') {	✔
NEW 137	binding.isFrozenName = true;	×
NEW 138	binding.trails.length = 0;	×
NEW 139	}	×
NEW 140		✔
NEW 141	// Skip var if it's shadowed by var with same name in higher scope	×
NEW 142	if (varNamesUsed.has(varName)) continue;	✔
143	varNamesUsed.add(varName);	✔
144		×
145	// Create array for var `[varName, isConst, isSilentConst, argNames, tempVarValue]`.	×
146	// NB: Assignment to var called `arguments` or `eval` is illegal in strict mode.	×
147	// This is relevant as it affects whether var is flagged as mutable or not.	×
148	const isConst = binding.isConst \|\| (isStrict && (varName === 'arguments' \|\| varName === 'eval'));	✔
149	const varDefNodes = [t.stringLiteral(varName)];	×
150	if (isConst) varDefNodes.push(t.numericLiteral(1));	✔
151	if (binding.isSilentConst) varDefNodes.push(t.numericLiteral(1));	✔
152	if (binding.argNames) {	✔
153	while (varDefNodes.length !== 3) varDefNodes.push(null);	✔
154	varDefNodes.push(t.arrayExpression(binding.argNames.map(argName => t.stringLiteral(argName))));	✔
155	}	×
156	if (varName === 'super') {	✔
157	while (varDefNodes.length !== 4) varDefNodes.push(null);	✔
158	varDefNodes.push(binding.varNode);	×
159	}	×
160	varDefsNodes.push(t.arrayExpression(varDefNodes));	✔
161		×
162	// If var is external to function, record function as using this var.	×
163	// Ignore `new.target` and `super` as they're not possible to recreate.	×
164	// https://github.com/overlookmotel/livepack/issues/448	×
165	if (externalVars && varName !== 'new.target' && varName !== 'super') {	✔
166	activateBinding(binding, varName);	×
167	const externalVar = getOrCreateExternalVar(externalVars, block, varName, binding);	×
168	externalVar.isReadFrom = true;	×
169	if (!isConst) externalVar.isAssignedTo = true;	✔
NEW 170	if (!externalVar.isFrozenName) {	✔
NEW 171	// TODO: Should also do same for all functions above - or should we?	×
NEW 172	// TODO: Should also set `isFrozenName` for `super` and `new.target`	×
NEW 173	externalVar.isFrozenName = true;	×
NEW 174	externalVar.trails.length = 0;	×
NEW 175	}	×
176	}	×
177	}	×
178		×
179	// If some vars from block used, add to scopes definitions	×
180	if (varDefsNodes.length !== 0) {	✔
181	activateBlock(block, state);	×
182		×
183	scopeNodes.push(t.arrayExpression([	×
184	t.numericLiteral(block.id),	×
185	block.name ? t.stringLiteral(block.name) : null,	✔
186	block.varsBlock.scopeIdVarNode,	×
187	...varDefsNodes	×
188	]));	×
189	}	×
190	} while (block = block.parent); // eslint-disable-line no-cond-assign	×
191		×
192	// Replace `eval(x)` with	×
193	// `livepack_tracker.evalDirect(	×
194	// x,	×
195	// eval,	×
196	// livepack_temp_1 => eval(livepack_temp_1),	×
197	// livepack_temp_1 => eval(...livepack_temp_1),	×
198	// [...], // Scope vars	×
199	// true // `isStrict` flag	×
200	// )`	×
201	callNode.callee = copyLocAndComments(	×
202	t.memberExpression(state.trackerVarNode, t.identifier('evalDirect')),	×
203	callNode.callee	×
204	);	×
205		×
206	const tempVarNode = createTempVarNode(state);	×
207	argNodes.push(	×
208	t.identifier('eval'),	×
209	t.arrowFunctionExpression([tempVarNode], t.callExpression(t.identifier('eval'), [tempVarNode])),	×
210	t.arrowFunctionExpression(	×
211	[tempVarNode], t.callExpression(t.identifier('eval'), [t.spreadElement(tempVarNode)])	×
212	),	×
213	t.arrayExpression(scopeNodes.reverse()),	×
214	t.booleanLiteral(isStrict),	×
215	t.booleanLiteral(canUseSuper && superIsProto)	✔
216	);	×
217	}	×
218		×
219	/**	×
220	* Instrument `eval` not used standalone (not as an `eval()` call).	×
221	* Replace `eval` with `livepack_tracker.evalIndirect`.	×
222	* @param {Object} node - `eval` identifier AST node	×
223	* @param {Object\|Array} parent - Parent AST node/container	×
224	* @param {string\|number} key - Node's key on parent AST node/container	×
225	* @param {Object} state - State object	×
226	* @returns {undefined}	×
227	*/	×
228	function instrumentEvalIdentifier(node, parent, key, state) {	142✔
229	parent[key] = copyLocAndComments(	142✔
230	t.memberExpression(state.trackerVarNode, t.identifier('evalIndirect')),	142✔
231	node	142✔
232	);	142✔
233	}	142✔
234		×
235	/**	×
236	* Determine if `eval` identifier refers to global `eval` (not var called `eval` defined in file).	×
237	* @param {Object} block - Block object that `eval` in in.	×
238	* @returns {boolean} - `true` if `eval` is a global var	×
239	*/	×
240	function isGlobalEval(block) {	1,942✔
241	do {	1,942✔
242	if (block.bindings.eval) return false;	11,724!
243	} while (block = block.parent); // eslint-disable-line no-cond-assign	1,942✔
244	return true;	1,942✔
245	}	1,942✔
246		×
247	/**	×
248	* If `super` is usable in this `eval()`, activate `super` block,	×
249	* create an internal / external var for `this`, and set `superIsProto` on function.	×
250	* @param {Object} [fn] - Function object	×
251	* @param {Object} state - State object	×
252	* @returns {boolean} - `true` if `super` is usable	×
253	*/	×
254	function activateSuperIfIsUsable(fn, state) {	1,800✔
255	const superBlock = state.currentSuperBlock;	1,800✔
256	if (!superBlock) return false;	1,800✔
257		336✔
258	// If no function, this code must be within `eval()` and `super` is outside `eval()`, so it is usable	336✔
259	if (fn) {	1,504✔
260	const fnType = fn.node.type;	320✔
261	if (fnType === 'FunctionDeclaration' \|\| fnType === 'FunctionExpression') return false;	320✔
262	if (fnType === 'ArrowFunctionExpression') {	320✔
263	const fullFunction = getParentFullFunction(fn);	12✔
264	if (fullFunction) {	12✔
265	const fullFnType = fullFunction.node.type;	12✔
266	if (fullFnType === 'FunctionDeclaration' \|\| fullFnType === 'FunctionExpression') return false;	12!
267	}	×
268	createExternalVarForThis(fn, state);	×
269	} else if (fnType === 'ClassDeclaration' \|\| fnType === 'ClassExpression') {	✔
270	const {trail} = state;	×
271	if (trail.length > 6) {	×
272	const maybeConstructorNode = getProp(fn.node, trail, 3);	×
UNCOV 273	if (maybeConstructorNode.type === 'ClassMethod' && maybeConstructorNode.kind === 'constructor') {	×
274	// In class constructor - need internal var for `this` as `eval()` code might include `super()`	144✔
275	createInternalVarForThis(fn, state);	144✔
276	}	144✔
277	}	144✔
278	}	144✔
279		282✔
280	setSuperIsProtoOnFunctions(superBlock, fn, state);	282✔
281	}	282✔
282		298✔
283	activateSuperBinding(superBlock, state);	298✔
284	return true;	×
285	}	×

overlookmotel / livepack / 6937731401

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