7077920486

Committed 03 Dec 2023 04:01PM UTC coverage: 90.344% (-0.02%) from 90.361%

Build # 7077920486

Build Type

push

github

Committed by

overlookmotel

Commit Message

Don't transpile `super()` in class constructors [fix]

Fixes #541.
Fixes #540.
Fixes #341.

Run Details

4611 of 4962 branches covered (0.0%)

Branch coverage included in aggregate %.

78 of 84 new or added lines in 8 files covered. (92.86%)

57 existing lines in 8 files now uncovered.

12446 of 13918 relevant lines covered (89.42%)

13081.48 hits per line

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

84.78

/lib/instrument/visitors/identifier.js

/* --------------------
 * livepack module
 * Code instrumentation visitors for identifiers
 * ------------------*/

'use strict';

// Export
module.exports = {
        IdentifierReadOnly,
        IdentifierAssignOnly,
        IdentifierReadAndAssign,
        ThisExpression,
        NewTargetExpression
};

// Imports
const visitEval = require('./eval.js'),
        {getOrCreateExternalVar, activateBlock, activateBinding} = require('../blocks.js'),
        {checkInternalVarNameClash} = require('../internalVars.js'),
        {
                CONST_VIOLATION_NEEDS_VAR, CONST_VIOLATION_NEEDS_NO_VAR, CONST_VIOLATION_SILENT
        } = require('../../shared/constants.js');

// Exports

/**
 * Visitor for identifier where only read from e.g. `x + 1`.
 * @param {Object} node - 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 IdentifierReadOnly(node, state, parent, key) {
        const varName = node.name;
        visitIdentifier(node, varName, true, false, state);

        // Handle `eval`
        if (varName === 'eval') visitEval(node, parent, key, state);
}

/**
 * Visitor for identifier where only assigned to e.g. `x = 1`.
 * @param {Object} node - AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function IdentifierAssignOnly(node, state) {
        visitIdentifier(node, node.name, false, true, state);
}

/**
 * Visitor for identifier where both read from and assigned to e.g. `x += 2`.
 * @param {Object} node - AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function IdentifierReadAndAssign(node, state) {
        visitIdentifier(node, node.name, true, true, state);
}

/**
 * Visitor for `this` expression.
 * Record use immediately. No need to wait until 2nd pass as no ambiguity as to where `this` is bound.
 * @param {Object} node - AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function ThisExpression(node, state) {
        const fn = state.currentFunction;
        if (!fn) return;

        // Ignore if `this` is global
        const block = state.currentThisBlock,
                binding = block.bindings.this;
        if (!binding) return;

        // Record as external var use in function. Ignore if internal to function.
        if (block.id < fn.id) {
                recordExternalVar(binding, block, 'this', fn, [...state.trail], true, false, state);
        }
}

/**
 * Visitor for `new.target` expression.
 * Record use immediately. No need to wait until 2nd pass as no ambiguity as to where it's bound.
 * @param {Object} node - AST node
 * @param {Object} state - State object
 * @returns {undefined}
 */
function NewTargetExpression(node, state) {
        // `new.target` can appear outside functions in CommonJS code.
        const fn = state.currentFunction;
        if (!fn) return;

        // Record as external var use in function.
        // NB: No need to check if binding exists, because if it doesn't,
        // parser will have already rejected the code as syntax error.
        const block = state.currentThisBlock;
        if (block.id < fn.id) {
                recordExternalVar(
                        block.bindings['new.target'], block, 'new.target', fn, [...state.trail], true, false, state
                );
        }
}

/**
 * Visit identifier.
 * If identifier is inside a function, schedule resolving the binding var refers to
 * and recording it's usage in parent function in 2nd pass.
 * @param {Object} node - Identifier AST node
 * @param {string} varName - Var name
 * @param {boolean} isReadFrom - `true` if variable is read from e.g. `x + 1`, `x++`
 * @param {boolean} isAssignedTo - `true` if variable is assigned to e.g. `x = 1`, `x++`
 * @param {Object} state - State object
 * @returns {undefined}
 */
function visitIdentifier(node, varName, isReadFrom, isAssignedTo, state) {
        const fn = state.currentFunction;
        if (fn) {
                // Resolve the binding var refers to in 2nd pass
                state.secondPass(
                        resolveIdentifier,
                        node, state.currentBlock, varName, fn, [...state.trail],
                        isReadFrom, isAssignedTo, state.isStrict, state
                );
        } else {
                // Not inside a function, so identifier won't be resolved and therefore misses out
                // on the check in `resolveIdentifier()` if it's a global. So check it here.
                checkInternalVarNameClash(varName, state);
        }
}

