11438993440

Committed 21 Oct 2024 11:18AM UTC coverage: 78.414% (-0.3%) from 78.729%

Build # 11438993440

Build Type

Pull #366

github

Committed by

web-flow

Commit Message

Merge 9d99d05c2 into 1acef8e47

Pull Request Pull Request #366: feat: Detect renderer's deprecations

Run Details

1593 of 2169 branches covered (73.44%)

Branch coverage included in aggregate %.

9 of 23 new or added lines in 2 files covered. (39.13%)

23 existing lines in 2 files now uncovered.

2392 of 2913 relevant lines covered (82.11%)

1580.51 hits per line

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

83.17

/src/linter/ui5Types/amdTranspiler/moduleDeclarationToDefinition.ts

import ts from "typescript";
import {getLogger} from "@ui5/logger";
import {ModuleDeclaration} from "./parseModuleDeclaration.js";
import rewriteExtendCall, {UnsupportedExtendCall} from "./rewriteExtendCall.js";
import {UnsupportedModuleError, toPosStr} from "./util.js";
import pruneNode from "./pruneNode.js";
const {SyntaxKind} = ts;

const log = getLogger("linter:ui5Types:amdTranspiler:moduleDeclarationToDefinition");

export interface ModuleDefinition {
        name?: string;
        body: ts.Statement[];
        imports: ts.ImportDeclaration[];
        oldFactoryBlock?: ts.Block;
        moveComments: [ts.Node, ts.Node][];
}

export default function (
        moduleDeclaration: ModuleDeclaration, sourceFile: ts.SourceFile, nodeFactory: ts.NodeFactory
): ModuleDefinition {
        const {imports, identifiers: importIdentifiers} = collectImports(moduleDeclaration, nodeFactory);
        const {body, oldFactoryBlock, moveComments} =
                getModuleBody(moduleDeclaration, sourceFile, nodeFactory, importIdentifiers);
        /* Ignore module name and export flag for now */
        return {
                imports,
                body,
                oldFactoryBlock,
                moveComments,
        };
}

/** Convert dependencies declaration to import statements:
 * a) If dependencies is an ArrayExpression, extract the values and create import statements.
 *         If factory is a Function extract the names of the parameters and use them for the imports.
 *                 If no parameter is found, assume it's a side effect import.
 *         If factory is an Identifier, derive import identifier names from the import module name for later usage
 * b) If dependencies is an Identifier, abort with an error.
*/
function collectImports(
        moduleDeclaration: ModuleDeclaration,
        nodeFactory: ts.NodeFactory
): {imports: ts.ImportDeclaration[]; identifiers: ts.Identifier[]} {
        const imports: ts.ImportDeclaration[] = [];
        const identifiers: ts.Identifier[] = [];
        if (!moduleDeclaration.dependencies) {
                // No dependencies declared
                return {imports, identifiers};
        }

        let factoryParams: ts.Identifier[] | undefined;
        let factoryRequiresCallWrapper = false;
        if (moduleDeclaration.factory) {
                if (ts.isFunctionExpression(moduleDeclaration.factory) ||
                        ts.isArrowFunction(moduleDeclaration.factory) ||
                        ts.isFunctionDeclaration(moduleDeclaration.factory)) {
                        // Extract parameter names
                        factoryParams = moduleDeclaration.factory.parameters.map((param) => {
                                if (!ts.isIdentifier(param.name)) {
                                        // Indicates destructuring in factory signature. This is not (yet?) supported
                                        throw new UnsupportedModuleError(
                                                `Unexpected parameter type ${ts.SyntaxKind[param.kind]} ` +
                                                `at ${toPosStr(param)}`);
                                }
                                return param.name;
                        });
                } else if (ts.isIdentifier(moduleDeclaration.factory)) {
                        factoryRequiresCallWrapper = true;
                }
        }

        if (ts.isIdentifier(moduleDeclaration.dependencies)) {
                throw new UnsupportedModuleError(`Unable to determine dependencies for module. Can't parse variable at ` +
                        `${toPosStr(moduleDeclaration.dependencies)}`);
        }

        // Create import statements based on factory parameters
        moduleDeclaration.dependencies.elements.forEach((dep, i) => {
                // Create import statements
                let moduleSpecifier: ts.StringLiteral;
                if (!ts.isStringLiteralLike(dep)) {
                        log.verbose(`Skipping non-string dependency entry of type ${ts.SyntaxKind[dep.kind]} at ` +
                                toPosStr(dep));
                        return;
                }
                if (ts.isNoSubstitutionTemplateLiteral(dep)) {
                        moduleSpecifier = nodeFactory.createStringLiteral(dep.text);
                        // Set range to the original range to preserve source mapping capability
                        ts.setTextRange(moduleSpecifier, dep);
                } else {
                        moduleSpecifier = dep;
                }
                let identifier: ts.Identifier | undefined;
                if (factoryRequiresCallWrapper) {
                        // Generate variable name based on import module
                        // Later this variable will be used to call the factory function
                        identifier = nodeFactory.createUniqueName(dep.text.replace(/[^a-zA-Z0-9]/g, "_"));
                } else if (factoryParams?.[i]) {
                        // Use factory parameter identifier as import identifier
                        identifier = factoryParams[i];
                } // else: Side effect imports. No identifier needed

                let importClause;
                if (identifier) {
                        identifiers.push(identifier);
                        importClause = nodeFactory.createImportClause(false, identifier, undefined);
                }

                imports.push(nodeFactory.createImportDeclaration(
                        undefined,
                        importClause,
                        moduleSpecifier
                ));
        });
        pruneNode(moduleDeclaration.dependencies);

        return {imports, identifiers};
}

