6785532597

Committed 07 Nov 2023 01:58PM UTC coverage: 90.033% (-0.01%) from 90.047%

Build # 6785532597

Build Type

push

github

Committed by

overlookmotel

Commit Message

WIP 2

Run Details

2810 of 3040 branches covered (0.0%)

Branch coverage included in aggregate %.

27 of 27 new or added lines in 1 file covered. (100.0%)

103 existing lines in 5 files now uncovered.

12835 of 14337 relevant lines covered (89.52%)

6627.9 hits per line

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

79.72

/lib/instrument/visitors/super.js

/* --------------------
 * livepack module
 * Code instrumentation visitor for `super`
 * ------------------*/

'use strict';

// Export
module.exports = {
        Super,
        recordSuper,
        activateSuperBinding,
        createInternalVarForThis,
        createExternalVarForThis,
        setSuperIsProtoOnFunctions,
        getSuperVarNode,
        getParentFullFunction
};

// Imports
const {
                createBindingWithoutNameCheck, getOrCreateExternalVar, activateBlock, createBlockTempVar,
                createInternalVar
        } = require('../blocks.js'),
        {getProp} = require('../../shared/functions.js'),
        {SUPER_CALL, SUPER_EXPRESSION} = require('../../shared/constants.js');

// Exports

/**
 * Visitor for `super`.
 * @param {Object} node - `super` AST node
 * @param {Object} state - State object
 * @param {Object|Array} parent - Parent AST node/container
 * @param {string|number} key - Node's key on parent AST node/container
 * @returns {undefined}
 */
function Super(node, state, parent, key) {
        // Exit if not in a function. Must be inside `eval()` within class or object method.
        const fn = state.currentFunction;
        if (!fn) return;

        // Determine if is `super()` call or other use of `super` and if in a nested arrow function.
        const isSuperCall = key === 'callee' && parent.type === 'CallExpression',
                isInArrowFunction = fn.node.type === 'ArrowFunctionExpression';

        // If `super()` call, check its position within class constructor
        // and determine if transpiled super requires `this$0` var too
        if (isSuperCall) {
                // `super()` call.
                // We must be inside class constructor as `super()` is illegal anywhere else,
                // however could be inside an arrow function nested within the constructor.
                // TODO: Handle `super()` in class constructor params
                const {trail} = state,
                        // `trail[3] === 'body'` ensures `super()` is not in constructor's params
                        isTopLevelStatement = !isInArrowFunction && trail.length === 8 && trail[3] === 'body';
                if (isTopLevelStatement && trail[6] === 'expression') {
                        // Top-level `super()` expression statement in constructor body.
                        // NB: `ExpressionStatement` is only kind of statement node with a key 'expression'.
                        const statementIndex = trail[5];
                        if (statementIndex === getProp(fn.node, trail, 5).length - 1) {
                                // Last statement is `super()` - will be transpiled to `return Reflect.construct(...)`
                                fn.returnsSuper = true;
                        } else if (fn.firstSuperStatementIndex === undefined) {
                                // First `super()` statement - record statement index
                                fn.firstSuperStatementIndex = statementIndex;
                                createInternalVarForThis(fn, state);
                        }
                } else if (
                        // Need to check parent node type as `ThrowStatement` also has an `argument` property
                        isTopLevelStatement && trail[6] === 'argument'
                        && getProp(fn.node, trail, 6).type === 'ReturnStatement'
                ) {
                        // `return super()`
                        fn.returnsSuper = true;
                } else if (isInArrowFunction) {
                        // `super()` appears within a nested arrow function
                        const classFn = getParentFullFunction(fn);
                        if (classFn) classFn.firstSuperStatementIndex = -1;
                        createExternalVarForThis(fn, state);
                } else {
                        // `super()` appears in constructor, but not as top level statement
                        fn.firstSuperStatementIndex = -1;
                        createInternalVarForThis(fn, state);
                }
        } else if (isInArrowFunction) {
                // `super` expression in arrow function
                // TODO: Need to freeze `this` if behind `with` block. This is possible in object methods
                // as they can be sloppy mode.
                createExternalVarForThis(fn, state);

                // If inside class constructor or prototype class property of class with super class,
                // class requires `this$0`. `this$0` not needed in methods.
                const fullFn = getParentFullFunction(fn);
                if (fullFn && fullFn.hasSuperClass) createInternalVarForThis(fullFn, state);
        } else if (fn.hasSuperClass) {
                // `super` expression in class constructor or class property of class with super class
                createInternalVarForThis(fn, state);
        }

        // Create external var for `super`
        // TODO: External var could be interfered with by `with` block. Not sure how to solve this.
        const superBlock = state.currentSuperBlock;
        recordSuper(superBlock, fn, state);

        // Set `superIsProto` on all functions between this one and the `super` target
        setSuperIsProtoOnFunctions(superBlock, fn, state);

        // Schedule recording usage of `super` in 2nd pass
        state.secondPass(recordAmendmentForSuper, node, superBlock, isSuperCall, fn, [...state.trail]);
}

