6956241385

Committed 22 Nov 2023 10:49AM UTC coverage: 90.321% (-0.1%) from 90.47%

Build # 6956241385

Build Type

push

github

Committed by

overlookmotel

Commit Message

WIP 1

Run Details

4746 of 5103 branches covered (0.0%)

Branch coverage included in aggregate %.

182 of 213 new or added lines in 13 files covered. (85.45%)

38 existing lines in 6 files now uncovered.

12667 of 14176 relevant lines covered (89.36%)

12765.83 hits per line

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

85.45

/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 internal/external var use in function.
        // Ignore if internal to function, unless in class constructor or prototype class property
        // of class with super class (where `this` will be substituted when `super()` is transpiled).
        if (block.id < fn.id) {
                recordExternalVar(binding, block, 'this', fn, [...state.trail], true, false, state);
        } else if (fn.hasSuperClass) {
                binding.trails.push([...state.trail]);
        }
}

/**
 * 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 possible to know at this point whether binding is frozen or not (an `eval()` might be 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, varName);
        const externalVar = getOrCreateExternalVar(fn.externalVars, block, varName, binding);
        if (isReadFrom) externalVar.isReadFrom = true;
        if (isAssignedTo) externalVar.isAssignedTo = true;
        if (!externalVar.isFrozenName) 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) {	177,550✔
36	const varName = node.name;	177,550✔
37	visitIdentifier(node, varName, true, false, state);	177,550✔
38		177,550✔
39	// Handle `eval`	177,550✔
40	if (varName === 'eval') visitEval(node, parent, key, state);	177,550✔
41	}	177,550✔
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,152✔
50	visitIdentifier(node, node.name, false, true, state);	5,152✔
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,034✔
60	visitIdentifier(node, node.name, true, true, state);	1,034✔
61	}	1,034✔
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,148✔
71	const fn = state.currentFunction;	26,148✔
72	if (!fn) return;	26,148✔
73		25,764✔
74	// Ignore if `this` is global	25,764✔
75	const block = state.currentThisBlock,	25,764✔
76	binding = block.bindings.this;	25,764✔
77	if (!binding) return;	26,148✔
78		25,732✔
79	// Record as internal/external var use in function.	25,732✔
80	// Ignore if internal to function, unless in class constructor or prototype class property	25,732✔
81	// of class with super class (where `this` will be substituted when `super()` is transpiled).	4✔
82	if (block.id < fn.id) {	4✔
83	recordExternalVar(binding, block, 'this', fn, [...state.trail], true, false, state);	4✔
84	} else if (fn.hasSuperClass) {	26,148✔
85	binding.trails.push([...state.trail]);	276✔
86	}	276✔
87	}	26,148✔
88		62✔
89	/**	62✔
90	* Visitor for `new.target` expression.	62✔
91	* Record use immediately. No need to wait until 2nd pass as no ambiguity as to where it's bound.	62✔
92	* @param {Object} node - AST node	62✔
93	* @param {Object} state - State object	62✔
94	* @returns {undefined}	4✔
95	*/	4✔
96	function NewTargetExpression(node, state) {	160✔
97	// `new.target` can appear outside functions in CommonJS code.	160✔
98	const fn = state.currentFunction;	160✔
99	if (!fn) return;	✔
100		✔
101	// Record as external var use in function.	128✔
102	// NB: No need to check if binding exists, because if it doesn't,	128✔
103	// parser will have already rejected the code as syntax error.	128✔
104	const block = state.currentThisBlock;	128!
105	if (block.id < fn.id) {	160✔
106	recordExternalVar(	104✔
107	block.bindings['new.target'], block, 'new.target', fn, [...state.trail], true, false, state	104✔
108	);	104✔
109	}	104✔
110	}	160✔
111		2✔
112	/**	2✔
113	* Visit identifier.	2✔
114	* If identifier is inside a function, schedule resolving the binding var refers to	4!
115	* and recording it's usage in parent function in 2nd pass.	×
116	* @param {Object} node - Identifier AST node	4✔
117	* @param {string} varName - Var name	2✔
118	* @param {boolean} isReadFrom - `true` if variable is read from e.g. `x + 1`, `x++`	62✔
119	* @param {boolean} isAssignedTo - `true` if variable is assigned to e.g. `x = 1`, `x++`	62✔
120	* @param {Object} state - State object	62✔
121	* @returns {undefined}	62✔
122	*/	62✔
123	function visitIdentifier(node, varName, isReadFrom, isAssignedTo, state) {	183,736✔
124	const fn = state.currentFunction;	×
125	if (fn) {	✔
126	// Resolve the binding var refers to in 2nd pass	×
127	state.secondPass(	×
128	resolveIdentifier,	×
129	node, state.currentBlock, varName, fn, [...state.trail],	×
130	isReadFrom, isAssignedTo, state.isStrict, state	×
131	);	×
132	} else {	✔
133	// Not inside a function, so identifier won't be resolved and therefore misses out	×
134	// on the check in `resolveIdentifier()` if it's a global. So check it here.	×
135	checkInternalVarNameClash(varName, state);	×
136	}	×
137	}	×
138		×
139	/**	×
140	* Resolve binding an identifier refers to and record its usage on function it's used within.	×
141	* @param {Object} node - Identifier AST node (not needed but passed for debug reasons)	×
142	* @param {Object} block - Block object	62✔
143	* @param {string} varName - Variable name	62✔
144	* @param {Object} fn - Function object	62✔
145	* @param {Array<string\|number>} trail - Trail	62✔
146	* @param {boolean} isReadFrom - `true` if variable is read from	62✔
147	* @param {boolean} isAssignedTo - `true` if variable is assigned to	62✔
148	* @param {boolean} isStrict - `true` if variable used in strict mode	62✔
149	* @param {Object} state - State object	62✔
150	* @returns {undefined}	62✔
151	*/	62✔
152	function resolveIdentifier(node, block, varName, fn, trail, isReadFrom, isAssignedTo, isStrict, state) {	163,878✔
153	// Find binding	76✔
154	let binding;	76✔
155	do {	76✔
156	binding = block.bindings[varName];	76✔
157	} while (!binding && (block = block.parent)); // eslint-disable-line no-cond-assign	76✔
158		76✔
159	// Record if global var	76✔
160	if (!binding) {	✔
161	// Vars which are local bindings have var name checked for internal var name clashes	76✔
162	// when the binding is created. But here there's no binding, so need to do the check.	76✔
163	checkInternalVarNameClash(varName, state);	6✔
164	fn.globalVarNames.add(varName);	6✔
165	return;	6✔
166	}	6✔
167		6✔
168	// Record if internal var	6✔
169	if (block.id >= fn.id) {	76✔
170	if (!binding.isFrozenName) binding.trails.push(trail);	70✔
171	return;	70✔
172	}	70✔
173		70✔
174	// Record external var	70✔
175	if (isAssignedTo && binding.isConst) {	70✔
176	// Record const violation.	70✔
177	// `CONST_VIOLATION_NEEDS_VAR` violation type is for if this const violation is output	124✔
178	// in a parent function where the const binding is internal to the function,	124✔
179	// it will need to be added to `internalVars`.	124✔
180	// This is not the case if var is being read from, as an external var is created below,	124✔
181	// which will be converted to an internal var.	124✔
182	// It's also not needed if binding is frozen, as they're not treated as internal vars.	124✔
183	// Not possible to know at this point whether binding is frozen or not (an `eval()` might be later	124✔
184	// in the function), so store the binding, and type will be changed to `CONST_VIOLATION_NEEDS_NO_VAR`	124✔
185	// later on if the binding is frozen.	124✔
186	fn.amendments.push({	6✔
187	type: binding.isSilentConst && !isStrict	6✔
188	? CONST_VIOLATION_SILENT	6✔
189	: isReadFrom \|\| binding.isFrozenName	6✔
190	? CONST_VIOLATION_NEEDS_NO_VAR	6✔
191	: CONST_VIOLATION_NEEDS_VAR,	6✔
192	blockId: block.id,	6✔
193	trail,	6✔
194	binding	6✔
UNCOV 195	});	×
UNCOV 196		×
UNCOV 197	if (!isReadFrom) return;	✔
UNCOV 198	isAssignedTo = false;	✔
UNCOV 199	}	×
UNCOV 200		✔
201	recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state);	6✔
202	}	6✔
203		6✔
204	/**	6✔
205	* Record an external var's usage within a function.	6✔
206	* @param {Object} binding - Binding object	6✔
207	* @param {Object} block - Block object	6✔
208	* @param {string} varName - Variable name	6✔
209	* @param {Object} fn - Function object	6!
UNCOV 210	* @param {Array<string\|number>} trail - Trail	×
UNCOV 211	* @param {boolean} isReadFrom - `true` if variable is read from	×
UNCOV 212	* @param {boolean} isAssignedTo - `true` if variable is assigned to	×
UNCOV 213	* @param {Object} state - State object	×
UNCOV 214	* @returns {undefined}	×
UNCOV 215	*/	×
216	function recordExternalVar(binding, block, varName, fn, trail, isReadFrom, isAssignedTo, state) {	33,100✔
217	activateBlock(block, state);	33,100✔
218	activateBinding(binding, varName);	33,100✔
219	const externalVar = getOrCreateExternalVar(fn.externalVars, block, varName, binding);	33,100!
220	if (isReadFrom) externalVar.isReadFrom = true;	33,100✔
221	if (isAssignedTo) externalVar.isAssignedTo = true;	33,100✔
222	if (!externalVar.isFrozenName) externalVar.trails.push(trail);	33,100✔
223	}	33,100✔

overlookmotel / livepack / 6956241385

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