@sapui5/sap.fe.core 1.96.4 → 1.99.0

package/src/sap/fe/core/helpers/BindingExpression.ts

@@ -28,7 +28,7 @@ import { ApplyAnnotationExpression, PathAnnotationExpression } from "@sap-ux/voc
 import { EntitySet } from "@sap-ux/vocabularies-types/dist/Converter";
 import { resolveEnumValue } from "./AnnotationEnum";
 
-type PrimitiveType = string | number | boolean | object | null | undefined;
+type PrimitiveType = string | number | bigint | boolean | object | null | undefined;
 
 type BaseExpression<T> = {
 	_type: string;
@@ -87,6 +87,11 @@ export type ConcatExpression = BaseExpression<string> & {
 	expressions: Expression<string>[];
 };
 
+export type LengthExpression = BaseExpression<string> & {
+	_type: "Length";
+	bindingExpression: BindingExpressionExpression<any>;
+};
+
 export type UnresolveableBindingExpression = BaseExpression<string> & {
 	_type: "Unresolveable";
 };
@@ -154,6 +159,7 @@ export type Expression<T> =
 	| NotExpression
 	| TruthyExpression
 	| ConcatExpression
+	| LengthExpression
 	| BindingExpressionExpression<T>
 	| EmbeddedBindingExpression<T>
 	| EmbeddedExpressionBindingExpression<T>
@@ -175,14 +181,7 @@ export const unresolveableExpression: UnresolveableBindingExpression = {
 };
 
 function escapeXmlAttribute(inputString: string) {
-	return inputString.replace(/[']/g, function(c: string) {
-		switch (c) {
-			case "'":
-				return "\\'";
-			default:
-				return c;
-		}
-	});
+	return inputString.replace(/'/g, "\\'");
 }
 
 export function hasUnresolveableExpression(...expressions: Expression<any>[]): boolean {
@@ -230,7 +229,7 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 
 		case "Comparison":
 			return (
-				a.operator == (b as ComparisonExpression).operator &&
+				a.operator === (b as ComparisonExpression).operator &&
 				_checkExpressionsAreEqual(a.operand1, (b as ComparisonExpression).operand1) &&
 				_checkExpressionsAreEqual(a.operand2, (b as ComparisonExpression).operand2)
 			);
@@ -245,6 +244,9 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 				return _checkExpressionsAreEqual(expression, bExpressions[index]);
 			});
 
+		case "Length":
+			return _checkExpressionsAreEqual(a.bindingExpression, (b as LengthExpression).bindingExpression);
+
 		case "Binding":
 			return (
 				a.modelName === (b as BindingExpressionExpression<T>).modelName &&
@@ -288,6 +290,7 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 		case "Ref":
 			return a.ref === (b as ReferenceExpression).ref;
 	}
+	return false;
 }
 
 /**
@@ -319,21 +322,15 @@ function flattenSetExpression(expression: SetExpression): SetExpression {
  * @returns {boolean} `true` if the set of expressions contains an expression and its negation
  */
 function hasOppositeExpressions(expressions: Expression<boolean>[]): boolean {
-	if (expressions.length < 2) {
-		return false;
-	}
-
-	let i = expressions.length;
-	while (i--) {
-		const expression = expressions[i];
-		const negatedExpression = not(expression);
-		for (let j = 0; j < i; j++) {
-			if (_checkExpressionsAreEqual(expressions[j], negatedExpression)) {
+	const negatedExpressions = expressions.map(not);
+	return expressions.some((expression, index) => {
+		for (let i = index + 1; i < negatedExpressions.length; i++) {
+			if (_checkExpressionsAreEqual(expression, negatedExpressions[i])) {
 				return true;
 			}
 		}
-	}
-	return false;
+		return false;
+	});
 }
 
 /**
@@ -355,9 +352,9 @@ export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<b
 	if (hasUnresolveableExpression(...expressions)) {
 		return unresolveableExpression;
 	}
-	let isStaticFalse: boolean = false;
+	let isStaticFalse = false;
 	const nonTrivialExpression = expressions.filter(expression => {
-		if (isConstant(expression) && !expression.value) {
+		if (isFalse(expression)) {
 			isStaticFalse = true;
 		}
 		return !isConstant(expression);
@@ -366,9 +363,7 @@ export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<b
 		return constant(false);
 	} else if (nonTrivialExpression.length === 0) {
 		// Resolve the constant then
-		const isValid = expressions.reduce((isValid, expression) => {
-			return isValid && isConstant(expression) && expression.value;
-		}, true);
+		const isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);
 		return constant(isValid);
 	} else if (nonTrivialExpression.length === 1) {
 		return nonTrivialExpression[0];
@@ -401,9 +396,9 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<bo
 	if (hasUnresolveableExpression(...expressions)) {
 		return unresolveableExpression;
 	}
-	let isStaticTrue: boolean = false;
+	let isStaticTrue = false;
 	const nonTrivialExpression = expressions.filter(expression => {
-		if (isConstant(expression) && expression.value) {
+		if (isTrue(expression)) {
 			isStaticTrue = true;
 		}
 		return !isConstant(expression) || expression.value;
@@ -412,9 +407,7 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<bo
 		return constant(true);
 	} else if (nonTrivialExpression.length === 0) {
 		// Resolve the constant then
-		const isValid = expressions.reduce((isValid, expression) => {
-			return isValid && isConstant(expression) && expression.value;
-		}, true);
+		const isValid = expressions.reduce((result, expression) => result && isTrue(expression), true);
 		return constant(isValid);
 	} else if (nonTrivialExpression.length === 1) {
 		return nonTrivialExpression[0];
@@ -459,26 +452,26 @@ export function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean
 		// Create the reverse comparison
 		switch (operand.operator) {
 			case "!==":
-				return equal(operand.operand1, operand.operand2);
+				return { ...operand, operator: "===" };
 			case "<":
-				return greaterOrEqual(operand.operand1, operand.operand2);
+				return { ...operand, operator: ">=" };
 			case "<=":
-				return greaterThan(operand.operand1, operand.operand2);
+				return { ...operand, operator: ">" };
 			case "===":
-				return notEqual(operand.operand1, operand.operand2);
+				return { ...operand, operator: "!==" };
 			case ">":
-				return lessOrEqual(operand.operand1, operand.operand2);
+				return { ...operand, operator: "<=" };
 			case ">=":
-				return lessThan(operand.operand1, operand.operand2);
+				return { ...operand, operator: "<" };
 		}
 	} else if (operand._type === "Not") {
 		return operand.operand;
-	} else {
-		return {
-			_type: "Not",
-			operand: operand
-		};
 	}
+
+	return {
+		_type: "Not",
+		operand: operand
+	};
 }
 
 /**
@@ -550,19 +543,16 @@ export function constant<T extends PrimitiveType>(value: T): ConstantExpression<
 	if (typeof value === "object" && value !== null && value !== undefined) {
 		if (Array.isArray(value)) {
 			constantValue = value.map(wrapPrimitive) as T;
-		} else if (isPrimitiveObject(value as object)) {
+		} else if (isPrimitiveObject(value)) {
 			constantValue = value.valueOf() as T;
 		} else {
-			const val = value as { [name: string]: ExpressionOrPrimitive<any> };
-			const obj = Object.keys(val).reduce((obj, key) => {
-				const value = wrapPrimitive(val[key]);
-				if (value._type !== "Constant" || value.value !== undefined) {
-					obj[key] = value;
+			constantValue = Object.entries(value).reduce((plainExpression, [key, val]) => {
+				const wrappedValue = wrapPrimitive(val);
+				if (wrappedValue._type !== "Constant" || wrappedValue.value !== undefined) {
+					plainExpression[key] = wrappedValue;
 				}
-				return obj;
-			}, {} as PlainExpressionObject);
-
-			constantValue = obj as T;
+				return plainExpression;
+			}, {} as PlainExpressionObject) as T;
 		}
 	} else {
 		constantValue = value;
@@ -589,16 +579,10 @@ export function resolveBindingString<T extends PrimitiveType>(
 				value: value
 			};
 		}
+	} else if (targetType === "boolean" && typeof value === "string" && (value === "true" || value === "false")) {
+		return constant(value === "true") as ConstantExpression<T>;
 	} else {
-		switch (targetType) {
-			case "boolean":
-				if (typeof value === "string" && (value === "true" || value === "false")) {
-					return constant(value === "true") as ConstantExpression<T>;
-				}
-				return constant(value) as ConstantExpression<T>;
-			default:
-				return constant(value) as ConstantExpression<T>;
-		}
+		return constant(value) as ConstantExpression<T>;
 	}
 }
 
@@ -607,11 +591,11 @@ export function resolveBindingString<T extends PrimitiveType>(
  *
  * @see fn
  *
- * @param ref Reference
+ * @param reference Reference
  * @returns {ReferenceExpression} The object reference binding part
  */
-export function ref(ref: string | null): ReferenceExpression {
-	return { _type: "Ref", ref };
+export function ref(reference: string | null): ReferenceExpression {
+	return { _type: "Ref", ref: reference };
 }
 
 /**
@@ -653,6 +637,14 @@ export function isConstant<T extends PrimitiveType>(maybeConstant: ExpressionOrP
 	return typeof maybeConstant !== "object" || (maybeConstant as BaseExpression<T>)._type === "Constant";
 }
 
+function isTrue(expression: Expression<PrimitiveType>) {
+	return isConstant(expression) && expression.value === true;
+}
+
+function isFalse(expression: Expression<PrimitiveType>) {
+	return isConstant(expression) && expression.value === false;
+}
+
 /**
  * Checks if the expression or value provided is binding or not.
  *
@@ -700,97 +692,97 @@ function isPrimitiveObject(objectType: object): boolean {
 	}
 }
 /**
- * Check if the passed annotation expression is a ComplexAnnotationExpression.
+ * Check if the passed annotation annotationValue is a ComplexAnnotationExpression.
  *
  * @template T The target type
- * @param  annotationExpression The annotation expression to evaluate
+ * @param  annotationValue The annotation annotationValue to evaluate
  * @returns {boolean} `true` if the object is a {ComplexAnnotationExpression}
  */
-function isComplexAnnotationExpression<T>(
-	annotationExpression: PropertyAnnotationValue<T>
-): annotationExpression is ComplexAnnotationExpression<T> {
-	return typeof annotationExpression === "object" && !isPrimitiveObject(annotationExpression as object);
+function isComplexAnnotationExpression<T>(annotationValue: PropertyAnnotationValue<T>): annotationValue is ComplexAnnotationExpression<T> {
+	return typeof annotationValue === "object" && !isPrimitiveObject(annotationValue as object);
 }
 
 /**
- * Generate the corresponding expression for a given annotation expression.
+ * Generate the corresponding annotationValue for a given annotation annotationValue.
  *
  * @template T The target type
- * @param annotationExpression The source annotation expression
+ * @param annotationValue The source annotation annotationValue
  * @param visitedNavigationPaths The path from the root entity set
- * @param defaultValue Default value if the annotationExpression is undefined
+ * @param defaultValue Default value if the annotationValue is undefined
  * @param pathVisitor A function to modify the resulting path
- * @returns {Expression<T>} The expression equivalent to that annotation expression
+ * @returns {Expression<T>} The annotationValue equivalent to that annotation annotationValue
  */
 export function annotationExpression<T extends PrimitiveType>(
-	annotationExpression: PropertyAnnotationValue<T>,
+	annotationValue: PropertyAnnotationValue<T>,
 	visitedNavigationPaths: string[] = [],
 	defaultValue?: ExpressionOrPrimitive<T>,
 	pathVisitor?: Function
 ): Expression<T> {
-	if (annotationExpression === undefined) {
+	if (annotationValue === undefined) {
 		return wrapPrimitive(defaultValue as T);
 	}
-	if (!isComplexAnnotationExpression(annotationExpression)) {
-		return constant(annotationExpression);
-	} else {
-		switch (annotationExpression.type) {
-			case "Path":
-				return bindingExpression(annotationExpression.path, undefined, visitedNavigationPaths, pathVisitor);
-			case "If":
-				return annotationIfExpression(annotationExpression.If, visitedNavigationPaths, pathVisitor);
-			case "Not":
-				return not(parseAnnotationCondition(annotationExpression.Not, visitedNavigationPaths, pathVisitor)) as Expression<T>;
-			case "Eq":
-				return equal(
-					parseAnnotationCondition(annotationExpression.Eq[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Eq[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Ne":
-				return notEqual(
-					parseAnnotationCondition(annotationExpression.Ne[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Ne[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Gt":
-				return greaterThan(
-					parseAnnotationCondition(annotationExpression.Gt[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Gt[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Ge":
-				return greaterOrEqual(
-					parseAnnotationCondition(annotationExpression.Ge[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Ge[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Lt":
-				return lessThan(
-					parseAnnotationCondition(annotationExpression.Lt[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Lt[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Le":
-				return lessOrEqual(
-					parseAnnotationCondition(annotationExpression.Le[0], visitedNavigationPaths, pathVisitor),
-					parseAnnotationCondition(annotationExpression.Le[1], visitedNavigationPaths, pathVisitor)
-				) as Expression<T>;
-			case "Or":
-				return or(
-					...(annotationExpression.Or.map(function(orCondition) {
-						return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
-					}) as Expression<boolean>[])
-				) as Expression<T>;
-			case "And":
-				return and(
-					...(annotationExpression.And.map(function(andCondition) {
-						return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
-					}) as Expression<boolean>[])
-				) as Expression<T>;
-			case "Apply":
-				return annotationApplyExpression(
-					annotationExpression as ApplyAnnotationExpression<string>,
-					visitedNavigationPaths,
-					pathVisitor
-				) as Expression<T>;
-		}
+
+	if (!isComplexAnnotationExpression(annotationValue)) {
+		return constant(annotationValue);
+	}
+
+	switch (annotationValue.type) {
+		case "Path":
+			return bindingExpression(annotationValue.path, undefined, visitedNavigationPaths, pathVisitor);
+		case "If":
+			return annotationIfExpression(annotationValue.If, visitedNavigationPaths, pathVisitor);
+		case "Not":
+			return not(parseAnnotationCondition(annotationValue.Not, visitedNavigationPaths, pathVisitor)) as Expression<T>;
+		case "Eq":
+			return equal(
+				parseAnnotationCondition(annotationValue.Eq[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Eq[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Ne":
+			return notEqual(
+				parseAnnotationCondition(annotationValue.Ne[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Ne[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Gt":
+			return greaterThan(
+				parseAnnotationCondition(annotationValue.Gt[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Gt[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Ge":
+			return greaterOrEqual(
+				parseAnnotationCondition(annotationValue.Ge[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Ge[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Lt":
+			return lessThan(
+				parseAnnotationCondition(annotationValue.Lt[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Lt[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Le":
+			return lessOrEqual(
+				parseAnnotationCondition(annotationValue.Le[0], visitedNavigationPaths, pathVisitor),
+				parseAnnotationCondition(annotationValue.Le[1], visitedNavigationPaths, pathVisitor)
+			) as Expression<T>;
+		case "Or":
+			return or(
+				...(annotationValue.Or.map(function(orCondition) {
+					return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
+				}) as Expression<boolean>[])
+			) as Expression<T>;
+		case "And":
+			return and(
+				...(annotationValue.And.map(function(andCondition) {
+					return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
+				}) as Expression<boolean>[])
+			) as Expression<T>;
+		case "Apply":
+			return annotationApplyExpression(
+				annotationValue as ApplyAnnotationExpression<string>,
+				visitedNavigationPaths,
+				pathVisitor
+			) as Expression<T>;
 	}
+	return unresolveableExpression;
 }
 
 /**
@@ -880,41 +872,40 @@ function parseAnnotationCondition<T extends PrimitiveType>(
 		);
 	} else if (annotationValue.hasOwnProperty("$EnumMember")) {
 		return constant(resolveEnumValue((annotationValue as any).$EnumMember) as T);
-	} else {
-		return constant(false as T);
 	}
+	return constant(false as T);
 }
 
 /**
  * Process the {IfAnnotationExpressionValue} into an expression.
  *
  * @template T The target type
- * @param annotationIfExpression An If expression returning the type T
+ * @param annotationValue An If expression returning the type T
  * @param visitedNavigationPaths The path from the root entity set
  * @param pathVisitor A function to modify the resulting path
  * @returns {Expression<T>} The equivalent ifElse expression
  */
 export function annotationIfExpression<T extends PrimitiveType>(
-	annotationIfExpression: IfAnnotationExpressionValue<T>,
+	annotationValue: IfAnnotationExpressionValue<T>,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
 ): Expression<T> {
 	return ifElse(
-		parseAnnotationCondition(annotationIfExpression[0], visitedNavigationPaths, pathVisitor),
-		parseAnnotationCondition(annotationIfExpression[1] as any, visitedNavigationPaths, pathVisitor),
-		parseAnnotationCondition(annotationIfExpression[2] as any, visitedNavigationPaths, pathVisitor)
+		parseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor),
+		parseAnnotationCondition(annotationValue[1] as any, visitedNavigationPaths, pathVisitor),
+		parseAnnotationCondition(annotationValue[2] as any, visitedNavigationPaths, pathVisitor)
 	);
 }
 
 export function annotationApplyExpression(
-	annotationApplyExpression: ApplyAnnotationExpression<string>,
+	applyExpression: ApplyAnnotationExpression<string>,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
 ): Expression<string> {
-	switch (annotationApplyExpression.Function) {
+	switch (applyExpression.Function) {
 		case "odata.concat":
 			return concat(
-				...annotationApplyExpression.Apply.map((applyParam: any) => {
+				...applyExpression.Apply.map((applyParam: any) => {
 					let applyParamConverted = applyParam;
 					if (applyParam.hasOwnProperty("$Path")) {
 						applyParamConverted = {
@@ -936,8 +927,8 @@ export function annotationApplyExpression(
 					return annotationExpression(applyParamConverted, visitedNavigationPaths, undefined, pathVisitor);
 				})
 			);
-			break;
 	}
+	return unresolveableExpression;
 }
 
 /**
@@ -960,10 +951,6 @@ function comparison<T extends PrimitiveType>(
 		return unresolveableExpression;
 	}
 	if (isConstant(leftExpression) && isConstant(rightExpression)) {
-		if (leftExpression.value === undefined || rightExpression.value === undefined) {
-			return constant(leftExpression.value === rightExpression.value);
-		}
-
 		switch (operator) {
 			case "!==":
 				return constant(leftExpression.value !== rightExpression.value);
@@ -976,7 +963,6 @@ function comparison<T extends PrimitiveType>(
 			case ">=":
 				return constant(leftExpression.value >= rightExpression.value);
 			case "===":
-			default:
 				return constant(leftExpression.value === rightExpression.value);
 		}
 	} else {
@@ -989,6 +975,16 @@ function comparison<T extends PrimitiveType>(
 	}
 }
 
+export function length(expression: BindingExpressionExpression<any> | UnresolveableBindingExpression): Expression<number> {
+	if (expression._type === "Unresolveable") {
+		return expression;
+	}
+	return {
+		_type: "Length",
+		bindingExpression: expression
+	};
+}
+
 /**
  * Comparison: "equal" (===).
  *
@@ -1010,32 +1006,35 @@ export function equal<T extends PrimitiveType>(
 		return constant(true);
 	}
 
-	// ((a === c) === true) => (a === c)
-	if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
-		return leftExpression;
-	} else if (rightExpression._type === "Comparison" && isConstant(leftExpression) && leftExpression.value === true) {
-		// (true === (a === c)) => (a === c)
-		return rightExpression;
-	} else if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
-		// ((a === c) === false) => !(a === c)
-		return not(leftExpression);
-	} else if (leftExpression._type === "IfElse" && _checkExpressionsAreEqual(leftExpression.onTrue, rightExpression)) {
-		// (if(xxxx) { aaa } else { bbb } ) === aaa )
-		return or(leftExpression.condition, equal(leftExpression.onFalse, rightExpression));
-	} else if (leftExpression._type === "IfElse" && _checkExpressionsAreEqual(leftExpression.onFalse, rightExpression)) {
-		return or(not(leftExpression.condition), equal(leftExpression.onTrue, rightExpression));
-	} else if (
-		leftExpression._type === "IfElse" &&
-		isConstant(leftExpression.onTrue) &&
-		isConstant(rightExpression) &&
-		isConstant(leftExpression.onFalse) &&
-		!_checkExpressionsAreEqual(leftExpression.onTrue, rightExpression) &&
-		!_checkExpressionsAreEqual(leftExpression.onFalse, rightExpression)
-	) {
-		return constant(false);
+	function reduce(left: Expression<T>, right: Expression<T>) {
+		if (left._type === "Comparison" && isTrue(right)) {
+			// compare(a, b) === true ~~> compare(a, b)
+			return left;
+		} else if (left._type === "Comparison" && isFalse(right)) {
+			// compare(a, b) === false ~~> !compare(a, b)
+			return not(left);
+		} else if (left._type === "IfElse" && _checkExpressionsAreEqual(left.onTrue, right)) {
+			// (if (x) { a } else { b }) === a ~~> x || (b === a)
+			return or(left.condition, equal(left.onFalse, right));
+		} else if (left._type === "IfElse" && _checkExpressionsAreEqual(left.onFalse, right)) {
+			// (if (x) { a } else { b }) === b ~~> !x || (a === b)
+			return or(not(left.condition), equal(left.onTrue, right));
+		} else if (
+			left._type === "IfElse" &&
+			isConstant(left.onTrue) &&
+			isConstant(left.onFalse) &&
+			isConstant(right) &&
+			!_checkExpressionsAreEqual(left.onTrue, right) &&
+			!_checkExpressionsAreEqual(left.onFalse, right)
+		) {
+			return constant(false);
+		}
+		return undefined;
 	}
 
-	return comparison("===", leftExpression, rightExpression);
+	// exploit symmetry: a === b <~> b === a
+	const reduced = reduce(leftExpression, rightExpression) ?? reduce(rightExpression, leftExpression);
+	return reduced ?? comparison("===", leftExpression, rightExpression);
 }
 
 /**
@@ -1050,36 +1049,7 @@ export function notEqual<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
 ): Expression<boolean> {
-	const leftExpression = wrapPrimitive(leftOperand);
-	const rightExpression = wrapPrimitive(rightOperand);
-
-	if (_checkExpressionsAreEqual(leftExpression, rightExpression)) {
-		return constant(false);
-	}
-
-	// ((a === c) !== true) => !(a === c)
-	if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
-		return not(leftExpression);
-	} else if (leftExpression._type === "Comparison" && isConstant(rightExpression) && rightExpression.value === true) {
-		// ((a === c) !== false) => (a === c)
-		return leftExpression;
-	} else if (leftExpression._type === "IfElse" && _checkExpressionsAreEqual(leftExpression.onTrue, rightExpression)) {
-		return and(not(leftExpression.condition), notEqual(leftExpression.onFalse, rightExpression));
-	} else if (leftExpression._type === "IfElse" && _checkExpressionsAreEqual(leftExpression.onFalse, rightExpression)) {
-		return and(leftExpression.condition, notEqual(leftExpression.onTrue, rightExpression));
-	} else if (
-		leftExpression._type === "IfElse" &&
-		isConstant(leftExpression.onTrue) &&
-		isConstant(rightExpression) &&
-		isConstant(leftExpression.onFalse) &&
-		!_checkExpressionsAreEqual(leftExpression.onTrue, rightExpression) &&
-		!_checkExpressionsAreEqual(leftExpression.onFalse, rightExpression)
-	) {
-		// If the left expression is an if else where both onTrue and onFalse are not equals to the right expression -> simplify as true
-		return constant(true);
-	}
-
-	return comparison("!==", leftExpression, rightExpression);
+	return not(equal(leftOperand, rightOperand));
 }
 
 /**
@@ -1184,61 +1154,40 @@ export function ifElse<T extends PrimitiveType>(
 		onFalseExpression = onFalseExpression.onFalse;
 	}
 
-	// inline nested if-else expressions: condition
-	if (conditionExpression._type === "IfElse") {
-		if (
-			isConstant(conditionExpression.onFalse) &&
-			!conditionExpression.onFalse.value &&
-			isConstant(conditionExpression.onTrue) &&
-			conditionExpression.onTrue.value
-		) {
-			// ifElse(ifElse(X, true, false), a, b) ==> ifElse(X, a, b)
-			conditionExpression = conditionExpression.condition;
-		} else if (
-			isConstant(conditionExpression.onFalse) &&
-			conditionExpression.onFalse.value &&
-			isConstant(conditionExpression.onTrue) &&
-			!conditionExpression.onTrue.value
-		) {
-			// ifElse(ifElse(X, false, true), a, b) ==> ifElse(not(X), a, b)
-			conditionExpression = not(conditionExpression.condition);
-		} else if (
-			isConstant(conditionExpression.onTrue) &&
-			!conditionExpression.onTrue.value &&
-			!isConstant(conditionExpression.onFalse)
-		) {
-			// ifElse(ifElse(X, false, a), b, c) ==> ifElse(and(not(X), a), b, c)
-			conditionExpression = and(not(conditionExpression.condition), conditionExpression.onFalse);
-		}
-	}
-
-	// again swap branches if needed (in case one of the optimizations above led to a negated condition)
-	if (conditionExpression._type === "Not") {
-		// ifElse(not(X), a, b) --> ifElse(X, b, a)
-		[onTrueExpression, onFalseExpression] = [onFalseExpression, onTrueExpression];
-		conditionExpression = not(conditionExpression);
-	}
-
-	// compute expression result for constant conditions
+	// (if true then a else b)  ~~> a
+	// (if false then a else b) ~~> b
 	if (isConstant(conditionExpression)) {
 		return conditionExpression.value ? onTrueExpression : onFalseExpression;
 	}
 
-	// compute expression result if onTrue and onFalse branches are equal
+	// if (isConstantBoolean(onTrueExpression) || isConstantBoolean(onFalseExpression)) {
+	// 	return or(and(condition, onTrueExpression as Expression<boolean>), and(not(condition), onFalseExpression as Expression<boolean>)) as Expression<T>
+	// }
+	// (if X then a else a) ~~> a
 	if (_checkExpressionsAreEqual(onTrueExpression, onFalseExpression)) {
 		return onTrueExpression;
 	}
 
-	// If either trueExpression or falseExpression is a value equals to false the expression can be simplified
-	// If(Condition) Then XXX Else False -> Condition && XXX
-	if (isConstant(onFalseExpression) && onFalseExpression.value === false) {
+	// if X then a else false ~~> X && a
+	if (isFalse(onFalseExpression)) {
 		return and(conditionExpression, onTrueExpression as Expression<boolean>) as Expression<T>;
 	}
-	// If(Condition) Then False Else XXX -> !Condition && XXX
-	if (isConstant(onTrueExpression) && onTrueExpression.value === false) {
+
+	// if X then a else true ~~> !X || a
+	if (isTrue(onFalseExpression)) {
+		return or(not(conditionExpression), onTrueExpression as Expression<boolean>) as Expression<T>;
+	}
+
+	// if X then false else a ~~> !X && a
+	if (isFalse(onTrueExpression)) {
 		return and(not(conditionExpression), onFalseExpression as Expression<boolean>) as Expression<T>;
 	}
 
+	// if X then true else a ~~> X || a
+	if (isTrue(onTrueExpression)) {
+		return or(conditionExpression, onFalseExpression as Expression<boolean>) as Expression<T>;
+	}
+
 	return {
 		_type: "IfElse",
 		condition: conditionExpression,
@@ -1389,17 +1338,17 @@ export function addTypeInformation<T, U extends Fn<T>>(
 /**
  * Function call, optionally with arguments.
  *
- * @param fn Function name or reference to function
+ * @param func Function name or reference to function
  * @param parameters Arguments
  * @param on Object to call the function on
  * @returns {FunctionExpression<T>} Expression representing the function call (not the result of the function call!)
  */
 export function fn<T, U extends FunctionOrName<T>>(
-	fn: U,
+	func: U,
 	parameters: WrappedTuple<FunctionParameters<T, U>>,
 	on?: ExpressionOrPrimitive<object>
 ): FunctionExpression<T> {
-	const functionName = typeof fn === "string" ? fn : (fn as Fn<T>).__functionName;
+	const functionName = typeof func === "string" ? func : (func as Fn<T>).__functionName;
 	return {
 		_type: "Function",
 		obj: on !== undefined ? wrapPrimitive(on) : undefined,
@@ -1445,31 +1394,26 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 	inExpression: Expression<T>,
 	expressionType: ExpressionType,
 	transformFunction: TransformFunction,
-	includeAllExpression: boolean = false
+	includeAllExpression = false
 ): Expression<T> {
 	let expression = inExpression;
 	switch (expression._type) {
 		case "Function":
-			expression.parameters = expression.parameters.map(expression =>
-				transformRecursively(expression, expressionType, transformFunction, includeAllExpression)
+		case "Formatter":
+			expression.parameters = expression.parameters.map(parameter =>
+				transformRecursively(parameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "Concat":
-			expression.expressions = expression.expressions.map(expression =>
-				transformRecursively(expression, expressionType, transformFunction, includeAllExpression)
+			expression.expressions = expression.expressions.map(subExpression =>
+				transformRecursively(subExpression, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "ComplexType":
-			expression.bindingParameters = expression.bindingParameters.map(expression =>
-				transformRecursively(expression, expressionType, transformFunction, includeAllExpression)
+			expression.bindingParameters = expression.bindingParameters.map(bindingParameter =>
+				transformRecursively(bindingParameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
-		case "Formatter":
-			expression.parameters = expression.parameters.map(expression =>
-				transformRecursively(expression, expressionType, transformFunction, includeAllExpression)
-			);
-			break;
-
 		case "IfElse":
 			const onTrue = transformRecursively(expression.onTrue, expressionType, transformFunction, includeAllExpression);
 			const onFalse = transformRecursively(expression.onFalse, expressionType, transformFunction, includeAllExpression);
@@ -1489,8 +1433,8 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			break;
 		case "Set":
 			if (includeAllExpression) {
-				expression.operands = expression.operands.map(expression =>
-					transformRecursively(expression, expressionType, transformFunction, includeAllExpression)
+				expression.operands = expression.operands.map(operand =>
+					transformRecursively(operand, expressionType, transformFunction, includeAllExpression)
 				);
 			}
 			break;
@@ -1503,6 +1447,7 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			break;
 		case "DefaultBinding":
 		case "Ref":
+		case "Length":
 		case "Binding":
 		case "Constant":
 			// Do nothing
@@ -1519,6 +1464,158 @@ export type BindingExpression<T> = T | string | undefined;
 const needParenthesis = function<T extends PrimitiveType>(expr: ExpressionOrPrimitive<T>): boolean {
 	return !isConstant(expr) && !isBinding(expr) && isExpression(expr) && expr._type !== "IfElse" && expr._type !== "Function";
 };
+
+/**
+ * Compiles a constant object to a string.
+ * @param expr
+ * @param isNullable
+ * @returns {string} The compiled string
+ */
+function compileConstantObject<T>(expr: ConstantExpression<object>, isNullable = false) {
+	if (isNullable && Object.keys(expr.value).length === 0) {
+		return "";
+	}
+	// Objects
+	const o = expr.value as PlainExpressionObject;
+	const properties: string[] = [];
+	Object.keys(o).forEach(key => {
+		const value = o[key];
+		const childResult = compileBinding(value, true, false, true);
+		if (childResult && childResult.length > 0) {
+			properties.push(`${key}: ${childResult}`);
+		}
+	});
+	return `{${properties.join(", ")}}`;
+}
+
+/**
+ * Compiles a Constant Binding Expression.
+ * @param expr
+ * @param embeddedInBinding
+ * @param isNullable
+ * @returns {string} The compiled string
+ */
+function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, embeddedInBinding: boolean, isNullable = false) {
+	if (expr.value === null) {
+		return "null";
+	}
+	if (expr.value === undefined) {
+		return "undefined";
+	}
+	if (typeof expr.value === "object") {
+		if (Array.isArray(expr.value)) {
+			const entries = expr.value.map(expression => compileBinding(expression, true));
+			return `[${entries.join(", ")}]`;
+		} else {
+			return compileConstantObject(expr as ConstantExpression<object>, isNullable);
+		}
+	}
+
+	if (embeddedInBinding) {
+		switch (typeof expr.value) {
+			case "number":
+			case "bigint":
+			case "boolean":
+				return expr.value.toString();
+			case "string":
+				return `'${escapeXmlAttribute(expr.value.toString())}'`;
+			default:
+				return "";
+		}
+	} else {
+		return expr.value.toString();
+	}
+}
+
+/**
+ * Generates the binding string for a Binding expression.
+ *
+ * @param expressionForBinding The expression to compile
+ * @param embeddedInBinding Whether the expression to compile is embedded into another expression
+ * @param embeddedSeparator The binding value evaluator ($ or % depending on whether we want to force the type or not)
+ * @returns {BindingExpression<T>} The corresponding expression binding
+ */
+function compileBindingForBinding<T extends PrimitiveType>(
+	expressionForBinding: BindingExpressionExpression<T> | DefaultBindingExpressionExpression<T>,
+	embeddedInBinding: boolean,
+	embeddedSeparator: string
+) {
+	if (
+		expressionForBinding.type ||
+		expressionForBinding.parameters ||
+		expressionForBinding.targetType ||
+		expressionForBinding.formatOptions ||
+		expressionForBinding.constraints
+	) {
+		// This is now a complex binding definition, let's prepare for it
+		const complexBindingDefinition = {
+			path: compileBindingPath(expressionForBinding),
+			type: expressionForBinding.type,
+			targetType: expressionForBinding.targetType,
+			parameters: expressionForBinding.parameters,
+			formatOptions: expressionForBinding.formatOptions,
+			constraints: expressionForBinding.constraints
+		};
+		let outBinding = compileBinding(complexBindingDefinition);
+		if (embeddedInBinding) {
+			outBinding = `${embeddedSeparator}` + outBinding;
+		}
+		return outBinding;
+	} else if (embeddedInBinding) {
+		return `${embeddedSeparator}{${compileBindingPath(expressionForBinding)}}`;
+	} else {
+		return `{${compileBindingPath(expressionForBinding)}}`;
+	}
+}
+
+function compileComplexTypeExpression<T extends PrimitiveType>(expression: ComplexTypeExpression<T>) {
+	if (expression.bindingParameters.length === 1) {
+		return `{${compilePathParameter(expression.bindingParameters[0], true)}, type: '${expression.type}'}`;
+	}
+
+	let outputEnd;
+	// this code is based on sap.ui.model.odata.v4._AnnotationHelperExpression.fetchCurrencyOrUnit
+	switch (expression.type) {
+		case "sap.ui.model.odata.type.Unit":
+			outputEnd = `,{mode:'OneTime',path:'/##@@requestUnitsOfMeasure',targetType:'any'}],type:'sap.ui.model.odata.type.Unit'`;
+			break;
+		case "sap.ui.model.odata.type.Currency":
+			outputEnd = `,{mode:'OneTime',path:'/##@@requestCurrencyCodes',targetType:'any'}],type:'sap.ui.model.odata.type.Currency'`;
+			break;
+		default:
+			outputEnd = `], type: '${expression.type}'`;
+	}
+	if (hasElements(expression.formatOptions)) {
+		outputEnd += `, formatOptions: ${compileBinding(expression.formatOptions)}`;
+	}
+	if (hasElements(expression.parameters)) {
+		outputEnd += `, parameters: ${compileBinding(expression.parameters)}`;
+	}
+	outputEnd += "}";
+
+	return `{mode:'TwoWay', parts:[${expression.bindingParameters.map((param: any) => compilePathParameter(param)).join(",")}${outputEnd}`;
+}
+
+/**
+ * Wrap the compiled binding string as required dependening on its context.
+ *
+ * @param expression The compiled expression
+ * @param embeddedInBinding True if the compiled expression is to be embedded in a binding
+ * @param parenthesisRequired True if the embedded binding needs to be wrapped in parethesis so that it is evaluated as one
+ * @returns {BindingExpression<string>} Finalized compiled expression
+ */
+function wrapBindingExpression(expression: string, embeddedInBinding: boolean, parenthesisRequired = false): BindingExpression<string> {
+	if (embeddedInBinding) {
+		if (parenthesisRequired) {
+			return `(${expression})`;
+		} else {
+			return expression;
+		}
+	} else {
+		return `{= ${expression}}`;
+	}
+}
+
 /**
  * Compile an expression into an expression binding.
  *
@@ -1526,55 +1623,24 @@ const needParenthesis = function<T extends PrimitiveType>(expr: ExpressionOrPrim
  * @param expression The expression to compile
  * @param embeddedInBinding Whether the expression to compile is embedded into another expression
  * @param keepTargetType Keep the target type of the embedded bindings instead of casting them to any
+ * @param isNullable Whether binding expression can resolve to empty string or not
  * @returns {BindingExpression<T>} The corresponding expression binding
  */
 export function compileBinding<T extends PrimitiveType>(
 	expression: ExpressionOrPrimitive<T>,
-	embeddedInBinding: boolean = false,
-	keepTargetType: boolean = false
+	embeddedInBinding = false,
+	keepTargetType = false,
+	isNullable = false
 ): BindingExpression<string> {
 	const expr = wrapPrimitive(expression);
 	const embeddedSeparator = keepTargetType ? "$" : "%";
-	let outProperty = "";
+
 	switch (expr._type) {
 		case "Unresolveable":
 			return undefined;
-		case "Constant":
-			if (expr.value === null) {
-				return "null";
-			}
-			if (expr.value === undefined) {
-				return "undefined";
-			}
-			if (typeof expr.value === "object") {
-				if (Array.isArray(expr.value)) {
-					const entries = expr.value.map(expression => compileBinding(expression, true));
-					return `[${entries.join(", ")}]`;
-				} else {
-					// Objects
-					const o = expr.value as PlainExpressionObject;
-					const properties = Object.keys(o).map(key => {
-						const value = o[key];
-						return `${key}: ${compileBinding(value, true)}`;
-					});
-					return `{${properties.join(", ")}}`;
-				}
-			}
 
-			if (embeddedInBinding) {
-				switch (typeof expr.value) {
-					case "number":
-					case "bigint":
-					case "boolean":
-						return expr.value.toString();
-					case "string":
-						return `'${escapeXmlAttribute(expr.value.toString())}'`;
-					default:
-						return "";
-				}
-			} else {
-				return expr.value.toString();
-			}
+		case "Constant":
+			return compileConstant(expr, embeddedInBinding, isNullable);
 
 		case "Ref":
 			return expr.ref || "null";
@@ -1584,164 +1650,91 @@ export function compileBinding<T extends PrimitiveType>(
 			return expr.obj === undefined
 				? `${expr.fn}(${argumentString})`
 				: `${compileBinding(expr.obj, true)}.${expr.fn}(${argumentString})`;
+
 		case "EmbeddedExpressionBinding":
-			if (embeddedInBinding) {
-				return `(${expr.value.substr(2, expr.value.length - 3)})`;
-			} else {
-				return `${expr.value}`;
-			}
+			return embeddedInBinding ? `(${expr.value.substr(2, expr.value.length - 3)})` : `${expr.value}`;
+
 		case "EmbeddedBinding":
-			if (embeddedInBinding) {
-				return `${embeddedSeparator}${expr.value}`;
-			} else {
-				return `${expr.value}`;
-			}
+			return embeddedInBinding ? `${embeddedSeparator}${expr.value}` : `${expr.value}`;
+
 		case "DefaultBinding":
 		case "Binding":
-			if (expr.type || expr.parameters || expr.targetType) {
-				let outBinding = "";
-				if (embeddedInBinding) {
-					outBinding += `${embeddedSeparator}`;
-				}
-				outBinding += `{path:'${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}'`;
-				if (expr.type) {
-					outBinding += `, type: '${expr.type}'`;
-				}
-				if (expr.constraints && Object.keys(expr.constraints).length > 0) {
-					outBinding += `, constraints: ${compileBinding(expr.constraints)}`;
-				}
-				if (expr.formatOptions) {
-					outBinding += `, formatOptions: ${compileBinding(expr.formatOptions)}`;
-				}
-				if (expr.parameters && Object.keys(expr.parameters).length > 0) {
-					outBinding += `, parameters: ${compileBinding(expr.parameters)}`;
-				}
-				if (expr.targetType) {
-					outBinding += `, targetType: '${expr.targetType}'`;
-				}
-				outBinding += "}";
-				return outBinding;
-			} else {
-				if (embeddedInBinding) {
-					return `${embeddedSeparator}{${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}}`;
-				} else {
-					return `{${expr.modelName ? `${expr.modelName}>` : ""}${expr.path}}`;
-				}
-			}
+			return compileBindingForBinding(expr, embeddedInBinding, embeddedSeparator);
 
 		case "Comparison":
-			const isOperand1Complex = needParenthesis(expr.operand1);
-			const isOperand2Complex = needParenthesis(expr.operand2);
-			let comparisonPart = "";
-			if (isOperand1Complex) {
-				comparisonPart += "(";
-			}
-			comparisonPart += `${compileBinding(expr.operand1, true)}`;
-			if (isOperand1Complex) {
-				comparisonPart += ")";
-			}
-			comparisonPart += ` ${expr.operator} `;
-			if (isOperand2Complex) {
-				comparisonPart += "(";
-			}
-			comparisonPart += `${compileBinding(expr.operand2, true)}`;
-			if (isOperand2Complex) {
-				comparisonPart += ")";
-			}
-			if (embeddedInBinding) {
-				return comparisonPart;
-			}
-			return `{= ${comparisonPart}}`;
+			const comparisonExpression = compileComparisonExpression(expr);
+			return wrapBindingExpression(comparisonExpression, embeddedInBinding);
 
 		case "IfElse":
-			if (embeddedInBinding) {
-				return `(${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
-					expr.onFalse,
-					true
-				)})`;
-			} else {
-				return `{= ${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
-					expr.onFalse,
-					true
-				)}}`;
-			}
+			const ifElseExpression = `${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
+				expr.onFalse,
+				true
+			)}`;
+			return wrapBindingExpression(ifElseExpression, embeddedInBinding, true);
 
 		case "Set":
-			if (embeddedInBinding) {
-				return `(${expr.operands.map(expression => compileBinding(expression, true)).join(` ${expr.operator} `)})`;
-			} else {
-				return `{= (${expr.operands.map(expression => compileBinding(expression, true)).join(` ${expr.operator} `)})}`;
-			}
+			const setExpression = expr.operands.map(operand => compileBinding(operand, true)).join(` ${expr.operator} `);
+			return wrapBindingExpression(setExpression, embeddedInBinding, true);
 
 		case "Concat":
-			if (embeddedInBinding) {
-				return `${expr.expressions.map(expression => compileBinding(expression, true, true)).join(` + `)}`;
-			} else {
-				return `{= ${expr.expressions.map(expression => compileBinding(expression, true, true)).join(` + `)} }`;
-			}
+			const concatExpression = expr.expressions.map(nestedExpression => compileBinding(nestedExpression, true, true)).join(" + ");
+			return wrapBindingExpression(concatExpression, embeddedInBinding);
+
+		case "Length":
+			const lengthExpression = `${compileBinding(expr.bindingExpression, true)}.length`;
+			return wrapBindingExpression(lengthExpression, embeddedInBinding);
 
 		case "Not":
-			if (embeddedInBinding) {
-				return `!${compileBinding(expr.operand, true)}`;
-			} else {
-				return `{= !${compileBinding(expr.operand, true)}}`;
-			}
+			const notExpression = `!${compileBinding(expr.operand, true)}`;
+			return wrapBindingExpression(notExpression, embeddedInBinding);
 
 		case "Truthy":
-			if (embeddedInBinding) {
-				return `!!${compileBinding(expr.operand, true)}`;
-			} else {
-				return `{= !!${compileBinding(expr.operand, true)}}`;
-			}
+			const truthyExpression = `!!${compileBinding(expr.operand, true)}`;
+			return wrapBindingExpression(truthyExpression, embeddedInBinding);
 
 		case "Formatter":
-			if (expr.parameters.length === 1) {
-				outProperty += `{${compilePathParameter(expr.parameters[0], true)}, formatter: '${expr.fn}'}`;
-			} else {
-				outProperty += `{parts:[${expr.parameters.map((param: any) => compilePathParameter(param)).join(",")}], formatter: '${
-					expr.fn
-				}'}`;
-			}
-			if (embeddedInBinding) {
-				outProperty = `\$${outProperty}`;
-			}
-			return outProperty;
+			const formatterExpression = compileFormatterExpression(expr);
+			return embeddedInBinding ? `\$${formatterExpression}` : formatterExpression;
+
 		case "ComplexType":
-			if (expr.bindingParameters.length === 1) {
-				outProperty += `{${compilePathParameter(expr.bindingParameters[0], true)}, type: '${expr.type}'}`;
-			} else {
-				let outputEnd;
-				// this code is based on sap.ui.model.odata.v4._AnnotationHelperExpression.fetchCurrencyOrUnit
-				switch (expr.type) {
-					case "sap.ui.model.odata.type.Unit":
-						outputEnd = `,{mode:'OneTime',path:'/##@@requestUnitsOfMeasure',targetType:'any'}],type:'sap.ui.model.odata.type.Unit'`;
-						break;
-					case "sap.ui.model.odata.type.Currency":
-						outputEnd = `,{mode:'OneTime',path:'/##@@requestCurrencyCodes',targetType:'any'}],type:'sap.ui.model.odata.type.Currency'`;
-						break;
-					default:
-						outputEnd = `], type: '${expr.type}'`;
-				}
-				if (expr.formatOptions && Object.keys(expr.formatOptions).length > 0) {
-					outputEnd += `, formatOptions: ${compileBinding(expr.formatOptions)}`;
-				}
-				if (expr.parameters && Object.keys(expr.parameters).length > 0) {
-					outputEnd += `, parameters: ${compileBinding(expr.parameters)}`;
-				}
-				outputEnd += "}";
-				outProperty += `{mode:'TwoWay', parts:[${expr.bindingParameters
-					.map((param: any) => compilePathParameter(param))
-					.join(",")}${outputEnd}`;
-			}
-			if (embeddedInBinding) {
-				outProperty = `\$${outProperty}`;
-			}
-			return outProperty;
+			const complexTypeExpression = compileComplexTypeExpression(expr);
+			return embeddedInBinding ? `\$${complexTypeExpression}` : complexTypeExpression;
+
 		default:
 			return "";
 	}
 }
 
+/**
+ * Compile a comparison expression.
+ *
+ * @param expression The comparison expression.
+ * @returns The compiled expression. Needs wrapping before it can be used as an expression binding.
+ */
+function compileComparisonExpression(expression: ComparisonExpression) {
+	function compileOperand(operand: Expression<any>) {
+		const compiledOperand = compileBinding(operand, true) ?? "undefined";
+		return wrapBindingExpression(compiledOperand, true, needParenthesis(operand));
+	}
+
+	return `${compileOperand(expression.operand1)} ${expression.operator} ${compileOperand(expression.operand2)}`;
+}
+
+/**
+ * Compile a formatter expression.
+ *
+ * @param expression The formatter expression.
+ * @returns The compiled expression.
+ */
+function compileFormatterExpression<T extends PrimitiveType>(expression: FormatterExpression<T>) {
+	if (expression.parameters.length === 1) {
+		return `{${compilePathParameter(expression.parameters[0], true)}, formatter: '${expression.fn}'}`;
+	} else {
+		const parts = expression.parameters.map(param => compilePathParameter(param));
+		return `{parts: [${parts.join(", ")}], formatter: '${expression.fn}'}`;
+	}
+}
+
 /**
  * Compile the path parameter of a formatter call.
  *
@@ -1749,53 +1742,54 @@ export function compileBinding<T extends PrimitiveType>(
  * @param singlePath Whether there is one or multiple path to consider
  * @returns {string} The string snippet to include in the overall binding definition
  */
-function compilePathParameter(expression: Expression<any>, singlePath: boolean = false): string {
+function compilePathParameter(expression: Expression<any>, singlePath = false): string {
 	let outValue = "";
-	switch (expression._type) {
-		case "Constant":
-			switch (typeof expression.value) {
-				case "number":
-				case "bigint":
-					outValue = `value: ${expression.value.toString()}`;
-					break;
-				case "string":
-					outValue = `value: '${escapeXmlAttribute(expression.value.toString())}'`;
-					break;
-				case "boolean":
-					outValue = `value: '${expression.value.toString()}'`;
-					break;
-				default:
-					outValue = "value: ''";
-					break;
-			}
-			if (singlePath) {
-				return outValue;
-			}
-			return `{${outValue}}`;
+	if (expression._type === "Constant") {
+		switch (typeof expression.value) {
+			case "number":
+			case "bigint":
+				outValue = `value: ${expression.value.toString()}`;
+				break;
+			case "string":
+				outValue = `value: '${escapeXmlAttribute(expression.value.toString())}'`;
+				break;
+			case "boolean":
+				outValue = `value: '${expression.value.toString()}'`;
+				break;
+			default:
+				outValue = "value: ''";
+				break;
+		}
+	} else if (expression._type === "DefaultBinding" || expression._type === "Binding") {
+		outValue = `path: '${compileBindingPath(expression)}'`;
 
-		case "DefaultBinding":
-		case "Binding":
-			outValue = `path:'${expression.modelName ? `${expression.modelName}>` : ""}${expression.path}'`;
+		outValue += expression.type ? `, type: '${expression.type}'` : `, targetType: 'any'`;
 
-			if (expression.type) {
-				outValue += `, type : '${expression.type}'`;
-			} else {
-				outValue += `, targetType : 'any'`;
-			}
-			if (expression.constraints && Object.keys(expression.constraints).length > 0) {
-				outValue += `, constraints: ${compileBinding(expression.constraints)}`;
-			}
-			if (expression.formatOptions && Object.keys(expression.formatOptions).length > 0) {
-				outValue += `, formatOptions: ${compileBinding(expression.formatOptions)}`;
-			}
-			if (expression.parameters && Object.keys(expression.parameters).length > 0) {
-				outValue += `, parameters: ${compileBinding(expression.parameters)}`;
-			}
-			if (singlePath) {
-				return outValue;
-			}
-			return `{${outValue}}`;
-		default:
-			return "";
+		if (hasElements(expression.constraints)) {
+			outValue += `, constraints: ${compileBinding(expression.constraints)}`;
+		}
+		if (hasElements(expression.formatOptions)) {
+			outValue += `, formatOptions: ${compileBinding(expression.formatOptions)}`;
+		}
+		if (hasElements(expression.parameters)) {
+			outValue += `, parameters: ${compileBinding(expression.parameters)}`;
+		}
+	} else {
+		return "";
 	}
+	return singlePath ? outValue : `{${outValue}}`;
+}
+
+function hasElements(obj: any) {
+	return obj && Object.keys(obj).length > 0;
+}
+
+/**
+ * Compile a binding expression path.
+ *
+ * @param expression The expression to compile.
+ * @returns The compiled path.
+ */
+function compileBindingPath<T extends PrimitiveType>(expression: BindingExpressionExpression<T> | DefaultBindingExpressionExpression<T>) {
+	return `${expression.modelName ? expression.modelName + ">" : ""}${expression.path}`;
 }