/**
 * Resolve binding an identifier refers to and record its usage on function it's used within.
 * @param {Object} node - Identifier AST node (not needed but passed for debug reasons)
 * @param {Object} block - Block object
 * @param {string} varName - Variable name
 * @param {Object} fn - Function object
 * @param {Array<string|number>} trail - Trail
 * @param {boolean} isReadFrom - `true` if variable is read from
 * @param {boolean} isAssignedTo - `true` if variable is assigned to
 * @param {boolean} isStrict - `true` if variable used in strict mode
 * @param {Object} state - State object
 * @returns {undefined}
 */
function resolveIdentifier(node, block, varName, fn, trail, isReadFrom, isAssignedTo, isStrict, state) {
        // Find binding
        let binding;
        do {
                binding = block.bindings[varName];
        } while (!binding && (block = block.parent)); // eslint-disable-line no-cond-assign

        // Record if global var
        if (!binding) {
                // Vars which are local bindings have var name checked for internal var name clashes
                // when the binding is created. But here there's no binding, so need to do the check.
                checkInternalVarNameClash(varName, state);
                fn.globalVarNames.add(varName);
                return;
        }

        // Record if internal var
        if (block.id >= fn.id) {
                if (!binding.isFrozenName) binding.trails.push(trail);
                return;
        }

        // Record external var
        if (isAssignedTo && binding.isConst) {
                // Record const violation.
                // `CONST_VIOLATION_NEEDS_VAR` violation type is for if this const violation is output
                // in a parent function where the const binding is internal to the function,
                // it will need to be added to `internalVars`.
                // This is not the case if var is being read from, as an external var is created below,
                // which will be converted to an internal var.
                // It's also not needed if binding is frozen, as they're not treated as internal vars.
                // Not always possible to know at this point if binding is frozen (it could be frozen
                // by an `eval()` later in the function). So store the binding, and type will be changed
                // to `CONST_VIOLATION_NEEDS_NO_VAR` later on if the binding is frozen.
                fn.amendments.push({
                        type: binding.isSilentConst && !isStrict
                                ? CONST_VIOLATION_SILENT
                                : isReadFrom || binding.isFrozenName
                                        ? CONST_VIOLATION_NEEDS_NO_VAR
                                        : CONST_VIOLATION_NEEDS_VAR,
                        blockId: block.id,
                        trail,
                        binding
                });

                if (!isReadFrom) return;
                isAssignedTo = false;
        }

        recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state);
}

/**
 * Record an external var's usage within a function.
 * @param {Object} binding - Binding object
 * @param {Object} block - Block object
 * @param {string} varName - Variable name
 * @param {Object} fn - Function object
 * @param {Array<string|number>} trail - Trail
 * @param {boolean} isReadFrom - `true` if variable is read from
 * @param {boolean} isAssignedTo - `true` if variable is assigned to
 * @param {Object} state - State object
 * @returns {undefined}
 */
function recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state) {
        activateBlock(block, state);
        activateBinding(binding);
        const externalVar = getOrCreateExternalVar(fn, block, varName, binding);
        if (isReadFrom) externalVar.isReadFrom = true;
        if (isAssignedTo) externalVar.isAssignedTo = true;
        // `new.target` isn't actually frozen so needs trail recorded
        if (!externalVar.isFrozenName || varName === 'new.target') externalVar.trails.push(trail);
}