/**
 * Record usage of `super` in function.
 * Activate `super` target binding + create external var for `super` (`super` is always an external var).
 * @param {Object} superBlock - `super` target block
 * @param {Object} fn - Function object
 * @param {Object} state - State object
 * @returns {undefined}
 */
function recordSuper(superBlock, fn, state) {
        const binding = activateSuperBinding(superBlock, state);
        const superExternalVar = getOrCreateExternalVar(fn.externalVars, superBlock, 'super', binding);
        superExternalVar.isReadFrom = true;
}

/**
 * Activate `super` target binding.
 * Create binding for `super` target + a temp var node to have `super` target assigned to it.
 * Binding is created lazily when `super` is encountered - most methods won't use `super`.
 * @param {Object} superBlock - `super` target block object
 * @param {Object} state - State object
 * @returns {Object} - Binding for `super` target
 */
function activateSuperBinding(superBlock, state) {
        activateBlock(superBlock, state);
        let binding = superBlock.bindings.super;
        if (!binding) {
                binding = createBindingWithoutNameCheck(superBlock, 'super', {
                        varNode: createBlockTempVar(superBlock, state),
                        isConst: true
                });
        }
        return binding;
}

/**
 * Create internal var for `this` on function.
 * @param {Object} fn - Function object
 * @param {Object} state - State object
 * @returns {undefined}
 */
function createInternalVarForThis(fn, state) {
        createInternalVar(fn, 'this', state.currentThisBlock.bindings.this, null);
}

/**
 * Create external var for `this` on function.
 * @param {Object} fn - Function object
 * @param {Object} state - State object
 * @returns {undefined}
 */
function createExternalVarForThis(fn, state) {
        const thisBlock = state.currentThisBlock;
        activateBlock(thisBlock, state);
        const thisExternalVar = getOrCreateExternalVar(
                fn.externalVars, thisBlock, 'this', thisBlock.bindings.this
        );
        thisExternalVar.isReadFrom = true;
}

/**
 * Set `superIsProto` on all functions between this one and the `super` target
 * @param {Object} superBlock - `super` target block object
 * @param {Object} fn - Function object
 * @param {Object} state - State object
 * @returns {undefined}
 */
function setSuperIsProtoOnFunctions(superBlock, fn, state) {
        if (!state.currentSuperIsProto) return;

        const superBlockId = superBlock.id;
        while (!fn.superIsProto) {
                fn.superIsProto = true;
                fn = fn.parent;
                if (!fn || fn.id < superBlockId) break;
        }
}

/**
 * Record amendment for `super`.
 * Used in serializer to transpile `super`.
 * Done in 2nd pass so the amendment that's recorded is in correct order relative to other amendments.
 * @param {Object} node - `super` AST node (not needed but passed for debug reasons)
 * @param {Object} superBlock - `super` block object
 * @param {boolean} isSuperCall - `true` if is a `super()` call
 * @param {Object} fn - Function object
 * @param {Array<string|number>} trail - Trail
 * @returns {undefined}
 */
