11443529734

Committed 21 Oct 2024 03:30PM UTC coverage: 79.186% (+0.3%) from 78.841%

Build # 11443529734

Build Type

Pull #374

github

Committed by

web-flow

Commit Message

Merge 2371a1e57 into 1acef8e47

Pull Request Pull Request #374: feat: Check Control renderer declaration

Run Details

1600 of 2149 branches covered (74.45%)

Branch coverage included in aggregate %.

42 of 44 new or added lines in 3 files covered. (95.45%)

20 existing lines in 3 files now uncovered.

2406 of 2910 relevant lines covered (82.68%)

1647.17 hits per line

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

87.5

/src/linter/ui5Types/amdTranspiler/rewriteExtendCall.ts

import ts from "typescript";
import {toPosStr} from "./util.js";

export class UnsupportedExtendCall extends Error {
        constructor(message: string) {
                super(message);
                this.name = this.constructor.name;
        }
}

/**
 * Rewrite a UI5-typical `Class.extend("MyClass", {})` CallExpression to a ClassDeclaration
 */
export default function rewriteExtendCall(nodeFactory: ts.NodeFactory,
        callExp: ts.CallExpression, modifiers?: ts.ModifierLike[],
        className?: string | ts.Identifier): ts.ClassDeclaration {
        if (!(ts.isPropertyAccessExpression(callExp.expression) && ts.isIdentifier(callExp.expression.name) &&
                callExp.expression.name.text === "extend")) {
                throw new UnsupportedExtendCall(`Not a UI5 Class#extends call ${toPosStr(callExp.expression)}`);
        }
        if (!className) {
                className = nodeFactory.createUniqueName(getClassNameFromArguments(callExp.arguments));
        }
        const body = getClassBodyFromArguments(nodeFactory, callExp.arguments);
        return nodeFactory.createClassDeclaration(modifiers,
                className,
                undefined,
                [nodeFactory.createHeritageClause(
                        ts.SyntaxKind.ExtendsKeyword,
                        [nodeFactory.createExpressionWithTypeArguments(
                                callExp.expression.expression, undefined
                        )]
                )],
                body);
}

function getClassNameFromArguments(args: ts.CallExpression["arguments"]): string {
        const firstArg = args[0];
        if (firstArg && !ts.isStringLiteralLike(firstArg)) {
                throw new UnsupportedExtendCall(`Unexpected extends argument of type ${ts.SyntaxKind[firstArg.kind]} at ` +
                        toPosStr(firstArg));
        }
        // Just like OpenUI5's ObjectPath...
        const nameSegments = firstArg.text.split(".");
        return nameSegments[nameSegments.length - 1];
}