1	/* --------------------	62✔
2	* livepack module	62✔
3	* Code instrumentation visitors for identifiers	62✔
4	* ------------------*/	62✔
5		62✔
6	'use strict';	62✔
7		62✔
8	// Export	62✔
9	module.exports = {	62✔
10	IdentifierReadOnly,	62✔
11	IdentifierAssignOnly,	62✔
12	IdentifierReadAndAssign,	62✔
13	ThisExpression,	62✔
14	NewTargetExpression	62✔
15	};	62✔
16		62✔
17	// Imports	62✔
18	const visitEval = require('./eval.js'),	62✔
19	{getOrCreateExternalVar, activateBlock, activateBinding} = require('../blocks.js'),	62✔
20	{checkInternalVarNameClash} = require('../internalVars.js'),	62✔
21	{	62✔
22	CONST_VIOLATION_NEEDS_VAR, CONST_VIOLATION_NEEDS_NO_VAR, CONST_VIOLATION_SILENT	62✔
23	} = require('../../shared/constants.js');	62✔
24		62✔
25	// Exports	62✔
26		62✔
27	/**	62✔
28	* Visitor for identifier where only read from e.g. `x + 1`.	62✔
29	* @param {Object} node - AST node	62✔
30	* @param {Object} state - State object	62✔
31	* @param {Object\|Array} parent - Parent AST node/container	62✔
32	* @param {string\|number} key - Node's key on parent AST node/container	62✔
33	* @returns {undefined}	62✔
34	*/	62✔
35	function IdentifierReadOnly(node, state, parent, key) {	179,684✔
36	const varName = node.name;	179,684✔
37	visitIdentifier(node, varName, true, false, state);	179,684✔
38		179,684✔
39	// Handle `eval`	179,684✔
40	if (varName === 'eval') visitEval(node, parent, key, state);	179,684✔
41	}	179,684✔
42		62✔
43	/**	62✔
44	* Visitor for identifier where only assigned to e.g. `x = 1`.	62✔
45	* @param {Object} node - AST node	56✔
46	* @param {Object} state - State object	56✔
47	* @returns {undefined}	56✔
48	*/	56✔
49	function IdentifierAssignOnly(node, state) {	5,318✔
50	visitIdentifier(node, node.name, false, true, state);	5,318✔
51	}	×
52		×
53	/**	×
54	* Visitor for identifier where both read from and assigned to e.g. `x += 2`.	56✔
55	* @param {Object} node - AST node	56✔
56	* @param {Object} state - State object	56✔
57	* @returns {undefined}	56!
58	*/	×
59	function IdentifierReadAndAssign(node, state) {	1,098✔
60	visitIdentifier(node, node.name, true, true, state);	1,098✔
61	}	1,098✔
62		62✔
63	/**	62✔
64	* Visitor for `this` expression.	62✔
65	* Record use immediately. No need to wait until 2nd pass as no ambiguity as to where `this` is bound.	62✔
66	* @param {Object} node - AST node	16✔
67	* @param {Object} state - State object	16✔
68	* @returns {undefined}	16✔
69	*/	16✔
70	function ThisExpression(node, state) {	26,152✔
71	const fn = state.currentFunction;	26,152✔
72	if (!fn) return;	26,152✔
73		25,768✔
74	// Ignore if `this` is global	25,768✔
75	const block = state.currentThisBlock,	25,768✔
76	binding = block.bindings.this;	25,768✔
77	if (!binding) return;	26,152✔
78		25,736✔
79	// Record as external var use in function. Ignore if internal to function.	25,736✔
80	if (block.id < fn.id) {	26,152✔
81	recordExternalVar(binding, block, 'this', fn, [...state.trail], true, false, state);	4✔
82	}	4✔
83	}	4✔
84		4✔
85	/**	4✔
86	* Visitor for `new.target` expression.	4✔
87	* Record use immediately. No need to wait until 2nd pass as no ambiguity as to where it's bound.	4✔
88	* @param {Object} node - AST node	4✔
89	* @param {Object} state - State object	62✔
90	* @returns {undefined}	62✔
91	*/	62✔
92	function NewTargetExpression(node, state) {	160✔
93	// `new.target` can appear outside functions in CommonJS code.	160✔
94	const fn = state.currentFunction;	160✔
95	if (!fn) return;	160✔
96		128✔
97	// Record as external var use in function.	128✔
98	// NB: No need to check if binding exists, because if it doesn't,	4✔
99	// parser will have already rejected the code as syntax error.	4✔
100	const block = state.currentThisBlock;	4✔
UNCOV 101	if (block.id < fn.id) {	✔
102	recordExternalVar(	4✔
103	block.bindings['new.target'], block, 'new.target', fn, [...state.trail], true, false, state	4✔
104	);	2✔
105	}	2✔
106	}	2✔
107		2✔
108	/**	2✔
109	* Visit identifier.	2✔
110	* If identifier is inside a function, schedule resolving the binding var refers to	4!
111	* and recording it's usage in parent function in 2nd pass.	4!
UNCOV 112	* @param {Object} node - Identifier AST node	×
UNCOV 113	* @param {string} varName - Var name	×
114	* @param {boolean} isReadFrom - `true` if variable is read from e.g. `x + 1`, `x++`	62✔
115	* @param {boolean} isAssignedTo - `true` if variable is assigned to e.g. `x = 1`, `x++`	62✔
116	* @param {Object} state - State object	62✔
117	* @returns {undefined}	62✔
118	*/	62✔
119	function visitIdentifier(node, varName, isReadFrom, isAssignedTo, state) {	186,100✔
120	const fn = state.currentFunction;	×
121	if (fn) {	✔
122	// Resolve the binding var refers to in 2nd pass	×
123	state.secondPass(	×
124	resolveIdentifier,	×
125	node, state.currentBlock, varName, fn, [...state.trail],	×
126	isReadFrom, isAssignedTo, state.isStrict, state	×
127	);	×
128	} else {	✔
129	// Not inside a function, so identifier won't be resolved and therefore misses out	×
130	// on the check in `resolveIdentifier()` if it's a global. So check it here.	×
131	checkInternalVarNameClash(varName, state);	×
132	}	×
133	}	×
134		×
135	/**	×
136	* Resolve binding an identifier refers to and record its usage on function it's used within.	×
137	* @param {Object} node - Identifier AST node (not needed but passed for debug reasons)	×
138	* @param {Object} block - Block object	62✔
139	* @param {string} varName - Variable name	62✔
140	* @param {Object} fn - Function object	62✔
141	* @param {Array<string\|number>} trail - Trail	62✔
142	* @param {boolean} isReadFrom - `true` if variable is read from	62✔
143	* @param {boolean} isAssignedTo - `true` if variable is assigned to	62✔
144	* @param {boolean} isStrict - `true` if variable used in strict mode	62✔
145	* @param {Object} state - State object	62✔
146	* @returns {undefined}	62✔
147	*/	62✔
148	function resolveIdentifier(node, block, varName, fn, trail, isReadFrom, isAssignedTo, isStrict, state) {	165,408✔
149	// Find binding	76✔
150	let binding;	76✔
151	do {	76✔
152	binding = block.bindings[varName];	76✔
153	} while (!binding && (block = block.parent)); // eslint-disable-line no-cond-assign	76✔
154		76✔
155	// Record if global var	76✔
156	if (!binding) {	✔
157	// Vars which are local bindings have var name checked for internal var name clashes	76✔
158	// when the binding is created. But here there's no binding, so need to do the check.	6✔
159	checkInternalVarNameClash(varName, state);	6✔
160	fn.globalVarNames.add(varName);	6✔
161	return;	6✔
162	}	6✔
163		6✔
164	// Record if internal var	6✔
165	if (block.id >= fn.id) {	76✔
166	if (!binding.isFrozenName) binding.trails.push(trail);	70✔
167	return;	70✔
168	}	70✔
169		70✔
170	// Record external var	70✔
171	if (isAssignedTo && binding.isConst) {	70✔
172	// Record const violation.	70✔
173	// `CONST_VIOLATION_NEEDS_VAR` violation type is for if this const violation is output	188✔
174	// in a parent function where the const binding is internal to the function,	188✔
175	// it will need to be added to `internalVars`.	188✔
176	// This is not the case if var is being read from, as an external var is created below,	188✔
177	// which will be converted to an internal var.	188✔
178	// It's also not needed if binding is frozen, as they're not treated as internal vars.	188✔
179	// Not always possible to know at this point if binding is frozen (it could be frozen	188✔
180	// by an `eval()` later in the function). So store the binding, and type will be changed	188✔
181	// to `CONST_VIOLATION_NEEDS_NO_VAR` later on if the binding is frozen.	188✔
182	fn.amendments.push({	6✔
183	type: binding.isSilentConst && !isStrict	6✔
184	? CONST_VIOLATION_SILENT	6✔
185	: isReadFrom \|\| binding.isFrozenName	6✔
186	? CONST_VIOLATION_NEEDS_NO_VAR	6✔
187	: CONST_VIOLATION_NEEDS_VAR,	6✔
188	blockId: block.id,	6✔
UNCOV 189	trail,	×
190	binding	×
191	});	×
192		×
193	if (!isReadFrom) return;	✔
194	isAssignedTo = false;	✔
195	}	×
196		✔
197	recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state);	6✔
198	}	6✔
199		6✔
200	/**	6✔
201	* Record an external var's usage within a function.	6✔
202	* @param {Object} binding - Binding object	6✔
203	* @param {Object} block - Block object	6✔
204	* @param {string} varName - Variable name	6✔
205	* @param {Object} fn - Function object	6!
206	* @param {Array<string\|number>} trail - Trail	×
207	* @param {boolean} isReadFrom - `true` if variable is read from	×
208	* @param {boolean} isAssignedTo - `true` if variable is assigned to	×
209	* @param {Object} state - State object	×
210	* @returns {undefined}	×
211	*/	6✔
212	function recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state) {	33,220✔
213	activateBlock(block, state);	33,220✔
214	activateBinding(binding);	33,220✔
215	const externalVar = getOrCreateExternalVar(fn, block, varName, binding);	33,220!
216	if (isReadFrom) externalVar.isReadFrom = true;	33,220✔
217	if (isAssignedTo) externalVar.isAssignedTo = true;	33,220✔
218	// `new.target` isn't actually frozen so needs trail recorded	33,220✔
219	if (!externalVar.isFrozenName \|\| varName === 'new.target') externalVar.trails.push(trail);	33,220✔
220	}	33,220✔

overlookmotel / livepack / 7077920486

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