/** Convert factory to module body:
 *         a) If factory is a FunctionExpression or ArrowFunctionExpression, extract the body and create default
 *                 export for it's return value
 *         b) If factory is any other kind of _value_, use it directly
 *         c) If factory is an Identifier, create a function and call it with all dependencies
 *
 * Then create default export:
 *         a) If factory body contains a single return statement, use its argument for the default export
 *         b) If factory body contains multiple return statements, wrap the whole body
 *                 in a function and use that for the default export
 */
function getModuleBody(
        moduleDeclaration: ModuleDeclaration,
        sourceFile: ts.SourceFile,
        nodeFactory: ts.NodeFactory,
        importIdentifiers: ts.Identifier[]
): {body: ts.Statement[]; oldFactoryBlock?: ts.Block; moveComments: [ts.Node, ts.Node][]} {
        if (!moduleDeclaration.factory) {
                return {body: [], moveComments: []};
        }
        let oldFactoryBlock: ts.Block | undefined;
        let body: ts.Statement[];
        const moveComments: [ts.Node, ts.Node][] = [];
        if ((ts.isFunctionExpression(moduleDeclaration.factory) ||
                ts.isArrowFunction(moduleDeclaration.factory) ||
                ts.isFunctionDeclaration(moduleDeclaration.factory))) {
                if (!moduleDeclaration.factory.body) {
                        // Empty function body, no export
                        body = [];
                } else if (ts.isBlock(moduleDeclaration.factory.body)) {
                        const factoryBody = moduleDeclaration.factory.body.statements;
                        /* Convert factory to module body:
                                a) If body contains a single return statement, add all nodes to body but wrap
                                        the return statement's argument with a default export
                                b) If body contains multiple return statements, wrap body in an iife
                                        use that for the body, wrapped in a default export declaration
                        */

                        const returnStatements = collectReturnStatementsInScope(moduleDeclaration.factory, 2);
                        if (returnStatements.length > 1) {
                                log.verbose(`Multiple return statements found in factory at ${toPosStr(moduleDeclaration.factory)}`);
                                let factoryCall: ts.CallExpression;
                                if (ts.isFunctionExpression(moduleDeclaration.factory) ||
                                        ts.isArrowFunction(moduleDeclaration.factory)) {
                                        // Wrap factory in iife
                                        factoryCall = nodeFactory.createCallExpression(
                                                moduleDeclaration.factory, undefined, importIdentifiers);
                                } else if (ts.isFunctionDeclaration(moduleDeclaration.factory) && moduleDeclaration.factory.name) {
                                        // Call the declaration
                                        factoryCall = nodeFactory.createCallExpression(
                                                moduleDeclaration.factory.name, undefined, importIdentifiers);
                                } else {
                                        throw new UnsupportedModuleError(
                                                `Unable to call factory of type ${ts.SyntaxKind[moduleDeclaration.factory.kind]} at ` +
                                                toPosStr(moduleDeclaration.factory));
                                }
                                body = [createDefaultExport(nodeFactory, factoryCall)];
                        } else {
                                oldFactoryBlock = moduleDeclaration.factory.body;
                                body = [];
                                // One return statement in scope
                                for (const node of factoryBody) {
                                        if (ts.isReturnStatement(node) && node.expression) {
                                                if (ts.isCallExpression(node.expression)) {
                                                        try {
                                                                const classDeclaration = rewriteExtendCall(nodeFactory,
                                                                        node.expression, [
                                                                                nodeFactory.createToken(ts.SyntaxKind.ExportKeyword),
                                                                                nodeFactory.createToken(ts.SyntaxKind.DefaultKeyword),
                                                                        ]);
                                                                body.push(classDeclaration);
                                                                moveComments.push([node, classDeclaration]);
                                                        } catch (err) {
                                                                if (err instanceof UnsupportedExtendCall) {
                                                                        log.verbose(`Failed to transform extend call: ${err.message}`);
                                                                        body.push(createDefaultExport(nodeFactory, node.expression));
                                                                } else {
                                                                        throw err;
                                                                }
                                                        }
                                                } else {
                                                        const defaultExport = createDefaultExport(nodeFactory, node.expression);
                                                        body.push(defaultExport);
                                                        moveComments.push([node, defaultExport]);
                                                        // body.push(factory.createExportAssignment(undefined, undefined,
                                                        //         node.expression));
                                                }
                                        } else if (ts.isExpressionStatement(node) && ts.isStringLiteral(node.expression) &&
                                                node.expression.text === "use strict") {
                                                // Ignore "use strict" directive
                                                continue;
                                        } else {
                                                body.push(node);
                                        }
                                }

                                pruneNode(moduleDeclaration.factory);
                        }
                } else if (ts.isCallExpression(moduleDeclaration.factory.body)) {
                        // Arrow function with expression body
                        try {
                                const classDeclaration = rewriteExtendCall(nodeFactory,
                                        moduleDeclaration.factory.body, [
                                                nodeFactory.createToken(ts.SyntaxKind.ExportKeyword),
                                                nodeFactory.createToken(ts.SyntaxKind.DefaultKeyword),
                                        ]);
                                body = [classDeclaration];
                        } catch (err) {
                                if (err instanceof UnsupportedExtendCall) {
                                        log.verbose(`Failed to transform extend call: ${err.message}`);
                                        body = [createDefaultExport(nodeFactory, moduleDeclaration.factory.body)];
                                } else {
                                        throw err;
                                }
                        }
                } else {
                        // Export expression directly
                        body = [createDefaultExport(nodeFactory, moduleDeclaration.factory.body)];
                }
        } else if (ts.isClassDeclaration(moduleDeclaration.factory) ||
                ts.isLiteralExpression(moduleDeclaration.factory) ||
                ts.isArrayLiteralExpression(moduleDeclaration.factory) ||
                ts.isObjectLiteralExpression(moduleDeclaration.factory) ||
                ts.isPropertyAccessExpression(moduleDeclaration.factory)) {
                // Use factory directly
                body = [createDefaultExport(nodeFactory, moduleDeclaration.factory)];
        } else { // Identifier
                throw new Error(`FIXME: Unsupported factory type ${ts.SyntaxKind[moduleDeclaration.factory.kind]} at ` +
                        toPosStr(moduleDeclaration.factory));
        }
        return {body, oldFactoryBlock, moveComments};
}

