@ui5/builder 3.0.0-alpha.1 → 3.0.0-alpha.11

package/lib/processors/jsdoc/lib/ui5/plugin.js

@@ -1,7 +1,7 @@
 /*
  * JSDoc3 plugin for UI5 documentation generation.
  *
- * (c) Copyright 2009-2021 SAP SE or an SAP affiliate company.
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */
 
@@ -53,7 +53,14 @@
  */
 
 /* imports */
-const Syntax = require('jsdoc/src/syntax').Syntax;
+const Syntax = {
+	// Those are currently not in the syntax.js file.
+	ChainExpression: "ChainExpression",
+	OptionalMemberExpression: "OptionalMemberExpression",
+	OptionalCallExpression: "OptionalCallExpression",
+
+	...require("jsdoc/src/syntax").Syntax,
+};
 const Doclet = require('jsdoc/doclet').Doclet;
 const fs = require('jsdoc/fs');
 const path = require('jsdoc/path');
@@ -234,9 +241,8 @@ function resolveModuleName(base, name) {
 function analyzeModuleDefinition(node) {
 	const args = node.arguments;
 	let arg = 0;
-	if ( arg < args.length
-		 && args[arg].type === Syntax.Literal && typeof args[arg].value === 'string' ) {
-		currentModule.name = args[arg].value;
+	if ( arg < args.length && isStringLiteral(args[arg]) ) {
+		currentModule.name = convertValue(args[arg]);
 		warning(`module explicitly defined a module name '${currentModule.name}'`);
 		const resourceModuleName = getModuleName(currentModule.resource);
 		if (currentModule.name !== resourceModuleName) {
@@ -249,13 +255,19 @@ function analyzeModuleDefinition(node) {
 		currentModule.dependencies = convertValue(args[arg], "string[]");
 		arg++;
 	}
-	if ( arg < args.length && args[arg].type === Syntax.FunctionExpression ) {
+	if ( arg < args.length && 
+		[Syntax.FunctionExpression, Syntax.ArrowFunctionExpression].includes(args[arg].type)) {
+
 		currentModule.factory = args[arg];
 		arg++;
 	}
 	if ( currentModule.dependencies && currentModule.factory ) {
 		for ( let i = 0; i < currentModule.dependencies.length && i < currentModule.factory.params.length; i++ ) {
-			const name = currentModule.factory.params[i].name;
+			const name =
+				(currentModule.factory.params[i].type === Syntax.ObjectPattern)
+					? currentModule.factory.params[i].properties[0].value.name // ObjectPattern means destructuring of the parameter
+					: currentModule.factory.params[i].name; // simple Identifier
+
 			const module = resolveModuleName(currentModule.module, currentModule.dependencies[i]);
 			debug(`  import ${name} from '${module}'`);
 			currentModule.localNames[name] = {
@@ -265,7 +277,7 @@ function analyzeModuleDefinition(node) {
 		}
 	}
 	if ( currentModule.factory ) {
-		collectShortcuts(currentModule.factory.body);
+		collectShortcuts(currentModule.factory);
 	}
 }
 
@@ -276,31 +288,33 @@ function analyzeModuleDefinition(node) {
  *
  * @param {ASTNode} body AST node of a function body that shall be searched for shortcuts
  */
-function collectShortcuts(body) {
+function collectShortcuts(factory) {
+	const body = factory.body;
 
 	function checkAssignment(name, valueNode) {
+		valueNode = resolvePotentialWrapperExpression(valueNode);
+
 		if ( valueNode.type === Syntax.Literal ) {
 			currentModule.localNames[name] = {
 				value: valueNode.value,
 				raw: valueNode.raw
 			};
 			debug("compile time constant found ", name, valueNode.value);
-		} else if ( valueNode.type === Syntax.MemberExpression ) {
+		} else if ( isMemberExpression(valueNode) ) {
 			const _import = getLeftmostName(valueNode);
 			const local = _import && currentModule.localNames[_import];
-			if ( typeof local === 'object' && local.module ) {
+			const objectName = getObjectName(valueNode);
+			if ( objectName && typeof local === 'object' && local.module ) {
 				currentModule.localNames[name] = {
 					module: local.module,
-					path: getObjectName(valueNode).split('.').slice(1).join('.') // TODO chaining if local has path
+					path: objectName.split('.').slice(1).join('.') // TODO chaining if local has path
 				};
 				debug(`  found local shortcut: ${name} ${currentModule.localNames[name]}`);
 			}
 		} else if ( isRequireSyncCall(valueNode) || isProbingRequireCall(valueNode) ) {
-			if ( valueNode.arguments[0]
-				 && valueNode.arguments[0].type === Syntax.Literal
-				 && typeof valueNode.arguments[0].value === 'string' ) {
+			if ( valueNode.arguments[0] && isStringLiteral(valueNode.arguments[0]) ) {
 				currentModule.localNames[name] = {
-					module: valueNode.arguments[0].value
+					module: convertValue(valueNode.arguments[0])
 					// no (or empty) path
 				};
 				debug(`  found local import: ${name} = ${valueNode.callee.property.name}('${valueNode.arguments[0].value}')`);
@@ -314,8 +328,8 @@ function collectShortcuts(body) {
 		}
 	}
 
-	if ( body.type === Syntax.BlockStatement ) {
-		body.body.forEach(function ( stmt ) {
+	if ( body.type === Syntax.BlockStatement || isArrowFuncExpression(factory) ) {
+		const itemsResolver = function ( stmt ) {
 			// console.log(stmt);
 			if ( stmt.type === Syntax.FunctionDeclaration ) {
 				if ( stmt.id && stmt.id.type === Syntax.Identifier && stmt.loc && stmt.loc.start ) {
@@ -335,15 +349,28 @@ function collectShortcuts(body) {
 						&& stmt.expression.type === Syntax.AssignmentExpression
 						&& stmt.expression.left.type === Syntax.Identifier ) {
 				checkAssignment(stmt.expression.left.name, stmt.expression.right);
-			} else if ( stmt.type === Syntax.ReturnStatement ) {
-				if ( stmt.argument && stmt.argument.type === Syntax.Identifier ) {
-					currentModule.defaultExport = stmt.argument.name;
-				} else if ( stmt.argument && isExtendCall(stmt.argument) ) {
-					debug(`  found default export class definition: return .extend('${stmt.argument.arguments[0].value}', ...)`);
-					currentModule.defaultExportClass = stmt.argument.arguments[0].value;
+			} else if ( isReturningNode(stmt) ) {
+				const stmtArgument = isArrowFuncExpression(stmt)
+					? stmt.body
+					: resolvePotentialWrapperExpression(stmt).argument;
+
+				if ( stmtArgument && stmtArgument.type === Syntax.Identifier ) {
+					currentModule.defaultExport = stmtArgument.name;
+				} else if ( stmtArgument && stmtArgument.type === Syntax.ClassExpression && stmtArgument.id && stmtArgument.id.type === Syntax.Identifier ) {
+					debug(`  found default export class definition: return class '${stmtArgument.id.name}'`);
+					currentModule.defaultExportClass = stmtArgument.id.name;
+				} else if ( stmtArgument && isExtendCall(stmtArgument) ) {
+					debug(`  found default export class definition: return .extend('${stmtArgument.arguments[0].value}', ...)`);
+					currentModule.defaultExportClass = convertValue(stmtArgument.arguments[0]);
 				}
 			}
-		});
+		};
+
+		if (isArrowFuncExpression(factory)) {
+			itemsResolver(factory);
+		} else {
+			body.body.forEach(itemsResolver);
+		}
 	}
 
 	if ( currentModule.defaultExport && currentModule.localNames[currentModule.defaultExport] ) {
@@ -368,12 +395,12 @@ function guessSingularName(sPluralName) {
 }
 
 function getPropertyKey(prop) {
-	if ( prop.key.type === Syntax.Identifier ) {
+	if ( prop.type === Syntax.SpreadElement ) {
+		return;
+	} else if ( prop.key.type === Syntax.Identifier && prop.computed !== true ) {
 		return prop.key.name;
 	} else if ( prop.key.type === Syntax.Literal ) {
 		return String(prop.key.value);
-	} else {
-		return prop.key.toSource();
 	}
 }
 
@@ -431,80 +458,180 @@ function createPropertyMap(node, defaultKey) {
 	return result;
 }
 
+/**
+ * Resolves potential wrapper expressions like: ChainExpression, AwaitExpression, etc.
+ * @param {Node} node 
+ * @returns {Node} the resolved node
+ */
+function resolvePotentialWrapperExpression(node) {
+	switch (node && node.type) {
+		case Syntax.ChainExpression:
+			return node.expression;
+
+		case Syntax.AwaitExpression:
+			return node.argument;
+
+		case Syntax.ExpressionStatement:
+			if ( node.expression.type === Syntax.YieldExpression ) {
+				return node.expression.argument.type === Syntax.UpdateExpression
+					? node.expression.argument
+					: node.expression;
+			}
+		default:
+			return node;
+	}
+}
+
+/**
+ * Strips the ChainExpression wrapper if such
+ * 
+ * @param {Node} rootNode 
+ * @param {String} path 
+ * @returns {Node}
+ */
+function stripChainWrappers(rootNode, path) {
+	const strip = (node) =>
+		node && node.type === Syntax.ChainExpression ? node.expression : node;
+
+	let curNode = strip(rootNode);
+	let chunks = path && path.split(".");
+	let name;
+
+	while (chunks && chunks.length) {
+		name = chunks.shift();
+		curNode = curNode &&  strip(curNode[name]);
+	}
+
+	return curNode;
+}
+
+function isTemplateLiteralWithoutExpression(node) {
+	return (
+		node?.type === Syntax.TemplateLiteral &&
+		node?.expressions?.length === 0 &&
+		node?.quasis?.length === 1
+	);
+}
+
+/**
+ * Checks whether a node is Literal or TemplateLiteral without an expression
+ * 
+ * @param {Node} node 
+ * @returns {String}
+ */
+function isStringLiteral(node) {
+	return (
+		(node && node.type === Syntax.Literal && typeof node.value === "string")
+		|| isTemplateLiteralWithoutExpression(node)
+	);
+}
+
+function isMemberExpression(node) {
+	return node && [Syntax.MemberExpression, Syntax.OptionalMemberExpression].includes(node.type);
+}
+
+function isCaleeMemberExpression(node) {
+	return (
+		node &&
+		[Syntax.CallExpression, Syntax.OptionalCallExpression].includes(node.type) &&
+		isMemberExpression(node.callee)
+	);
+}
+
 function isExtendCall(node) {
+	node = stripChainWrappers(node);
 
 	return (
 		node
-		&& node.type === Syntax.CallExpression
-		&& node.callee.type === Syntax.MemberExpression
-		&& node.callee.property.type === Syntax.Identifier
-		&& node.callee.property.name === 'extend'
+		&& isCaleeMemberExpression(node)
+		&& stripChainWrappers(node, "callee.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.property").name === 'extend'
 		&& node.arguments.length >= 2
-		&& node.arguments[0].type === Syntax.Literal
-		&& typeof node.arguments[0].value === "string"
+		&& isStringLiteral(node.arguments[0])
 		&& node.arguments[1].type === Syntax.ObjectExpression
 	);
 
 }
 
+function isArrowFuncExpression(node) {
+	return (
+		node &&
+		node.type === Syntax.ArrowFunctionExpression &&
+		node.expression === true
+	);
+}
+
+/**
+ * Checks whether the node is of a "returning" type
+ * 
+ * @param {Node} node 
+ * @returns {Boolean}
+ */
+function isReturningNode(node) {
+	return (node && node.type === Syntax.ReturnStatement)
+		|| (node && node.type === Syntax.ExpressionStatement && node.expression.type === Syntax.YieldExpression)
+		|| isArrowFuncExpression(node);
+}
+
 function isSapUiDefineCall(node) {
 
 	return (
-		node
-		&& node.type === Syntax.CallExpression
-		&& node.callee.type === Syntax.MemberExpression
-		&& node.callee.object.type === Syntax.MemberExpression
-		&& node.callee.object.object.type === Syntax.Identifier
-		&& node.callee.object.object.name === 'sap'
-		&& node.callee.object.property.type === Syntax.Identifier
-		&& node.callee.object.property.name === 'ui'
-		&& node.callee.property.type === Syntax.Identifier
-		&& node.callee.property.name === 'define'
+		stripChainWrappers(node)
+		&& isCaleeMemberExpression(stripChainWrappers(node))
+		&& isMemberExpression(stripChainWrappers(node, "callee.object"))
+		&& stripChainWrappers(node, "callee.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.property").name === 'define'
+		&& stripChainWrappers(node, "callee.object.object").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.object").name === 'sap'
+		&& stripChainWrappers(node, "callee.object.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.property").name === 'ui'
 	);
 
 }
 
 function isCreateDataTypeCall(node) {
+	node = stripChainWrappers(node);
+
 	return (
 		node
-		&& node.type === Syntax.CallExpression
-		&& node.callee.type === Syntax.MemberExpression
-		&& getResolvedObjectName(node.callee.object) === "sap.ui.base.DataType"
-		&& node.callee.property.type === Syntax.Identifier
-		&& node.callee.property.name === 'createType'
+		&& isCaleeMemberExpression(node)
+		&& getResolvedObjectName(stripChainWrappers(node, "callee.object")) === "sap.ui.base.DataType"
+		&& stripChainWrappers(node, "callee.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.property").name === 'createType'
 	);
 }
 
 function isRequireSyncCall(node) {
+	node = stripChainWrappers(node);
+
 	return (
 		node
-		&& node.type === Syntax.CallExpression
-		&& node.callee.type === Syntax.MemberExpression
-		&& node.callee.object.type === Syntax.MemberExpression
-		&& node.callee.object.object.type === Syntax.Identifier
-		&& node.callee.object.object.name === 'sap'
-		&& node.callee.object.property.type === Syntax.Identifier
-		&& node.callee.object.property.name === 'ui'
-		&& node.callee.property.type === Syntax.Identifier
-		&& node.callee.property.name === 'requireSync'
+		&& isCaleeMemberExpression(node)
+		&& isMemberExpression( stripChainWrappers(node, "callee.object") )
+		&& stripChainWrappers(node, "callee.object.object").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.object").name === 'sap'
+		&& stripChainWrappers(node, "callee.object.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.property").name === 'ui'
+		&& stripChainWrappers(node, "callee.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.property").name === 'requireSync'
 	);
 }
 
 function isProbingRequireCall(node) {
+	node = stripChainWrappers(node);
+
 	return (
 		node
-		&& node.type === Syntax.CallExpression
-		&& node.callee.type === Syntax.MemberExpression
-		&& node.callee.object.type === Syntax.MemberExpression
-		&& node.callee.object.object.type === Syntax.Identifier
-		&& node.callee.object.object.name === 'sap'
-		&& node.callee.object.property.type === Syntax.Identifier
-		&& node.callee.object.property.name === 'ui'
-		&& node.callee.property.type === Syntax.Identifier
-		&& node.callee.property.name === 'require'
+		&& isCaleeMemberExpression(node)
+		&& isMemberExpression( stripChainWrappers(node, "callee.object") )
+		&& stripChainWrappers(node, "callee.object.object").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.object").name === 'sap'
+		&& stripChainWrappers(node, "callee.object.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.object.property").name === 'ui'
+		&& stripChainWrappers(node, "callee.property").type === Syntax.Identifier
+		&& stripChainWrappers(node, "callee.property").name === 'require'
 		&& node.arguments.length === 1
-		&& node.arguments[0].type === Syntax.Literal
-		&& typeof node.arguments[0].value === 'string' // TODO generalize to statically analyzable constants
+		&& isStringLiteral(node.arguments[0])
 	);
 }
 
@@ -520,7 +647,7 @@ function isCompileTimeConstant(node) {
 }
 
 function getObjectName(node) {
-	if ( node.type === Syntax.MemberExpression && !node.computed && node.property.type === Syntax.Identifier ) {
+	if ( isMemberExpression(node) && !node.computed && node.property.type === Syntax.Identifier ) {
 		const prefix = getObjectName(node.object);
 		return prefix ? prefix + "." + node.property.name : null;
 	} else if ( node.type === Syntax.Identifier ) {
@@ -535,7 +662,7 @@ function getObjectName(node) {
  * returns the leftmost identifier a
  */
 function getLeftmostName(node) {
-	while ( node.type === Syntax.MemberExpression ) {
+	while ( isMemberExpression(node) ) {
 		node = node.object;
 	}
 	if ( node.type === Syntax.Identifier ) {
@@ -603,7 +730,7 @@ function convertValueWithRaw(node, type, propertyName) {
 			raw: node.operator + node.argument.raw
 		};
 
-	} else if ( node.type === Syntax.MemberExpression && type ) {
+	} else if ( isMemberExpression(node) && type ) {
 
 		// enum value (a.b.c)
 		value = getResolvedObjectName(node);
@@ -673,6 +800,11 @@ function convertValueWithRaw(node, type, propertyName) {
 			};
 		}
 
+	} else if ( isTemplateLiteralWithoutExpression(node) ) {
+		return {
+			value: node?.quasis?.[0]?.value?.cooked,
+			raw: node?.quasis?.[0]?.value?.raw,
+		};
 	}
 
 	value = "...see text or source";
@@ -696,10 +828,10 @@ function convertStringArray(node) {
 	}
 	const result = [];
 	for ( let i = 0; i < node.elements.length; i++ ) {
-		if ( node.elements[i].type !== Syntax.Literal || typeof node.elements[i].value !== 'string' ) {
+		if ( !isStringLiteral(node.elements[i]) ) {
 			throw new Error("not a string literal");
 		}
-		result.push(node.elements[i].value);
+		result.push( convertValue(node.elements[i]) );
 	}
 	// console.log(result);
 	return result;
@@ -735,7 +867,7 @@ function collectClassInfo(extendCall, classDoclet) {
 	if ( classDoclet && classDoclet.augments && classDoclet.augments.length === 1 ) {
 		baseType = classDoclet.augments[0];
 	}
-	if ( extendCall.callee.type === Syntax.MemberExpression ) {
+	if ( isMemberExpression(extendCall.callee) ) {
 		const baseCandidate = getResolvedObjectName(extendCall.callee.object);
 		if ( baseCandidate && baseType == null ) {
 			baseType = baseCandidate;
@@ -745,7 +877,7 @@ function collectClassInfo(extendCall, classDoclet) {
 	}
 
 	const oClassInfo = {
-		name : extendCall.arguments[0].value,
+		name : convertValue(extendCall.arguments[0]),
 		baseType : baseType,
 		interfaces : [],
 		doc : classDoclet && classDoclet.description,
@@ -987,7 +1119,7 @@ function collectClassInfo(extendCall, classDoclet) {
 	return oClassInfo;
 }
 
-function collectDesigntimeInfo(dtNode) {
+function collectDesigntimeInfo(dtNodeArgument) {
 
 	function each(node, defaultKey, callback) {
 		const map = node && createPropertyMap(node.value);
@@ -1009,7 +1141,7 @@ function collectDesigntimeInfo(dtNode) {
 
 	let oDesigntimeInfo;
 
-	const map = createPropertyMap(dtNode.argument);
+	const map = createPropertyMap(dtNodeArgument);
 
 	if (map.annotations) {
 
@@ -1094,12 +1226,19 @@ function determineValueRangeBorder(range, expression, varname, inverse) {
 function determineValueRange(expression, varname, inverse) {
 	const range = {};
 	if ( expression.type === Syntax.LogicalExpression
-		 && expression.operator === '&&'
 		 && expression.left.type === Syntax.BinaryExpression
-		 && expression.right.type === Syntax.BinaryExpression
-		 && determineValueRangeBorder(range, expression.left, varname, inverse)
-		 && determineValueRangeBorder(range, expression.right, varname, inverse) ) {
-		return range;
+		 && expression.right.type === Syntax.BinaryExpression ) {
+
+			if ( expression.operator === "&&" 
+				&& determineValueRangeBorder(range, expression.left, varname, inverse) 
+				&& determineValueRangeBorder(range, expression.right, varname, inverse) ) {
+				return range;
+			} else if ( ["||", "??"].includes(expression.operator)
+				&& ( determineValueRangeBorder(range, expression.left, varname, inverse) 
+				|| determineValueRangeBorder(range, expression.right, varname, inverse) )) {
+				return range;
+			}
+		
 	} else if ( expression.type === Syntax.BinaryExpression
 				&& determineValueRangeBorder(range, expression, varname, inverse) ) {
 		return range;
@@ -1112,24 +1251,24 @@ function collectDataTypeInfo(extendCall, classDoclet) {
 	let i = 0,
 		name, def, base, pattern, range;
 
-	if ( i < args.length && args[i].type === Syntax.Literal && typeof args[i].value === 'string' ) {
-		name = args[i++].value;
+	if ( i < args.length && isStringLiteral(args[i]) ) {
+		name = convertValue(args[i++]);
 	}
 	if ( i < args.length && args[i].type === Syntax.ObjectExpression ) {
 		def = createPropertyMap(args[i++]);
 	}
 	if ( i < args.length ) {
-		if ( args[i].type === Syntax.Literal && typeof args[i].value === 'string' ) {
-			base = args[i++].value;
-		} else if ( args[i].type === Syntax.CallExpression
-					&& args[i].callee.type === Syntax.MemberExpression
-					&& getResolvedObjectName(args[i].callee.object) === "sap.ui.base.DataType"
-					&& args[i].callee.property.type === Syntax.Identifier
-					&& args[i].callee.property.name === 'getType'
-					&& args[i].arguments.length === 1
-					&& args[i].arguments[0].type === Syntax.Literal
-					&& typeof args[i].arguments[0].value === 'string' ) {
-			base = args[i++].arguments[0].value;
+		const node = resolvePotentialWrapperExpression(args[i]);
+
+		if ( isStringLiteral(args[i]) ) {
+			base = convertValue(args[i++]);
+		} else if ( isCaleeMemberExpression(node)
+					&& getResolvedObjectName(node.callee.object) === "sap.ui.base.DataType"
+					&& node.callee.property.type === Syntax.Identifier
+					&& node.callee.property.name === 'getType'
+					&& node.arguments.length === 1
+					&& isStringLiteral(node.arguments[0]) ) {
+			base = convertValue(args[i++].arguments[0]);
 		} else {
 			future(`could not identify base type of data type '${name}'`);
 		}
@@ -1137,25 +1276,31 @@ function collectDataTypeInfo(extendCall, classDoclet) {
 		base = "any";
 	}
 
+	const isArrowExpression = isArrowFuncExpression(def && def.isValid && def.isValid.value);
+
 	if ( def
 		 && def.isValid
-		 && def.isValid.value.type === Syntax.FunctionExpression
+		 && [Syntax.FunctionExpression, Syntax.ArrowFunctionExpression].includes(def.isValid.value.type)
 		 && def.isValid.value.params.length === 1
 		 && def.isValid.value.params[0].type === Syntax.Identifier
-		 && def.isValid.value.body.body.length === 1 ) {
+		 && (isArrowExpression || def.isValid.value.body.body.length === 1) ) {
+
 		const varname = def.isValid.value.params[0].name;
-		const stmt = def.isValid.value.body.body[0];
-		if ( stmt.type === Syntax.ReturnStatement && stmt.argument ) {
-			if ( stmt.argument.type === Syntax.CallExpression
-				 && stmt.argument.callee.type === Syntax.MemberExpression
-				 && stmt.argument.callee.object.type === Syntax.Literal
-				 && stmt.argument.callee.object.regex
-				 && stmt.argument.callee.property.type === Syntax.Identifier
-				 && stmt.argument.callee.property.name === 'test' ) {
-				pattern = stmt.argument.callee.object.regex.pattern;
+		const stmt = isArrowExpression ? def.isValid.value.body : def.isValid.value.body.body[0];
+
+		if ( isReturningNode(stmt) || isArrowExpression ) {
+			const stmtArgument = resolvePotentialWrapperExpression(
+				isArrowExpression ? stmt : stmt.argument
+			);
+			if ( isCaleeMemberExpression(stmtArgument)
+				 && stmtArgument.callee.object.type === Syntax.Literal
+				 && stmtArgument.callee.object.regex
+				 && stmtArgument.callee.property.type === Syntax.Identifier
+				 && stmtArgument.callee.property.name === 'test' ) {
+				pattern = stmtArgument.callee.object.regex.pattern;
 				// console.log(pattern);
 			} else {
-				range = determineValueRange(stmt.argument, varname, false);
+				range = determineValueRange(stmtArgument, varname, false);
 			}
 		} else if ( stmt.type === Syntax.IfStatement
 					&& stmt.consequent.type === Syntax.BlockStatement
@@ -1617,7 +1762,7 @@ function createAutoDoc(oClassInfo, classComment, doclet, node, parser, filename,
 				"Removes a " + n1 + " from the aggregation " + link + ".",
 				"",
 				"@param {int | string | " + makeTypeString(info, true) + "} " + varname(n1, "variant") + " The " + n1 + " to remove or its index or id",
-				"@returns {" + makeTypeString(info, true) + "} The removed " + n1 + " or <code>null</code>",
+				"@returns {" + makeTypeString(info, true) + "|null} The removed " + n1 + " or <code>null</code>",
 				info.since ? "@since " + info.since : "",
 				info.deprecation ? "@deprecated " + info.deprecation : "",
 				info.experimental ? "@experimental " + info.experimental : "",
@@ -1740,7 +1885,7 @@ function createAutoDoc(oClassInfo, classComment, doclet, node, parser, filename,
 			newJSDoc([
 				"Removes an " + n1 + " from the association named " + link + ".",
 				"@param {int | sap.ui.core.ID | " + info.type + "} " + varname(n1, "variant") + " The " + n1 + " to be removed or its index or ID",
-				"@returns {sap.ui.core.ID} The removed " + n1 + " or <code>null</code>",
+				"@returns {sap.ui.core.ID|null} The removed " + n1 + " or <code>null</code>",
 				info.since ? "@since " + info.since : "",
 				info.deprecation ? "@deprecated " + info.deprecation : "",
 				info.experimental ? "@experimental " + info.experimental : "",
@@ -1812,7 +1957,7 @@ function createAutoDoc(oClassInfo, classComment, doclet, node, parser, filename,
 			"",
 			"@param {object}",
 			"           [oData] An application-specific payload object that will be passed to the event handler along with the event object when firing the event",
-			"@param {function}",
+			"@param {function(sap.ui.base.Event):void}",
 			"           fnFunction The function to be called when the event occurs",
 			"@param {object}",
 			"           [oListener] Context object to call the event handler with. Defaults to this <code>" + oClassInfo.name + "</code> itself",
@@ -1830,7 +1975,7 @@ function createAutoDoc(oClassInfo, classComment, doclet, node, parser, filename,
 			"",
 			"The passed function and listener object must match the ones used for event registration.",
 			"",
-			"@param {function}",
+			"@param {function(sap.ui.base.Event):void}",
 			"           fnFunction The function to be called, when the event occurs",
 			"@param {object}",
 			"           [oListener] Context object on which the given function had to be called",
@@ -2582,24 +2727,37 @@ exports.astNodeVisitor = {
 			}
 		}
 
-		if ( node.type === Syntax.ExpressionStatement ) {
-			if ( isSapUiDefineCall(node.expression) ) {
-				analyzeModuleDefinition(node.expression);
-			/*
+		if ( [Syntax.ExpressionStatement, Syntax.LogicalExpression].includes(node.type) ) {
+			let nodeToAnalyze;
+			if (isSapUiDefineCall(node.expression)) {
+				nodeToAnalyze = node.expression;
+
+				/*
 			} else if ( isJQuerySapDeclareCall(node.expression)
 				 && node.expression.arguments.length > 0
 				 && node.expression.arguments[0].type === Syntax.Literal
 				 && typeof node.expression.arguments[0].value === "string" ) {
 				warning(`module has explicit module name ${node.expression.arguments[0].value}`);
 			*/
+			} else if (isSapUiDefineCall(node.left)) {
+				nodeToAnalyze = node.left;
+			} else if (isSapUiDefineCall(node.right)) {
+				nodeToAnalyze = node.right;
 			}
 
+			nodeToAnalyze && analyzeModuleDefinition(
+				resolvePotentialWrapperExpression(nodeToAnalyze)
+			);
 		}
 
-		if (node.type === Syntax.ReturnStatement && node.argument && node.argument.type === Syntax.ObjectExpression && /\.designtime\.js$/.test(currentSourceName) ) {
+		const isArrowExpression = isArrowFuncExpression(node) && node.body.type === Syntax.ObjectExpression;
+		const nodeArgument = isArrowExpression
+				? node.body
+				: resolvePotentialWrapperExpression(node).argument;
+		if (isArrowExpression || (isReturningNode(node) && nodeArgument && nodeArgument.type === Syntax.ObjectExpression) && /\.designtime\.js$/.test(currentSourceName) ) {
 
 			// assume this node to return designtime metadata. Collect it and remember it by its module name
-			const oDesigntimeInfo = collectDesigntimeInfo(node);
+			const oDesigntimeInfo = collectDesigntimeInfo(nodeArgument);
 			if ( oDesigntimeInfo ) {
 				designtimeInfos[currentModule.module] = oDesigntimeInfo;
 				info(`collected designtime info ${currentModule.module}`);
@@ -2629,14 +2787,19 @@ exports.astNodeVisitor = {
 				}
 			});
 
-		} else if ( node.type === Syntax.ReturnStatement && isExtendCall(node.argument) ) {
+		} else if ( isReturningNode(node)
+					&& isExtendCall(resolvePotentialWrapperExpression(node).argument || node.body) ) {
+
+			const nodeArgument = isArrowFuncExpression(node)
+				? node.body
+				: resolvePotentialWrapperExpression(node).argument;
 
 			// return Something.extend(...)
 
-			const className = node.argument.arguments[0].value;
-			const comment = getLeadingCommentNode(node, className) || getLeadingCommentNode(node.argument, className);
+			const className = convertValue(nodeArgument.arguments[0]);
+			const comment = getLeadingCommentNode(node, className) || getLeadingCommentNode(nodeArgument, className);
 			// console.log(`ast node with comment ${comment}`);
-			processExtendCall(node.argument, comment, true);
+			processExtendCall(nodeArgument, comment, true);
 		} else if ( node.type === Syntax.ExpressionStatement && node.expression.type === Syntax.AssignmentExpression ) {
 
 			if ( isCreateDataTypeCall(node.expression.right) ) {
@@ -2677,3 +2840,132 @@ exports.astNodeVisitor = {
 	}
 
 };
+
+(function() {
+	const jsdocType = require("jsdoc/lib/jsdoc/tag/type");
+	const catharsis = require('catharsis');
+	const TYPES = catharsis.Types;
+
+	const toTypeString = (type) => getTypeStrings(type).join("|");
+
+	/*
+	 * This function has been copied from jsdoc/lib/jsdoc/tag/type (version 3.6.7)
+	 * The copy has been enhanced with the changes from https://github.com/jsdoc/jsdoc/pull/1735
+	 * to retain the full function signature for function types and with a further change
+	 * to retain the full record type structure.
+	 *
+	 * JSDoc is copyright (c) 2011-present Michael Mathews micmath@gmail.com and the contributors to JSDoc.
+	 */ 
+	function getTypeStrings(parsedType, isOutermostType) {
+		let applications;
+		let typeString;
+		let types = [];
+		switch (parsedType.type) {
+			case TYPES.AllLiteral:
+				types.push('*');
+				break;
+			case TYPES.FunctionType:
+				typeString = 'function';
+				// #### BEGIN: MODIFIED BY SAP
+				const paramTypes = [];
+				if (parsedType.new) {
+					paramTypes.push(toTypeString(parsedType.new));
+				}
+				if (Array.isArray(parsedType.params)) {
+					paramTypes.push(...parsedType.params.map(toTypeString));
+				}
+				if (paramTypes.length || parsedType.result) {
+					typeString += `(${paramTypes.join(", ")})`;
+				}
+				if (parsedType.result) {
+					typeString += `:${toTypeString(parsedType.result)}`;
+				}
+				types.push(typeString);
+				// #### END: MODIFIED BY SAP
+				break;
+			 case TYPES.NameExpression:
+				 types.push(parsedType.name);
+				break;
+			case TYPES.NullLiteral:
+				types.push('null');
+				break;
+			case TYPES.RecordType:
+				// #### BEGIN: MODIFIED BY SAP
+				// types.push('Object');
+				if (Array.isArray(parsedType.fields)) {
+					typeString = `{${parsedType.fields.map(
+						({key,value}) => {
+							const keyString = catharsis.stringify(key);
+							if (value) {
+								var propertyPlusType = `${keyString}: ${toTypeString(value)}`;
+								return propertyPlusType;
+							} else {
+								let pos;
+								if (keyString && (pos = keyString.indexOf(":")) > -1) {
+									// When no space is present between colon and type (e.g. the structure looks like "{x:number}" with no space after
+									// the colon), then Catharsis parses this as property name "x:number" with no type given.
+									// In this case give a clear hint that this space is needed and throw an error to prevent such issues from being merged
+									const realName = keyString.substring(0, pos);
+									const realValue = keyString.substring(pos + 1, keyString.length);
+									let message = `Cannot parse the "${keyString}" part of "${parsedType.typeExpression}" in RecordType (log output above may give a hint in which file).\n`;
+									message += `Did you mean to specify a property "${realName}" of type "${realValue}"? Then insert a space after the colon and write "${realName}: ${realValue}".`
+									error(message);
+									return "x: any"; // unparseable property set to "any" - but the JSDoc run will fail now, anyway
+								} else {
+									// only property given without type; this will be turned into type "any" further downstream
+									return keyString;
+								}
+							}
+						}
+					).join(', ')}}`;
+					types.push(typeString);
+				} else {
+					types.push('Object');
+				}
+				// #### END: MODIFIED BY SAP
+				break;
+			case TYPES.TypeApplication:
+				// if this is the outermost type, we strip the modifiers; otherwise, we keep them
+				if (isOutermostType) {
+					applications = parsedType.applications.map(application =>
+						catharsis.stringify(application)).join(', ');
+					typeString = `${getTypeStrings(parsedType.expression)[0]}.<${applications}>`;
+					types.push(typeString);
+				}
+				else {
+					types.push( catharsis.stringify(parsedType) );
+				}
+				break;
+			case TYPES.TypeUnion:
+				parsedType.elements.forEach(element => {
+					types = types.concat( getTypeStrings(element) );
+				});
+				break;
+			case TYPES.UndefinedLiteral:
+				types.push('undefined');
+				break;
+			case TYPES.UnknownLiteral:
+				types.push('?');
+				break;
+			default:
+				// this shouldn't happen
+				throw new Error(`unrecognized type ${parsedType.type} in parsed type: ${parsedType}`);
+		}
+		return types;
+	}
+
+	const origParse = jsdocType.parse;
+	jsdocType.parse = function() {
+		const tagInfo = origParse.apply(this, arguments);
+		// #### BEGIN: MODIFIED BY SAP
+		if ( tagInfo && (/function/.test(tagInfo.typeExpression) || /\{.*\}/.test(tagInfo.typeExpression)) && tagInfo.parsedType ) {
+			// #### END: MODIFIED BY SAP
+			// console.info("old typeExpression", tagInfo.typeExpression); 
+			// console.info("old parse tree", tagInfo.parsedType); 
+			// console.info("old parse result", tagInfo.type); 
+			tagInfo.type = getTypeStrings(tagInfo.parsedType);
+			// console.info("new parse result", tagInfo.type); 
+		}
+		return tagInfo;
+	}
+}());