function getClassBodyFromArguments(
        nodeFactory: ts.NodeFactory, args: ts.CallExpression["arguments"]): ts.ClassElement[] {
        let classBody: ts.ObjectLiteralExpression | undefined;
        for (let i = args.length - 1; i >= 0; i--) {
                const arg = args[i];
                if (ts.isObjectLiteralExpression(arg)) {
                        classBody = arg;
                        break;
                }
        }
        if (!classBody) {
                throw new UnsupportedExtendCall(`No class body found in extends call at ${toPosStr(args[0])}`);
        }
        if (classBody.properties.find((prop) => ts.isSpreadAssignment(prop) || ts.isShorthandPropertyAssignment(prop))) {
                // TODO: Support spread elements(?)
                throw new UnsupportedExtendCall(`Unsupported spread element in extends call body`);
        }
        return classBody.properties.map((prop): ts.ClassElement | undefined => {
                if (ts.isMethodDeclaration(prop)) {
                        // Use method declarations as-is
                        // e.g. "method() {}"

                        // Special handling:
                        // - renderer: *static*
                        // This aligns it with how UI5 projects should declare those properties in TypeScript

                        if (
                                ts.isIdentifier(prop.name) && prop.name.text === "renderer" &&
                                !prop.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)
                        ) {
                                // Add static modifier to renderer method
                                const staticModifier = nodeFactory.createToken(ts.SyntaxKind.StaticKeyword);
                                return nodeFactory.updateMethodDeclaration(prop,
                                        prop.modifiers ? [...prop.modifiers, staticModifier] : [staticModifier],
                                        prop.asteriskToken,
                                        prop.name, prop.questionToken, prop.typeParameters, prop.parameters, prop.type, prop.body);
                        }

                        return prop;
                } else if (ts.isPropertyAssignment(prop)) {
                        if (ts.isFunctionExpression(prop.initializer)) {
                                let modifiers: ts.ModifierLike[] | undefined;

                                // Special handling:
                                // - renderer: *static*
                                // This aligns it with how UI5 projects should declare those properties in TypeScript
                                if (
                                        ts.isIdentifier(prop.name) && prop.name.text === "renderer" &&
                                        !prop.initializer.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)
                                ) {
                                        modifiers = [nodeFactory.createToken(ts.SyntaxKind.StaticKeyword)];
                                }

                                return nodeFactory.createMethodDeclaration(
                                        modifiers, undefined,
                                        prop.name,
                                        undefined, undefined,
                                        prop.initializer.parameters,
                                        undefined,
                                        prop.initializer.body);
                        } else {
                                const modifiers: ts.ModifierLike[] = [];

                                // Special handling:
                                // - metadata: *readonly static*
                                // - renderer: *static*
                                // This aligns it with how UI5 projects should declare those properties in TypeScript
                                if (
                                        ts.isObjectLiteralExpression(prop.initializer) &&
                                        ts.isIdentifier(prop.name) &&
                                        prop.name.text === "metadata"
                                ) {
                                        modifiers.push(nodeFactory.createToken(ts.SyntaxKind.ReadonlyKeyword));
                                        modifiers.push(nodeFactory.createToken(ts.SyntaxKind.StaticKeyword));
                                } else if (ts.isIdentifier(prop.name) && prop.name.text === "renderer") {
                                        modifiers.push(nodeFactory.createToken(ts.SyntaxKind.StaticKeyword));
                                } else if (prop.initializer.kind === ts.SyntaxKind.NullKeyword ||
                                        prop.initializer.kind === ts.SyntaxKind.UndefinedKeyword
                                ) {
                                        // Skip property assignments that declare a null value, in the hope
                                        // that tsc can infer a more useful type based on other assignment
                                        // in one of the methods. If we would define a class property, tsc
                                        // would not attempt to infer more type information.
                                        return;
                                }

                                // Assign all properties (including arrow functions) to the class prototype
                                // This transformation does not reflect the runtime behavior where
                                // properties are set on the Class's prototype. However, tsc won't derive *any*
                                // type information from Object.defineProperty(Class.prototype, "prob", ...)
                                // So the current approach works better for the static analysis

                                return nodeFactory.createPropertyDeclaration(
                                        modifiers,
                                        prop.name,
                                        undefined, undefined,
                                        prop.initializer);
                        }
                } else {
                        throw new UnsupportedExtendCall(
                                `While generating class body: Unexpected property type ${ts.SyntaxKind[prop.kind]} at ` +
                                toPosStr(prop));
                }
        }).filter((_) => _) as ts.ClassElement[];
}