/**
 * Collect all return statements in the provided node's function scope
 */
function collectReturnStatementsInScope(node: ts.Node, maxCount?: number): ts.ReturnStatement[] {
        const returnStatements: ts.ReturnStatement[] = [];
        function visitNode(node: ts.Node) {
                switch (node.kind) {
                        case SyntaxKind.ReturnStatement:
                                returnStatements.push(node as ts.ReturnStatement);
                                return;

                                // Do not traverse into nodes that declare a new function scope
                        case SyntaxKind.FunctionDeclaration:
                        case SyntaxKind.FunctionExpression:
                        case SyntaxKind.ArrowFunction:
                        case SyntaxKind.MethodDeclaration:
                        case SyntaxKind.ModuleDeclaration:
                        case SyntaxKind.Constructor:
                        case SyntaxKind.SetAccessor:
                        case SyntaxKind.GetAccessor:
                                return;
                }
                if (maxCount && returnStatements.length >= maxCount) {
                        return;
                }
                ts.forEachChild(node, visitNode);
        }

        ts.forEachChild(node, visitNode);
        return returnStatements;
}

function createDefaultExport(factory: ts.NodeFactory, node: ts.Node): ts.Statement {
        if (ts.isLiteralExpression(node)) {
                // Use factory directly
                return factory.createExportAssignment(undefined, undefined, node);
        }
        const exportModifiers = [
                factory.createToken(ts.SyntaxKind.ExportKeyword),
                factory.createToken(ts.SyntaxKind.DefaultKeyword),
        ];
        switch (node.kind) {
                case SyntaxKind.CallExpression:
                case SyntaxKind.ArrayLiteralExpression:
                case SyntaxKind.ObjectLiteralExpression:
                case SyntaxKind.ArrowFunction:
                case SyntaxKind.Identifier:
                case SyntaxKind.PropertyAccessExpression:
                        return factory.createExportAssignment(undefined, undefined, node as ts.Expression);
                case SyntaxKind.ClassDeclaration:
                        return factory.updateClassDeclaration(
                                (node as ts.ClassDeclaration),
                                exportModifiers,
                                (node as ts.ClassDeclaration).name,
                                (node as ts.ClassDeclaration).typeParameters,
                                (node as ts.ClassDeclaration).heritageClauses,
                                (node as ts.ClassDeclaration).members);
                case SyntaxKind.FunctionDeclaration:
                        return factory.updateFunctionDeclaration(
                                (node as ts.FunctionDeclaration),
                                exportModifiers,
                                (node as ts.FunctionDeclaration).asteriskToken,
                                (node as ts.FunctionDeclaration).name,
                                (node as ts.FunctionDeclaration).typeParameters,
                                (node as ts.FunctionDeclaration).parameters,
                                (node as ts.FunctionDeclaration).type,
                                (node as ts.FunctionDeclaration).body);
                case SyntaxKind.FunctionExpression:
                        return factory.createFunctionDeclaration(
                                exportModifiers,
                                (node as ts.FunctionExpression).asteriskToken,
                                (node as ts.FunctionExpression).name,
                                (node as ts.FunctionExpression).typeParameters,
                                (node as ts.FunctionExpression).parameters,
                                (node as ts.FunctionExpression).type,
                                (node as ts.FunctionExpression).body);
                default:
                        throw new UnsupportedModuleError(
                                `Unable to create default export assignment for node of type ${SyntaxKind[node.kind]} at ` +
                                toPosStr(node));
        }
}