function recordAmendmentForSuper(node, superBlock, isSuperCall, fn, trail) {
        // Record amendment for `super`
        fn.amendments.push({
                type: isSuperCall ? SUPER_CALL : SUPER_EXPRESSION,
                blockId: superBlock.id,
                trail
        });
}

/**
 * Get temp var node for `super` target.
 * @param {Object} superBlock - `super` target block object
 * @returns {Object|undefined} - Temp var identifier AST node, or `undefined` if binding not used
 */
function getSuperVarNode(superBlock) {
        const binding = superBlock.bindings.super;
        return binding ? binding.varNode : undefined;
}

/**
 * Get parent function which is a full function/class.
 * @param {Object} fn - Function object
 * @returns {Object|undefined} - Full function object (or `undefined` if none found)
 */
function getParentFullFunction(fn) {
        do {
                fn = fn.parent;
        } while (fn && fn.node.type === 'ArrowFunctionExpression');
        return fn;
}

1	/* --------------------	32✔
2	* livepack module	32✔
3	* Code instrumentation visitor for `super`	32✔
4	* ------------------*/	32✔
5		32✔
6	'use strict';	32✔
7		32✔
8	// Export	32✔
9	module.exports = {	32✔
10	Super,	32✔
11	recordSuper,	32✔
12	activateSuperBinding,	32✔
13	createInternalVarForThis,	32✔
14	createExternalVarForThis,	32✔
15	setSuperIsProtoOnFunctions,	32✔
16	getSuperVarNode,	32✔
17	getParentFullFunction	32✔
18	};	32✔
19		32✔
20	// Imports	32✔
21	const {	32✔
22	createBindingWithoutNameCheck, getOrCreateExternalVar, activateBlock, createBlockTempVar,	32✔
23	createInternalVar	32✔
24	} = require('../blocks.js'),	32✔
25	{getProp} = require('../../shared/functions.js'),	32✔
26	{SUPER_CALL, SUPER_EXPRESSION} = require('../../shared/constants.js');	32✔
27		32✔
28	// Exports	32✔
29		32✔
30	/**	32✔
31	* Visitor for `super`.	32✔
32	* @param {Object} node - `super` AST node	32✔
33	* @param {Object} state - State object	32✔
34	* @param {Object\|Array} parent - Parent AST node/container	32✔
35	* @param {string\|number} key - Node's key on parent AST node/container	32✔
36	* @returns {undefined}	32✔
37	*/	32✔
38	function Super(node, state, parent, key) {	566✔
39	// Exit if not in a function. Must be inside `eval()` within class or object method.	566✔
40	const fn = state.currentFunction;	566✔
41	if (!fn) return;	566!
42		566✔
43	// Determine if is `super()` call or other use of `super` and if in a nested arrow function.	566✔
44	const isSuperCall = key === 'callee' && parent.type === 'CallExpression',	2✔
45	isInArrowFunction = fn.node.type === 'ArrowFunctionExpression';	2✔
46		2✔
47	// If `super()` call, check its position within class constructor	2✔
48	// and determine if transpiled super requires `this$0` var too	×
49	if (isSuperCall) {	✔
50	// `super()` call.	×
51	// We must be inside class constructor as `super()` is illegal anywhere else,	2✔
52	// however could be inside an arrow function nested within the constructor.	2✔
53	// TODO: Handle `super()` in class constructor params	2!
54	const {trail} = state,	2✔
55	// `trail[3] === 'body'` ensures `super()` is not in constructor's params	2✔
56	isTopLevelStatement = !isInArrowFunction && trail.length === 8 && trail[3] === 'body';	2✔
57	if (isTopLevelStatement && trail[6] === 'expression') {	2✔
58	// Top-level `super()` expression statement in constructor body.	2✔
59	// NB: `ExpressionStatement` is only kind of statement node with a key 'expression'.	2✔
60	const statementIndex = trail[5];	1✔
61	if (statementIndex === getProp(fn.node, trail, 5).length - 1) {	1✔
62	// Last statement is `super()` - will be transpiled to `return Reflect.construct(...)`	1✔
63	fn.returnsSuper = true;	1✔
64	} else if (fn.firstSuperStatementIndex === undefined) {	1✔
65	// First `super()` statement - record statement index	1✔
66	fn.firstSuperStatementIndex = statementIndex;	1✔
67	createInternalVarForThis(fn, state);	1✔
68	}	1✔
69	} else if (	1✔
70	// Need to check parent node type as `ThrowStatement` also has an `argument` property	1✔
71	isTopLevelStatement && trail[6] === 'argument'	1✔
72	&& getProp(fn.node, trail, 6).type === 'ReturnStatement'	1✔
73	) {	1✔
74	// `return super()`	1✔
75	fn.returnsSuper = true;	1✔
76	} else if (isInArrowFunction) {	1!
77	// `super()` appears within a nested arrow function	×
78	const classFn = getParentFullFunction(fn);	×
79	if (classFn) classFn.firstSuperStatementIndex = -1;	1✔
80	createExternalVarForThis(fn, state);	1✔
81	} else {	1✔
82	// `super()` appears in constructor, but not as top level statement	1✔
83	fn.firstSuperStatementIndex = -1;	1✔
84	createInternalVarForThis(fn, state);	1✔
85	}	1!
86	} else if (isInArrowFunction) {	✔
87	// `super` expression in arrow function	×
88	// TODO: Need to freeze `this` if behind `with` block. This is possible in object methods	×
89	// as they can be sloppy mode.	×
90	createExternalVarForThis(fn, state);	×
91		×
92	// If inside class constructor or prototype class property of class with super class,	×
93	// class requires `this$0`. `this$0` not needed in methods.	×
94	const fullFn = getParentFullFunction(fn);	×
95	if (fullFn && fullFn.hasSuperClass) createInternalVarForThis(fullFn, state);	×
96	} else if (fn.hasSuperClass) {	✔
97	// `super` expression in class constructor or class property of class with super class	×
98	createInternalVarForThis(fn, state);	×
99	}	×
100		×
101	// Create external var for `super`	1✔
102	// TODO: External var could be interfered with by `with` block. Not sure how to solve this.	1!
UNCOV 103	const superBlock = state.currentSuperBlock;	×
104	recordSuper(superBlock, fn, state);	×
105		×
106	// Set `superIsProto` on all functions between this one and the `super` target	×
107	setSuperIsProtoOnFunctions(superBlock, fn, state);	×
108		×
109	// Schedule recording usage of `super` in 2nd pass	×
110	state.secondPass(recordAmendmentForSuper, node, superBlock, isSuperCall, fn, [...state.trail]);	×
111	}	×
UNCOV 112		×
UNCOV 113	/**	×
UNCOV 114	* Record usage of `super` in function.	×
115	* Activate `super` target binding + create external var for `super` (`super` is always an external var).	1✔
116	* @param {Object} superBlock - `super` target block	1✔
117	* @param {Object} fn - Function object	2✔
118	* @param {Object} state - State object	2✔
119	* @returns {undefined}	2✔
120	*/	2✔
121	function recordSuper(superBlock, fn, state) {	656✔
122	const binding = activateSuperBinding(superBlock, state);	656✔
123	const superExternalVar = getOrCreateExternalVar(fn.externalVars, superBlock, 'super', binding);	656✔
124	superExternalVar.isReadFrom = true;	656✔
125	}	656✔
126		2✔
127	/**	2✔
128	* Activate `super` target binding.	2✔
129	* Create binding for `super` target + a temp var node to have `super` target assigned to it.	2✔
130	* Binding is created lazily when `super` is encountered - most methods won't use `super`.	32✔
131	* @param {Object} superBlock - `super` target block object	32✔
132	* @param {Object} state - State object	32✔
133	* @returns {Object} - Binding for `super` target	32✔
134	*/	32✔
135	function activateSuperBinding(superBlock, state) {	697✔
136	activateBlock(superBlock, state);	697✔
137	let binding = superBlock.bindings.super;	697✔
138	if (!binding) {	3✔
139	binding = createBindingWithoutNameCheck(superBlock, 'super', {	3✔
140	varNode: createBlockTempVar(superBlock, state),	3✔
141	isConst: true	3✔
142	});	3✔
143	}	×
144	return binding;	×
UNCOV 145	}	×
UNCOV 146		×
UNCOV 147	/**	×
148	* Create internal var for `this` on function.	3✔
149	* @param {Object} fn - Function object	3✔
150	* @param {Object} state - State object	3✔
151	* @returns {undefined}	3✔
152	*/	3✔
153	function createInternalVarForThis(fn, state) {	68✔
154	createInternalVar(fn, 'this', state.currentThisBlock.bindings.this, null);	68✔
155	}	68✔
156		32✔
157	/**	32✔
158	* Create external var for `this` on function.	32✔
159	* @param {Object} fn - Function object	32✔
160	* @param {Object} state - State object	32✔
161	* @returns {undefined}	32✔
162	*/	32✔
163	function createExternalVarForThis(fn, state) {	42✔
164	const thisBlock = state.currentThisBlock;	42✔
165	activateBlock(thisBlock, state);	42✔
166	const thisExternalVar = getOrCreateExternalVar(	42✔
167	fn.externalVars, thisBlock, 'this', thisBlock.bindings.this	42✔
168	);	3✔
169	thisExternalVar.isReadFrom = true;	3✔
170	}	3✔
171		3✔
172	/**	3✔
173	* Set `superIsProto` on all functions between this one and the `super` target	3✔
174	* @param {Object} superBlock - `super` target block object	3✔
UNCOV 175	* @param {Object} fn - Function object	×
176	* @param {Object} state - State object	3✔
177	* @returns {undefined}	3✔
178	*/	3✔
179	function setSuperIsProtoOnFunctions(superBlock, fn, state) {	607✔
180	if (!state.currentSuperIsProto) return;	607✔
181		552✔
182	const superBlockId = superBlock.id;	552✔
183	while (!fn.superIsProto) {	582✔
184	fn.superIsProto = true;	527✔
185	fn = fn.parent;	527✔
186	if (!fn \|\| fn.id < superBlockId) break;	527✔
187	}	527✔
188	}	607✔
189		32✔
190	/**	32✔
191	* Record amendment for `super`.	32✔
192	* Used in serializer to transpile `super`.	32✔
193	* Done in 2nd pass so the amendment that's recorded is in correct order relative to other amendments.	32✔
194	* @param {Object} node - `super` AST node (not needed but passed for debug reasons)	2✔
195	* @param {Object} superBlock - `super` block object	2✔
196	* @param {boolean} isSuperCall - `true` if is a `super()` call	2✔
197	* @param {Object} fn - Function object	32✔
198	* @param {Array<string\|number>} trail - Trail	32✔
199	* @returns {undefined}	32✔
200	*/	32✔
201	function recordAmendmentForSuper(node, superBlock, isSuperCall, fn, trail) {	566✔
202	// Record amendment for `super`	×
203	fn.amendments.push({	×
204	type: isSuperCall ? SUPER_CALL : SUPER_EXPRESSION,	✔
205	blockId: superBlock.id,	×
206	trail	×
207	});	×
208	}	×
209		×
210	/**	×
211	* Get temp var node for `super` target.	×
UNCOV 212	* @param {Object} superBlock - `super` target block object	×
UNCOV 213	* @returns {Object\|undefined} - Temp var identifier AST node, or `undefined` if binding not used	×
UNCOV 214	*/	×
215	function getSuperVarNode(superBlock) {	1,773✔
216	const binding = superBlock.bindings.super;	1,773✔
217	return binding ? binding.varNode : undefined;	1,773✔
218	}	1,773✔
219		32✔
220	/**	32✔
221	* Get parent function which is a full function/class.	32✔
222	* @param {Object} fn - Function object	32✔
223	* @returns {Object\|undefined} - Full function object (or `undefined` if none found)	32✔
224	*/	32✔
225	function getParentFullFunction(fn) {	48✔
226	do {	48✔
227	fn = fn.parent;	59✔
228	} while (fn && fn.node.type === 'ArrowFunctionExpression');	2✔
229	return fn;	2✔
230	}	2✔

overlookmotel / livepack / 6785532597

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