1	import ts from "typescript";
2	import {toPosStr} from "./util.js";
3
4	export class UnsupportedExtendCall extends Error {
5	constructor(message: string) {
6	super(message);	383✔
7	this.name = this.constructor.name;	383✔
8	}
9	}
10
11	/**
12	* Rewrite a UI5-typical `Class.extend("MyClass", {})` CallExpression to a ClassDeclaration
13	*/
14	export default function rewriteExtendCall(nodeFactory: ts.NodeFactory,
15	callExp: ts.CallExpression, modifiers?: ts.ModifierLike[],
16	className?: string \| ts.Identifier): ts.ClassDeclaration {
17	if (!(ts.isPropertyAccessExpression(callExp.expression) && ts.isIdentifier(callExp.expression.name) &&	489✔
18	callExp.expression.name.text === "extend")) {
19	throw new UnsupportedExtendCall(`Not a UI5 Class#extends call ${toPosStr(callExp.expression)}`);	381✔
20	}
21	if (!className) {	108✔
22	className = nodeFactory.createUniqueName(getClassNameFromArguments(callExp.arguments));	76✔
23	}
24	const body = getClassBodyFromArguments(nodeFactory, callExp.arguments);	106✔
25	return nodeFactory.createClassDeclaration(modifiers,	106✔
26	className,
27	undefined,
28	[nodeFactory.createHeritageClause(
29	ts.SyntaxKind.ExtendsKeyword,
30	[nodeFactory.createExpressionWithTypeArguments(
31	callExp.expression.expression, undefined
32	)]
33	)],
34	body);
35	}
36
37	function getClassNameFromArguments(args: ts.CallExpression["arguments"]): string {
38	const firstArg = args[0];	76✔
39	if (firstArg && !ts.isStringLiteralLike(firstArg)) {	76✔
40	throw new UnsupportedExtendCall(`Unexpected extends argument of type ${ts.SyntaxKind[firstArg.kind]} at ` +	2✔
41	toPosStr(firstArg));
42	}
43	// Just like OpenUI5's ObjectPath...
44	const nameSegments = firstArg.text.split(".");	74✔
45	return nameSegments[nameSegments.length - 1];	74✔
46	}
47
48	function getClassBodyFromArguments(
49	nodeFactory: ts.NodeFactory, args: ts.CallExpression["arguments"]): ts.ClassElement[] {
50	let classBody: ts.ObjectLiteralExpression \| undefined;
51	for (let i = args.length - 1; i >= 0; i--) {	106✔
52	const arg = args[i];	106✔
53	if (ts.isObjectLiteralExpression(arg)) {	106!
54	classBody = arg;	106✔
55	break;	106✔
56	}
57	}
58	if (!classBody) {	106!
59	throw new UnsupportedExtendCall(`No class body found in extends call at ${toPosStr(args[0])}`);	×
60	}
61	if (classBody.properties.find((prop) => ts.isSpreadAssignment(prop) \|\| ts.isShorthandPropertyAssignment(prop))) {	176!
62	// TODO: Support spread elements(?)
63	throw new UnsupportedExtendCall(`Unsupported spread element in extends call body`);	×
64	}
65	return classBody.properties.map((prop): ts.ClassElement \| undefined => {	106✔
66	if (ts.isMethodDeclaration(prop)) {	176✔
67	// Use method declarations as-is
68	// e.g. "method() {}"
69
70	// Special handling:
71	// - renderer: static
72	// This aligns it with how UI5 projects should declare those properties in TypeScript
73
74	if (	3✔
75	ts.isIdentifier(prop.name) && prop.name.text === "renderer" &&	8✔
NEW 76	!prop.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)	×
77	) {
78	// Add static modifier to renderer method
79	const staticModifier = nodeFactory.createToken(ts.SyntaxKind.StaticKeyword);	2✔
80	return nodeFactory.updateMethodDeclaration(prop,	2✔
81	prop.modifiers ? [...prop.modifiers, staticModifier] : [staticModifier],	2!
82	prop.asteriskToken,
83	prop.name, prop.questionToken, prop.typeParameters, prop.parameters, prop.type, prop.body);
84	}
85
86	return prop;	1✔
87	} else if (ts.isPropertyAssignment(prop)) {	173!
88	if (ts.isFunctionExpression(prop.initializer)) {	173✔
89	let modifiers: ts.ModifierLike[] \| undefined;
90
91	// Special handling:
92	// - renderer: static
93	// This aligns it with how UI5 projects should declare those properties in TypeScript
94	if (	100✔
95	ts.isIdentifier(prop.name) && prop.name.text === "renderer" &&	202✔
NEW 96	!prop.initializer.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)	×
97	) {
98	modifiers = [nodeFactory.createToken(ts.SyntaxKind.StaticKeyword)];	2✔
99	}
100
101	return nodeFactory.createMethodDeclaration(	100✔
102	modifiers, undefined,
103	prop.name,
104	undefined, undefined,
105	prop.initializer.parameters,
106	undefined,
107	prop.initializer.body);
108	} else {
109	const modifiers: ts.ModifierLike[] = [];	73✔
110
111	// Special handling:
112	// - metadata: readonly static
113	// - renderer: static
114	// This aligns it with how UI5 projects should declare those properties in TypeScript
115	if (	73✔
116	ts.isObjectLiteralExpression(prop.initializer) &&	178✔
117	ts.isIdentifier(prop.name) &&
118	prop.name.text === "metadata"
119	) {
120	modifiers.push(nodeFactory.createToken(ts.SyntaxKind.ReadonlyKeyword));	48✔
121	modifiers.push(nodeFactory.createToken(ts.SyntaxKind.StaticKeyword));	48✔
122	} else if (ts.isIdentifier(prop.name) && prop.name.text === "renderer") {	25✔
123	modifiers.push(nodeFactory.createToken(ts.SyntaxKind.StaticKeyword));	13✔
124	} else if (prop.initializer.kind === ts.SyntaxKind.NullKeyword \|\|	12!
125	prop.initializer.kind === ts.SyntaxKind.UndefinedKeyword
126	) {
127	// Skip property assignments that declare a null value, in the hope
128	// that tsc can infer a more useful type based on other assignment
129	// in one of the methods. If we would define a class property, tsc
130	// would not attempt to infer more type information.
UNCOV 131	return;	×
132	}
133
134	// Assign all properties (including arrow functions) to the class prototype
135	// This transformation does not reflect the runtime behavior where
136	// properties are set on the Class's prototype. However, tsc won't derive any
137	// type information from Object.defineProperty(Class.prototype, "prob", ...)
138	// So the current approach works better for the static analysis
139
140	return nodeFactory.createPropertyDeclaration(	73✔
141	modifiers,
142	prop.name,
143	undefined, undefined,
144	prop.initializer);
145	}
146	} else {
147	throw new UnsupportedExtendCall(	×
148	`While generating class body: Unexpected property type ${ts.SyntaxKind[prop.kind]} at ` +
149	toPosStr(prop));
150	}
151	}).filter((_) => _) as ts.ClassElement[];	176✔
152	}

SAP / ui5-linter / 11443529734

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