1	import ts from "typescript";
2	import {getLogger} from "@ui5/logger";
3	import {ModuleDeclaration} from "./parseModuleDeclaration.js";
4	import rewriteExtendCall, {UnsupportedExtendCall} from "./rewriteExtendCall.js";
5	import {UnsupportedModuleError, toPosStr} from "./util.js";
6	import pruneNode from "./pruneNode.js";
7	const {SyntaxKind} = ts;	10✔
8
9	const log = getLogger("linter:ui5Types:amdTranspiler:moduleDeclarationToDefinition");	10✔
10
11	export interface ModuleDefinition {
12	name?: string;
13	body: ts.Statement[];
14	imports: ts.ImportDeclaration[];
15	oldFactoryBlock?: ts.Block;
16	moveComments: [ts.Node, ts.Node][];
17	}
18
19	export default function (
20	moduleDeclaration: ModuleDeclaration, sourceFile: ts.SourceFile, nodeFactory: ts.NodeFactory
21	): ModuleDefinition {
22	const {imports, identifiers: importIdentifiers} = collectImports(moduleDeclaration, nodeFactory);	156✔
23	const {body, oldFactoryBlock, moveComments} =
24	getModuleBody(moduleDeclaration, sourceFile, nodeFactory, importIdentifiers);	156✔
25	/* Ignore module name and export flag for now */
26	return {	156✔
27	imports,
28	body,
29	oldFactoryBlock,
30	moveComments,
31	};
32	}
33
34	/** Convert dependencies declaration to import statements:
35	* a) If dependencies is an ArrayExpression, extract the values and create import statements.
36	* If factory is a Function extract the names of the parameters and use them for the imports.
37	* If no parameter is found, assume it's a side effect import.
38	* If factory is an Identifier, derive import identifier names from the import module name for later usage
39	* b) If dependencies is an Identifier, abort with an error.
40	*/
41	function collectImports(
42	moduleDeclaration: ModuleDeclaration,
43	nodeFactory: ts.NodeFactory
44	): {imports: ts.ImportDeclaration[]; identifiers: ts.Identifier[]} {
45	const imports: ts.ImportDeclaration[] = [];	156✔
46	const identifiers: ts.Identifier[] = [];	156✔
47	if (!moduleDeclaration.dependencies) {	156✔
48	// No dependencies declared
49	return {imports, identifiers};	13✔
50	}
51
52	let factoryParams: ts.Identifier[] \| undefined;
53	let factoryRequiresCallWrapper = false;	143✔
54	if (moduleDeclaration.factory) {	143✔
55	if (ts.isFunctionExpression(moduleDeclaration.factory) \|\|	141✔
56	ts.isArrowFunction(moduleDeclaration.factory) \|\|
57	ts.isFunctionDeclaration(moduleDeclaration.factory)) {
58	// Extract parameter names
59	factoryParams = moduleDeclaration.factory.parameters.map((param) => {	140✔
60	if (!ts.isIdentifier(param.name)) {	255!
61	// Indicates destructuring in factory signature. This is not (yet?) supported
62	throw new UnsupportedModuleError(	×
63	`Unexpected parameter type ${ts.SyntaxKind[param.kind]} ` +
64	`at ${toPosStr(param)}`);
65	}
66	return param.name;	255✔
67	});
68	} else if (ts.isIdentifier(moduleDeclaration.factory)) {	1!
69	factoryRequiresCallWrapper = true;	×
70	}
71	}
72
73	if (ts.isIdentifier(moduleDeclaration.dependencies)) {	143!
74	throw new UnsupportedModuleError(`Unable to determine dependencies for module. Can't parse variable at ` +	×
75	`${toPosStr(moduleDeclaration.dependencies)}`);
76	}
77
78	// Create import statements based on factory parameters
79	moduleDeclaration.dependencies.elements.forEach((dep, i) => {	143✔
80	// Create import statements
81	let moduleSpecifier: ts.StringLiteral;
82	if (!ts.isStringLiteralLike(dep)) {	290✔
83	log.verbose(`Skipping non-string dependency entry of type ${ts.SyntaxKind[dep.kind]} at ` +	1✔
84	toPosStr(dep));
85	return;	1✔
86	}
87	if (ts.isNoSubstitutionTemplateLiteral(dep)) {	289✔
88	moduleSpecifier = nodeFactory.createStringLiteral(dep.text);	2✔
89	// Set range to the original range to preserve source mapping capability
90	ts.setTextRange(moduleSpecifier, dep);	2✔
91	} else {
92	moduleSpecifier = dep;	287✔
93	}
94	let identifier: ts.Identifier \| undefined;
95	if (factoryRequiresCallWrapper) {	289!
96	// Generate variable name based on import module
97	// Later this variable will be used to call the factory function
98	identifier = nodeFactory.createUniqueName(dep.text.replace(/[^a-zA-Z0-9]/g, "_"));	×
99	} else if (factoryParams?.[i]) {	289✔
100	// Use factory parameter identifier as import identifier
101	identifier = factoryParams[i];	253✔
102	} // else: Side effect imports. No identifier needed
103
104	let importClause;
105	if (identifier) {	289✔
106	identifiers.push(identifier);	253✔
107	importClause = nodeFactory.createImportClause(false, identifier, undefined);	253✔
108	}
109
110	imports.push(nodeFactory.createImportDeclaration(	289✔
111	undefined,
112	importClause,
113	moduleSpecifier
114	));
115	});
116	pruneNode(moduleDeclaration.dependencies);	143✔
117
118	return {imports, identifiers};	143✔
119	}
120
121	/** Convert factory to module body:
122	* a) If factory is a FunctionExpression or ArrowFunctionExpression, extract the body and create default
123	* export for it's return value
124	* b) If factory is any other kind of _value_, use it directly
125	* c) If factory is an Identifier, create a function and call it with all dependencies
126	*
127	* Then create default export:
128	* a) If factory body contains a single return statement, use its argument for the default export
129	* b) If factory body contains multiple return statements, wrap the whole body
130	* in a function and use that for the default export
131	*/
132	function getModuleBody(
133	moduleDeclaration: ModuleDeclaration,
134	sourceFile: ts.SourceFile,
135	nodeFactory: ts.NodeFactory,
136	importIdentifiers: ts.Identifier[]
137	): {body: ts.Statement[]; oldFactoryBlock?: ts.Block; moveComments: [ts.Node, ts.Node][]} {
138	if (!moduleDeclaration.factory) {	156✔
139	return {body: [], moveComments: []};	5✔
140	}
141	let oldFactoryBlock: ts.Block \| undefined;
142	let body: ts.Statement[];
143	const moveComments: [ts.Node, ts.Node][] = [];	151✔
144	if ((ts.isFunctionExpression(moduleDeclaration.factory) \|\|	151✔
145	ts.isArrowFunction(moduleDeclaration.factory) \|\|
146	ts.isFunctionDeclaration(moduleDeclaration.factory))) {
147	if (!moduleDeclaration.factory.body) {	149!
148	// Empty function body, no export
149	body = [];	×
150	} else if (ts.isBlock(moduleDeclaration.factory.body)) {	149✔
151	const factoryBody = moduleDeclaration.factory.body.statements;	148✔
152	/* Convert factory to module body:
153	a) If body contains a single return statement, add all nodes to body but wrap
154	the return statement's argument with a default export
155	b) If body contains multiple return statements, wrap body in an iife
156	use that for the body, wrapped in a default export declaration
157	*/
158
159	const returnStatements = collectReturnStatementsInScope(moduleDeclaration.factory, 2);	148✔
160	if (returnStatements.length > 1) {	148✔
161	log.verbose(`Multiple return statements found in factory at ${toPosStr(moduleDeclaration.factory)}`);	5✔
162	let factoryCall: ts.CallExpression;
163	if (ts.isFunctionExpression(moduleDeclaration.factory) \|\|	5✔
164	ts.isArrowFunction(moduleDeclaration.factory)) {
165	// Wrap factory in iife
166	factoryCall = nodeFactory.createCallExpression(	4✔
167	moduleDeclaration.factory, undefined, importIdentifiers);
168	} else if (ts.isFunctionDeclaration(moduleDeclaration.factory) && moduleDeclaration.factory.name) {	1!
169	// Call the declaration
170	factoryCall = nodeFactory.createCallExpression(	1✔
171	moduleDeclaration.factory.name, undefined, importIdentifiers);
172	} else {
UNCOV 173	throw new UnsupportedModuleError(	×
174	`Unable to call factory of type ${ts.SyntaxKind[moduleDeclaration.factory.kind]} at ` +
175	toPosStr(moduleDeclaration.factory));
176	}
177	body = [createDefaultExport(nodeFactory, factoryCall)];	5✔
178	} else {
179	oldFactoryBlock = moduleDeclaration.factory.body;	143✔
180	body = [];	143✔
181	// One return statement in scope
182	for (const node of factoryBody) {	143✔
183	if (ts.isReturnStatement(node) && node.expression) {	391✔
184	if (ts.isCallExpression(node.expression)) {	114✔
185	try {	72✔
186	const classDeclaration = rewriteExtendCall(nodeFactory,	72✔
187	node.expression, [
188	nodeFactory.createToken(ts.SyntaxKind.ExportKeyword),
189	nodeFactory.createToken(ts.SyntaxKind.DefaultKeyword),
190	]);
191	body.push(classDeclaration);	69✔
192	moveComments.push([node, classDeclaration]);	69✔
193	} catch (err) {
194	if (err instanceof UnsupportedExtendCall) {	3!
195	log.verbose(`Failed to transform extend call: ${err.message}`);	3✔
196	body.push(createDefaultExport(nodeFactory, node.expression));	3✔
197	} else {
198	throw err;	×
199	}
200	}
201	} else {
202	const defaultExport = createDefaultExport(nodeFactory, node.expression);	42✔
203	body.push(defaultExport);	42✔
204	moveComments.push([node, defaultExport]);	42✔
205	// body.push(factory.createExportAssignment(undefined, undefined,
206	// node.expression));
207	}
208	} else if (ts.isExpressionStatement(node) && ts.isStringLiteral(node.expression) &&	277✔
209	node.expression.text === "use strict") {
210	// Ignore "use strict" directive
211	continue;	110✔
212	} else {
213	body.push(node);	167✔
214	}
215	}
216
217	pruneNode(moduleDeclaration.factory);	143✔
218	}
219	} else if (ts.isCallExpression(moduleDeclaration.factory.body)) {	1!
220	// Arrow function with expression body
221	try {	1✔
222	const classDeclaration = rewriteExtendCall(nodeFactory,	1✔
223	moduleDeclaration.factory.body, [
224	nodeFactory.createToken(ts.SyntaxKind.ExportKeyword),
225	nodeFactory.createToken(ts.SyntaxKind.DefaultKeyword),
226	]);
227	body = [classDeclaration];	1✔
228	} catch (err) {
229	if (err instanceof UnsupportedExtendCall) {	×
230	log.verbose(`Failed to transform extend call: ${err.message}`);	×
231	body = [createDefaultExport(nodeFactory, moduleDeclaration.factory.body)];	×
232	} else {
233	throw err;	×
234	}
235	}
236	} else {
237	// Export expression directly
238	body = [createDefaultExport(nodeFactory, moduleDeclaration.factory.body)];	×
239	}
240	} else if (ts.isClassDeclaration(moduleDeclaration.factory) \|\|	2!
241	ts.isLiteralExpression(moduleDeclaration.factory) \|\|
242	ts.isArrayLiteralExpression(moduleDeclaration.factory) \|\|
243	ts.isObjectLiteralExpression(moduleDeclaration.factory) \|\|
244	ts.isPropertyAccessExpression(moduleDeclaration.factory)) {
245	// Use factory directly
246	body = [createDefaultExport(nodeFactory, moduleDeclaration.factory)];	2✔
247	} else { // Identifier
248	throw new Error(`FIXME: Unsupported factory type ${ts.SyntaxKind[moduleDeclaration.factory.kind]} at ` +	×
249	toPosStr(moduleDeclaration.factory));
250	}
251	return {body, oldFactoryBlock, moveComments};	151✔
252	}
253
254	/**
255	* Collect all return statements in the provided node's function scope
256	*/
257	function collectReturnStatementsInScope(node: ts.Node, maxCount?: number): ts.ReturnStatement[] {
258	const returnStatements: ts.ReturnStatement[] = [];	148✔
259	function visitNode(node: ts.Node) {
260	switch (node.kind) {	3,123✔
261	case SyntaxKind.ReturnStatement:
262	returnStatements.push(node as ts.ReturnStatement);	124✔
263	return;	124✔
264
265	// Do not traverse into nodes that declare a new function scope
266	case SyntaxKind.FunctionDeclaration:
267	case SyntaxKind.FunctionExpression:
268	case SyntaxKind.ArrowFunction:
269	case SyntaxKind.MethodDeclaration:
270	case SyntaxKind.ModuleDeclaration:
271	case SyntaxKind.Constructor:
272	case SyntaxKind.SetAccessor:
273	case SyntaxKind.GetAccessor:
274	return;	62✔
275	}
276	if (maxCount && returnStatements.length >= maxCount) {	2,937!
277	return;	×
278	}
279	ts.forEachChild(node, visitNode);	2,937✔
280	}
281
282	ts.forEachChild(node, visitNode);	148✔
283	return returnStatements;	148✔
284	}
285
286	function createDefaultExport(factory: ts.NodeFactory, node: ts.Node): ts.Statement {
287	if (ts.isLiteralExpression(node)) {	52!
288	// Use factory directly
289	return factory.createExportAssignment(undefined, undefined, node);	×
290	}
291	const exportModifiers = [	52✔
292	factory.createToken(ts.SyntaxKind.ExportKeyword),
293	factory.createToken(ts.SyntaxKind.DefaultKeyword),
294	];
295	switch (node.kind) {	52!
296	case SyntaxKind.CallExpression:
297	case SyntaxKind.ArrayLiteralExpression:
298	case SyntaxKind.ObjectLiteralExpression:
299	case SyntaxKind.ArrowFunction:
300	case SyntaxKind.Identifier:
301	case SyntaxKind.PropertyAccessExpression:
302	return factory.createExportAssignment(undefined, undefined, node as ts.Expression);	49✔
303	case SyntaxKind.ClassDeclaration:
304	return factory.updateClassDeclaration(	×
305	(node as ts.ClassDeclaration),
306	exportModifiers,
307	(node as ts.ClassDeclaration).name,
308	(node as ts.ClassDeclaration).typeParameters,
309	(node as ts.ClassDeclaration).heritageClauses,
310	(node as ts.ClassDeclaration).members);
311	case SyntaxKind.FunctionDeclaration:
312	return factory.updateFunctionDeclaration(	×
313	(node as ts.FunctionDeclaration),
314	exportModifiers,
315	(node as ts.FunctionDeclaration).asteriskToken,
316	(node as ts.FunctionDeclaration).name,
317	(node as ts.FunctionDeclaration).typeParameters,
318	(node as ts.FunctionDeclaration).parameters,
319	(node as ts.FunctionDeclaration).type,
320	(node as ts.FunctionDeclaration).body);
321	case SyntaxKind.FunctionExpression:
322	return factory.createFunctionDeclaration(	3✔
323	exportModifiers,
324	(node as ts.FunctionExpression).asteriskToken,
325	(node as ts.FunctionExpression).name,
326	(node as ts.FunctionExpression).typeParameters,
327	(node as ts.FunctionExpression).parameters,
328	(node as ts.FunctionExpression).type,
329	(node as ts.FunctionExpression).body);
330	default:
331	throw new UnsupportedModuleError(	×
332	`Unable to create default export assignment for node of type ${SyntaxKind[node.kind]} at ` +
333	toPosStr(node));
334	}
335	}

SAP / ui5-linter / 11438993440

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