6864312331

Committed 14 Nov 2023 01:28PM UTC coverage: 90.449% (-0.09%) from 90.535%

Build # 6864312331

Build Type

push

github

Committed by

overlookmotel

Commit Message

Support `super` in arrow functions in `eval()` [fix]

Fixes #308.

Run Details

4685 of 5038 branches covered (0.0%)

Branch coverage included in aggregate %.

15 of 22 new or added lines in 2 files covered. (68.18%)

76 existing lines in 7 files now uncovered.

12617 of 14091 relevant lines covered (89.54%)

12894.85 hits per line

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

59.9

/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 = [],
                functionId = fn ? fn.id : undefined,
                varNamesUsed = new Set();
        let blockIsExternalToFunction = false,
                externalVars;
        do {
                if (!blockIsExternalToFunction && fn && block.id < functionId) {
                        blockIsExternalToFunction = true;
                        externalVars = fn.externalVars;
                }

                const varDefsNodes = [];
                for (const [varName, binding] of Object.entries(block.bindings)) {
                        if (varNamesUsed.has(varName)) continue;
                        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]`.
                        // 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 (blockIsExternalToFunction && varName !== 'new.target' && varName !== 'super') {
                                activateBinding(binding, varName);
                                const externalVar = getOrCreateExternalVar(externalVars, block, varName, binding);
                                externalVar.isReadFrom = true;
                                if (!isConst) externalVar.isAssignedTo = true;
                        }
                }

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

overlookmotel / livepack / 6864312331

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