@sapui5/sap.fe.core 1.101.0 → 1.103.0

package/src/sap/fe/core/helpers/{BindingExpression.ts → BindingToolkit.ts}

@@ -1,7 +1,9 @@
-import {
+import type {
 	AndAnnotationExpression,
 	AndConditionalExpression,
+	ApplyAnnotationExpression,
 	ConditionalCheckOrValue,
+	EntitySet,
 	EntityType,
 	EqAnnotationExpression,
 	EqConditionalExpression,
@@ -21,15 +23,19 @@ import {
 	NotConditionalExpression,
 	OrAnnotationExpression,
 	OrConditionalExpression,
+	PathAnnotationExpression,
 	PathConditionExpression,
 	PropertyAnnotationValue
 } from "@sap-ux/vocabularies-types";
-import { ApplyAnnotationExpression, PathAnnotationExpression } from "@sap-ux/vocabularies-types/types/Edm";
-import { EntitySet } from "@sap-ux/vocabularies-types/dist/Converter";
 import { resolveEnumValue } from "./AnnotationEnum";
 
 type PrimitiveType = string | number | bigint | boolean | object | null | undefined;
-
+type PrimitiveTypeCast<P> =
+	| (P extends Boolean ? boolean : never)
+	| (P extends Number ? number : never)
+	| (P extends String ? string : never)
+	| P;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 type BaseExpression<T> = {
 	_type: string;
 };
@@ -43,17 +49,17 @@ type SetOperator = "&&" | "||";
 export type SetExpression = BaseExpression<boolean> & {
 	_type: "Set";
 	operator: SetOperator;
-	operands: Expression<boolean>[];
+	operands: BindingToolkitExpression<boolean>[];
 };
 
 export type NotExpression = BaseExpression<boolean> & {
 	_type: "Not";
-	operand: Expression<boolean>;
+	operand: BindingToolkitExpression<boolean>;
 };
 
 export type TruthyExpression = BaseExpression<boolean> & {
 	_type: "Truthy";
-	operand: Expression<string>;
+	operand: BindingToolkitExpression<string>;
 };
 
 export type ReferenceExpression = BaseExpression<object> & {
@@ -64,43 +70,43 @@ export type ReferenceExpression = BaseExpression<object> & {
 export type FormatterExpression<T> = BaseExpression<T> & {
 	_type: "Formatter";
 	fn: string;
-	parameters: Expression<any>[];
+	parameters: BindingToolkitExpression<any>[];
 };
 
-export type ComplexTypeExpression<T> = BaseExpression<T> & {
+type ComplexTypeExpression<T> = BaseExpression<T> & {
 	_type: "ComplexType";
 	type: string;
-	formatOptions: object;
+	formatOptions: any;
 	parameters: object;
-	bindingParameters: Expression<any>[];
+	bindingParameters: BindingToolkitExpression<any>[];
 };
 
 export type FunctionExpression<T> = BaseExpression<T> & {
 	_type: "Function";
-	obj?: Expression<object>;
+	obj?: BindingToolkitExpression<object>;
 	fn: string;
-	parameters: Expression<any>[];
+	parameters: BindingToolkitExpression<any>[];
 };
 
 export type ConcatExpression = BaseExpression<string> & {
 	_type: "Concat";
-	expressions: Expression<string>[];
+	expressions: BindingToolkitExpression<string>[];
 };
 
 export type LengthExpression = BaseExpression<string> & {
 	_type: "Length";
-	bindingExpression: BindingExpressionExpression<any>;
+	pathInModel: PathInModelExpression<any>;
 };
 
-export type UnresolveableBindingExpression = BaseExpression<string> & {
+type UnresolveablePathExpression = BaseExpression<string> & {
 	_type: "Unresolvable";
 };
 
 /**
- * @typedef BindingExpressionExpression
+ * @typedef PathInModelExpression
  */
-export type BindingExpressionExpression<T> = BaseExpression<T> & {
-	_type: "Binding";
+export type PathInModelExpression<T> = BaseExpression<T> & {
+	_type: "PathInModel";
 	modelName?: string;
 	path: string;
 	targetEntitySet?: EntitySet;
@@ -108,26 +114,16 @@ export type BindingExpressionExpression<T> = BaseExpression<T> & {
 	constraints?: any;
 	parameters?: any;
 	targetType?: string;
+	mode?: string;
 	formatOptions?: any;
 };
 
-export type DefaultBindingExpressionExpression<T> = BaseExpression<T> & {
-	_type: "DefaultBinding";
-	modelName?: string;
-	path: string;
-	type?: string;
-	constraints?: object;
-	parameters?: any;
-	targetType?: string;
-	formatOptions?: object;
-};
-
-export type EmbeddedBindingExpression<T> = BaseExpression<T> & {
+export type EmbeddedUI5BindingExpression<T> = BaseExpression<T> & {
 	_type: "EmbeddedBinding";
 	value: string;
 };
 
-export type EmbeddedExpressionBindingExpression<T> = BaseExpression<T> & {
+export type EmbeddedUI5ExpressionBindingExpression<T> = BaseExpression<T> & {
 	_type: "EmbeddedExpressionBinding";
 	value: string;
 };
@@ -136,34 +132,33 @@ type ComparisonOperator = "===" | "!==" | ">=" | ">" | "<=" | "<";
 export type ComparisonExpression = BaseExpression<boolean> & {
 	_type: "Comparison";
 	operator: ComparisonOperator;
-	operand1: Expression<any>;
-	operand2: Expression<any>;
+	operand1: BindingToolkitExpression<any>;
+	operand2: BindingToolkitExpression<any>;
 };
 
 export type IfElseExpression<T> = BaseExpression<T> & {
 	_type: "IfElse";
-	condition: Expression<boolean>;
-	onTrue: Expression<T>;
-	onFalse: Expression<T>;
+	condition: BindingToolkitExpression<boolean>;
+	onTrue: BindingToolkitExpression<T>;
+	onFalse: BindingToolkitExpression<T>;
 };
 
 /**
  * An expression that evaluates to type T.
  *
- * @typedef Expression
+ * @typedef BindingToolkitExpression
  */
-export type Expression<T> =
-	| UnresolveableBindingExpression
+export type BindingToolkitExpression<T> =
+	| UnresolveablePathExpression
 	| ConstantExpression<T>
 	| SetExpression
 	| NotExpression
 	| TruthyExpression
 	| ConcatExpression
 	| LengthExpression
-	| BindingExpressionExpression<T>
-	| EmbeddedBindingExpression<T>
-	| EmbeddedExpressionBindingExpression<T>
-	| DefaultBindingExpressionExpression<T>
+	| PathInModelExpression<T>
+	| EmbeddedUI5BindingExpression<T>
+	| EmbeddedUI5ExpressionBindingExpression<T>
 	| ComparisonExpression
 	| IfElseExpression<T>
 	| FormatterExpression<T>
@@ -174,9 +169,9 @@ export type Expression<T> =
 /**
  * An expression that evaluates to type T, or a constant value of type T
  */
-export type ExpressionOrPrimitive<T extends PrimitiveType> = Expression<T> | T;
+type ExpressionOrPrimitive<T extends PrimitiveType> = BindingToolkitExpression<T> | T;
 
-export const unresolveableExpression: UnresolveableBindingExpression = {
+export const unresolveableExpression: UnresolveablePathExpression = {
 	_type: "Unresolvable"
 };
 
@@ -184,17 +179,18 @@ function escapeXmlAttribute(inputString: string) {
 	return inputString.replace(/'/g, "\\'");
 }
 
-export function hasUnresolveableExpression(...expressions: Expression<any>[]): boolean {
-	return expressions.find(expr => expr._type === "Unresolvable") !== undefined;
+export function hasUnresolveableExpression(...expressions: BindingToolkitExpression<any>[]): boolean {
+	return expressions.find((expr) => expr._type === "Unresolvable") !== undefined;
 }
 /**
  * Check two expressions for (deep) equality.
  *
  * @param a
  * @param b
- * @returns {boolean} `true` if the two expressions are equal
+ * @returns `true` if the two expressions are equal
+ * @private
  */
-export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>): boolean {
+export function _checkExpressionsAreEqual<T>(a: BindingToolkitExpression<T>, b: BindingToolkitExpression<T>): boolean {
 	if (a._type !== b._type) {
 		return false;
 	}
@@ -215,8 +211,8 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 			return (
 				a.operator === (b as SetExpression).operator &&
 				a.operands.length === (b as SetExpression).operands.length &&
-				a.operands.every(expression =>
-					(b as SetExpression).operands.some(otherExpression => _checkExpressionsAreEqual(expression, otherExpression))
+				a.operands.every((expression) =>
+					(b as SetExpression).operands.some((otherExpression) => _checkExpressionsAreEqual(expression, otherExpression))
 				)
 			);
 
@@ -245,19 +241,13 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
 			});
 
 		case "Length":
-			return _checkExpressionsAreEqual(a.bindingExpression, (b as LengthExpression).bindingExpression);
-
-		case "Binding":
-			return (
-				a.modelName === (b as BindingExpressionExpression<T>).modelName &&
-				a.path === (b as BindingExpressionExpression<T>).path &&
-				a.targetEntitySet === (b as BindingExpressionExpression<T>).targetEntitySet
-			);
+			return _checkExpressionsAreEqual(a.pathInModel, (b as LengthExpression).pathInModel);
 
-		case "DefaultBinding":
+		case "PathInModel":
 			return (
-				a.modelName === (b as DefaultBindingExpressionExpression<T>).modelName &&
-				a.path === (b as DefaultBindingExpressionExpression<T>).path
+				a.modelName === (b as PathInModelExpression<T>).modelName &&
+				a.path === (b as PathInModelExpression<T>).path &&
+				a.targetEntitySet === (b as PathInModelExpression<T>).targetEntitySet
 			);
 
 		case "Formatter":
@@ -297,15 +287,15 @@ export function _checkExpressionsAreEqual<T>(a: Expression<T>, b: Expression<T>)
  * Converts a nested SetExpression by inlining operands of type SetExpression with the same operator.
  *
  * @param expression The expression to flatten
- * @returns {SetExpression} A new SetExpression with the same operator
+ * @returns A new SetExpression with the same operator
  */
 function flattenSetExpression(expression: SetExpression): SetExpression {
 	return expression.operands.reduce(
 		(result: SetExpression, operand) => {
 			const candidatesForFlattening =
 				operand._type === "Set" && operand.operator === expression.operator ? operand.operands : [operand];
-			candidatesForFlattening.forEach(candidate => {
-				if (result.operands.every(e => !_checkExpressionsAreEqual(e, candidate))) {
+			candidatesForFlattening.forEach((candidate) => {
+				if (result.operands.every((e) => !_checkExpressionsAreEqual(e, candidate))) {
 					result.operands.push(candidate);
 				}
 			});
@@ -319,9 +309,9 @@ function flattenSetExpression(expression: SetExpression): SetExpression {
  * Detects whether an array of boolean expressions contains an expression and its negation.
  *
  * @param expressions Array of expressions
- * @returns {boolean} `true` if the set of expressions contains an expression and its negation
+ * @returns `true` if the set of expressions contains an expression and its negation
  */
-function hasOppositeExpressions(expressions: Expression<boolean>[]): boolean {
+function hasOppositeExpressions(expressions: BindingToolkitExpression<boolean>[]): boolean {
 	const negatedExpressions = expressions.map(not);
 	return expressions.some((expression, index) => {
 		for (let i = index + 1; i < negatedExpressions.length; i++) {
@@ -340,9 +330,9 @@ function hasOppositeExpressions(expressions: Expression<boolean>[]): boolean {
  * false or if the expression contains an operand and its negation).
  *
  * @param operands Expressions to connect by `and`
- * @returns {Expression<boolean>} Expression evaluating to boolean
+ * @returns Expression evaluating to boolean
  */
-export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<boolean> {
+export function and(...operands: ExpressionOrPrimitive<boolean>[]): BindingToolkitExpression<boolean> {
 	const expressions = flattenSetExpression({
 		_type: "Set",
 		operator: "&&",
@@ -353,7 +343,7 @@ export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<b
 		return unresolveableExpression;
 	}
 	let isStaticFalse = false;
-	const nonTrivialExpression = expressions.filter(expression => {
+	const nonTrivialExpression = expressions.filter((expression) => {
 		if (isFalse(expression)) {
 			isStaticFalse = true;
 		}
@@ -385,9 +375,9 @@ export function and(...operands: ExpressionOrPrimitive<boolean>[]): Expression<b
  * true or if the expression contains an operand and its negation).
  *
  * @param operands Expressions to connect by `or`
- * @returns {Expression<boolean>} Expression evaluating to boolean
+ * @returns Expression evaluating to boolean
  */
-export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<boolean> {
+export function or(...operands: ExpressionOrPrimitive<boolean>[]): BindingToolkitExpression<boolean> {
 	const expressions = flattenSetExpression({
 		_type: "Set",
 		operator: "||",
@@ -397,7 +387,7 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<bo
 		return unresolveableExpression;
 	}
 	let isStaticTrue = false;
-	const nonTrivialExpression = expressions.filter(expression => {
+	const nonTrivialExpression = expressions.filter((expression) => {
 		if (isTrue(expression)) {
 			isStaticTrue = true;
 		}
@@ -426,9 +416,9 @@ export function or(...operands: ExpressionOrPrimitive<boolean>[]): Expression<bo
  * Logical `not` operator.
  *
  * @param operand The expression to reverse
- * @returns {Expression<boolean>} The resulting expression that evaluates to boolean
+ * @returns The resulting expression that evaluates to boolean
  */
-export function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean> {
+export function not(operand: ExpressionOrPrimitive<boolean>): BindingToolkitExpression<boolean> {
 	operand = wrapPrimitive(operand);
 	if (hasUnresolveableExpression(operand)) {
 		return unresolveableExpression;
@@ -438,16 +428,16 @@ export function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean
 		typeof operand === "object" &&
 		operand._type === "Set" &&
 		operand.operator === "||" &&
-		operand.operands.every(expression => isConstant(expression) || isComparison(expression))
+		operand.operands.every((expression) => isConstant(expression) || isComparison(expression))
 	) {
-		return and(...operand.operands.map(expression => not(expression)));
+		return and(...operand.operands.map((expression) => not(expression)));
 	} else if (
 		typeof operand === "object" &&
 		operand._type === "Set" &&
 		operand.operator === "&&" &&
-		operand.operands.every(expression => isConstant(expression) || isComparison(expression))
+		operand.operands.every((expression) => isConstant(expression) || isComparison(expression))
 	) {
-		return or(...operand.operands.map(expression => not(expression)));
+		return or(...operand.operands.map((expression) => not(expression)));
 	} else if (isComparison(operand)) {
 		// Create the reverse comparison
 		switch (operand.operator) {
@@ -478,9 +468,9 @@ export function not(operand: ExpressionOrPrimitive<boolean>): Expression<boolean
  * Evaluates whether a binding expression is equal to true with a loose equality.
  *
  * @param operand The expression to check
- * @returns {Expression<boolean>} The resulting expression that evaluates to boolean
+ * @returns The resulting expression that evaluates to boolean
  */
-export function isTruthy(operand: Expression<string>): Expression<boolean> {
+export function isTruthy(operand: BindingToolkitExpression<string>): BindingToolkitExpression<boolean> {
 	if (isConstant(operand)) {
 		return constant(!!operand.value);
 	} else {
@@ -491,6 +481,25 @@ export function isTruthy(operand: Expression<string>): Expression<boolean> {
 	}
 }
 
+/**
+ * Creates a binding expression that will be evaluated by the corresponding model.
+ *
+ * @param path
+ * @param modelName
+ * @param visitedNavigationPaths
+ * @param pathVisitor
+ * @returns An expression representating that path in the model
+ * @deprecated use pathInModel instead
+ */
+export function bindingExpression<TargetType extends PrimitiveType>(
+	path: any,
+	modelName?: string,
+	visitedNavigationPaths: string[] = [],
+	pathVisitor?: Function
+): PathInModelExpression<TargetType> | UnresolveablePathExpression {
+	return pathInModel(path, modelName, visitedNavigationPaths, pathVisitor);
+}
+
 /**
  * Creates a binding expression that will be evaluated by the corresponding model.
  *
@@ -499,14 +508,38 @@ export function isTruthy(operand: Expression<string>): Expression<boolean> {
  * @param [modelName] The name of the model
  * @param [visitedNavigationPaths] The paths from the root entitySet
  * @param [pathVisitor] A function to modify the resulting path
- * @returns {BindingExpressionExpression<TargetType>} The default binding expression
+ * @returns An expression representating that path in the model
  */
-export function bindingExpression<TargetType extends PrimitiveType>(
+export function pathInModel(
+	path: undefined,
+	modelName?: string,
+	visitedNavigationPaths?: string[],
+	pathVisitor?: Function
+): UnresolveablePathExpression;
+export function pathInModel<TargetType extends PrimitiveType>(
+	path: string,
+	modelName?: string,
+	visitedNavigationPaths?: string[],
+	pathVisitor?: undefined
+): PathInModelExpression<TargetType>;
+export function pathInModel<TargetType extends PrimitiveType>(
+	path: string,
+	modelName?: string,
+	visitedNavigationPaths?: string[],
+	pathVisitor?: Function
+): UnresolveablePathExpression | PathInModelExpression<TargetType>;
+export function pathInModel<TargetType extends PrimitiveType>(
+	path: string | undefined,
+	modelName?: string,
+	visitedNavigationPaths?: string[],
+	pathVisitor?: Function
+): UnresolveablePathExpression | PathInModelExpression<TargetType>;
+export function pathInModel<TargetType extends PrimitiveType>(
 	path: string | undefined,
 	modelName?: string,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
-): BindingExpressionExpression<TargetType> | UnresolveableBindingExpression {
+): UnresolveablePathExpression | PathInModelExpression<TargetType> {
 	if (path === undefined) {
 		return unresolveableExpression;
 	}
@@ -522,20 +555,20 @@ export function bindingExpression<TargetType extends PrimitiveType>(
 		targetPath = localPath.join("/");
 	}
 	return {
-		_type: "Binding",
+		_type: "PathInModel",
 		modelName: modelName,
 		path: targetPath
 	};
 }
 
-type PlainExpressionObject = { [index: string]: Expression<any> };
+type PlainExpressionObject = { [index: string]: BindingToolkitExpression<any> };
 
 /**
  * Creates a constant expression based on a primitive value.
  *
  * @template T
  * @param value The constant to wrap in an expression
- * @returns {ConstantExpression<T>} The constant expression
+ * @returns The constant expression
  */
 export function constant<T extends PrimitiveType>(value: T): ConstantExpression<T> {
 	let constantValue: T;
@@ -565,7 +598,7 @@ type EvaluationType = "boolean";
 export function resolveBindingString<T extends PrimitiveType>(
 	value: string | boolean | number,
 	targetType?: EvaluationType
-): ConstantExpression<T> | EmbeddedBindingExpression<T> | EmbeddedExpressionBindingExpression<T> {
+): ConstantExpression<T> | EmbeddedUI5BindingExpression<T> | EmbeddedUI5ExpressionBindingExpression<T> {
 	if (value !== undefined && typeof value === "string" && value.startsWith("{")) {
 		if (value.startsWith("{=")) {
 			// Expression binding, we can just remove the outer binding things
@@ -590,9 +623,8 @@ export function resolveBindingString<T extends PrimitiveType>(
  * A named reference.
  *
  * @see fn
- *
  * @param reference Reference
- * @returns {ReferenceExpression} The object reference binding part
+ * @returns The object reference binding part
  */
 export function ref(reference: string | null): ReferenceExpression {
 	return { _type: "Ref", ref: reference };
@@ -605,9 +637,9 @@ export function ref(reference: string | null): ReferenceExpression {
  * no such expression type supported.
  *
  * @param something Type to check
- * @returns {boolean} `true` if the type is considered to be an expression
+ * @returns `true` if the type is considered to be an expression
  */
-function isExpression<T extends PrimitiveType>(something: ExpressionOrPrimitive<T>): something is Expression<T> {
+function isExpression<T extends PrimitiveType>(something: ExpressionOrPrimitive<T>): something is BindingToolkitExpression<T> {
 	return something !== null && typeof something === "object" && (something as BaseExpression<T>)._type !== undefined;
 }
 
@@ -616,9 +648,9 @@ function isExpression<T extends PrimitiveType>(something: ExpressionOrPrimitive<
  *
  * @template T
  * @param something The object to wrap in a Constant expression
- * @returns {Expression<T>} Either the original object or the wrapped one depending on the case
+ * @returns Either the original object or the wrapped one depending on the case
  */
-function wrapPrimitive<T extends PrimitiveType>(something: ExpressionOrPrimitive<T>): Expression<T> {
+function wrapPrimitive<T extends PrimitiveType>(something: ExpressionOrPrimitive<T>): BindingToolkitExpression<T> {
 	if (isExpression(something)) {
 		return something;
 	}
@@ -631,29 +663,44 @@ function wrapPrimitive<T extends PrimitiveType>(something: ExpressionOrPrimitive
  *
  * @template T The target type
  * @param  maybeConstant The expression or primitive value that is to be checked
- * @returns {boolean} `true` if it is constant
+ * @returns `true` if it is constant
  */
 export function isConstant<T extends PrimitiveType>(maybeConstant: ExpressionOrPrimitive<T>): maybeConstant is ConstantExpression<T> {
 	return typeof maybeConstant !== "object" || (maybeConstant as BaseExpression<T>)._type === "Constant";
 }
 
-function isTrue(expression: Expression<PrimitiveType>) {
+function isTrue(expression: BindingToolkitExpression<PrimitiveType>) {
 	return isConstant(expression) && expression.value === true;
 }
 
-function isFalse(expression: Expression<PrimitiveType>) {
+function isFalse(expression: BindingToolkitExpression<PrimitiveType>) {
 	return isConstant(expression) && expression.value === false;
 }
 
 /**
- * Checks if the expression or value provided is binding or not.
+ * Checks if the expression or value provided is a path in model expression or not.
+ *
+ * @template T The target type
+ * @param  maybeBinding The expression or primitive value that is to be checked
+ * @returns `true` if it is a path in model expression
+ */
+export function isPathInModelExpression<T extends PrimitiveType>(
+	maybeBinding: ExpressionOrPrimitive<T>
+): maybeBinding is PathInModelExpression<T> {
+	return typeof maybeBinding === "object" && (maybeBinding as BaseExpression<T>)._type === "PathInModel";
+}
+
+/**
+ * Checks if the expression or value provided is a complex type expression.
  *
  * @template T The target type
  * @param  maybeBinding The expression or primitive value that is to be checked
- * @returns {boolean} `true` if it is binding
+ * @returns `true` if it is a path in model expression
  */
-export function isBinding<T extends PrimitiveType>(maybeBinding: ExpressionOrPrimitive<T>): maybeBinding is BindingExpressionExpression<T> {
-	return typeof maybeBinding === "object" && (maybeBinding as BaseExpression<T>)._type === "Binding";
+export function isComplexTypeExpression<T extends PrimitiveType>(
+	maybeBinding: ExpressionOrPrimitive<T>
+): maybeBinding is ComplexTypeExpression<T> {
+	return typeof maybeBinding === "object" && (maybeBinding as BaseExpression<T>)._type === "ComplexType";
 }
 
 /**
@@ -661,9 +708,9 @@ export function isBinding<T extends PrimitiveType>(maybeBinding: ExpressionOrPri
  *
  * @template T The target type
  * @param expression The expression
- * @returns {boolean} `true` if the expression is a ComparisonExpression
+ * @returns `true` if the expression is a ComparisonExpression
  */
-function isComparison<T extends PrimitiveType>(expression: Expression<T>): expression is ComparisonExpression {
+function isComparison<T extends PrimitiveType>(expression: BindingToolkitExpression<T>): expression is ComparisonExpression {
 	return expression._type === "Comparison";
 }
 
@@ -696,7 +743,7 @@ function isPrimitiveObject(objectType: object): boolean {
  *
  * @template T The target type
  * @param  annotationValue The annotation annotationValue to evaluate
- * @returns {boolean} `true` if the object is a {ComplexAnnotationExpression}
+ * @returns `true` if the object is a {ComplexAnnotationExpression}
  */
 function isComplexAnnotationExpression<T>(annotationValue: PropertyAnnotationValue<T>): annotationValue is ComplexAnnotationExpression<T> {
 	return typeof annotationValue === "object" && !isPrimitiveObject(annotationValue as object);
@@ -710,14 +757,33 @@ function isComplexAnnotationExpression<T>(annotationValue: PropertyAnnotationVal
  * @param visitedNavigationPaths The path from the root entity set
  * @param defaultValue Default value if the annotationValue is undefined
  * @param pathVisitor A function to modify the resulting path
- * @returns {Expression<T>} The annotationValue equivalent to that annotation annotationValue
+ * @returns The annotationValue equivalent to that annotation annotationValue
+ * @deprecated use getExpressionFromAnnotation instead
  */
 export function annotationExpression<T extends PrimitiveType>(
 	annotationValue: PropertyAnnotationValue<T>,
 	visitedNavigationPaths: string[] = [],
 	defaultValue?: ExpressionOrPrimitive<T>,
 	pathVisitor?: Function
-): Expression<T> {
+): BindingToolkitExpression<PrimitiveTypeCast<T>> {
+	return getExpressionFromAnnotation(annotationValue, visitedNavigationPaths, defaultValue, pathVisitor);
+}
+/**
+ * Generate the corresponding annotationValue for a given annotation annotationValue.
+ *
+ * @template T The target type
+ * @param annotationValue The source annotation annotationValue
+ * @param visitedNavigationPaths The path from the root entity set
+ * @param defaultValue Default value if the annotationValue is undefined
+ * @param pathVisitor A function to modify the resulting path
+ * @returns The annotationValue equivalent to that annotation annotationValue
+ */
+export function getExpressionFromAnnotation<T extends PrimitiveType>(
+	annotationValue: PropertyAnnotationValue<T>,
+	visitedNavigationPaths: string[] = [],
+	defaultValue?: ExpressionOrPrimitive<T>,
+	pathVisitor?: Function
+): BindingToolkitExpression<PrimitiveTypeCast<T>> {
 	if (annotationValue === undefined) {
 		return wrapPrimitive(defaultValue as T);
 	}
@@ -728,59 +794,59 @@ export function annotationExpression<T extends PrimitiveType>(
 
 	switch (annotationValue.type) {
 		case "Path":
-			return bindingExpression(annotationValue.path, undefined, visitedNavigationPaths, pathVisitor);
+			return pathInModel(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>;
+			return not(parseAnnotationCondition(annotationValue.Not, visitedNavigationPaths, pathVisitor)) as BindingToolkitExpression<T>;
 		case "Eq":
 			return equal(
 				parseAnnotationCondition(annotationValue.Eq[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Eq[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Ne":
 			return notEqual(
 				parseAnnotationCondition(annotationValue.Ne[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Ne[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Gt":
 			return greaterThan(
 				parseAnnotationCondition(annotationValue.Gt[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Gt[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Ge":
 			return greaterOrEqual(
 				parseAnnotationCondition(annotationValue.Ge[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Ge[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Lt":
 			return lessThan(
 				parseAnnotationCondition(annotationValue.Lt[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Lt[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Le":
 			return lessOrEqual(
 				parseAnnotationCondition(annotationValue.Le[0], visitedNavigationPaths, pathVisitor),
 				parseAnnotationCondition(annotationValue.Le[1], visitedNavigationPaths, pathVisitor)
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 		case "Or":
 			return or(
-				...(annotationValue.Or.map(function(orCondition) {
-					return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
-				}) as Expression<boolean>[])
-			) as Expression<T>;
+				...annotationValue.Or.map(function (orCondition) {
+					return parseAnnotationCondition<boolean>(orCondition, visitedNavigationPaths, pathVisitor);
+				})
+			) as BindingToolkitExpression<T>;
 		case "And":
 			return and(
-				...(annotationValue.And.map(function(andCondition) {
-					return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
-				}) as Expression<boolean>[])
-			) as Expression<T>;
+				...annotationValue.And.map(function (andCondition) {
+					return parseAnnotationCondition<boolean>(andCondition, visitedNavigationPaths, pathVisitor);
+				})
+			) as BindingToolkitExpression<T>;
 		case "Apply":
 			return annotationApplyExpression(
 				annotationValue as ApplyAnnotationExpression<string>,
 				visitedNavigationPaths,
 				pathVisitor
-			) as Expression<T>;
+			) as BindingToolkitExpression<T>;
 	}
 	return unresolveableExpression;
 }
@@ -792,65 +858,65 @@ export function annotationExpression<T extends PrimitiveType>(
  * @param annotationValue The condition or value from the annotation
  * @param visitedNavigationPaths The path from the root entity set
  * @param pathVisitor A function to modify the resulting path
- * @returns {Expression<T>} An equivalent expression
+ * @returns An equivalent expression
  */
 function parseAnnotationCondition<T extends PrimitiveType>(
 	annotationValue: ConditionalCheckOrValue,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
-): Expression<T> {
+): BindingToolkitExpression<T> {
 	if (annotationValue === null || typeof annotationValue !== "object") {
 		return constant(annotationValue as T);
 	} else if (annotationValue.hasOwnProperty("$Or")) {
 		return or(
-			...(((annotationValue as OrConditionalExpression).$Or.map(function(orCondition) {
+			...((annotationValue as OrConditionalExpression).$Or.map(function (orCondition) {
 				return parseAnnotationCondition(orCondition, visitedNavigationPaths, pathVisitor);
-			}) as unknown) as Expression<boolean>[])
-		) as Expression<T>;
+			}) as unknown as BindingToolkitExpression<boolean>[])
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$And")) {
 		return and(
-			...(((annotationValue as AndConditionalExpression).$And.map(function(andCondition) {
+			...((annotationValue as AndConditionalExpression).$And.map(function (andCondition) {
 				return parseAnnotationCondition(andCondition, visitedNavigationPaths, pathVisitor);
-			}) as unknown) as Expression<boolean>[])
-		) as Expression<T>;
+			}) as unknown as BindingToolkitExpression<boolean>[])
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Not")) {
 		return not(
 			parseAnnotationCondition((annotationValue as NotConditionalExpression).$Not[0], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Eq")) {
 		return equal(
 			parseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as EqConditionalExpression).$Eq[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Ne")) {
 		return notEqual(
 			parseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as NeConditionalExpression).$Ne[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Gt")) {
 		return greaterThan(
 			parseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as GtConditionalExpression).$Gt[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Ge")) {
 		return greaterOrEqual(
 			parseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as GeConditionalExpression).$Ge[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Lt")) {
 		return lessThan(
 			parseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as LtConditionalExpression).$Lt[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Le")) {
 		return lessOrEqual(
 			parseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[0], visitedNavigationPaths, pathVisitor),
 			parseAnnotationCondition((annotationValue as LeConditionalExpression).$Le[1], visitedNavigationPaths, pathVisitor)
-		) as Expression<T>;
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$Path")) {
-		return bindingExpression((annotationValue as PathConditionExpression<T>).$Path, undefined, visitedNavigationPaths, pathVisitor);
+		return pathInModel((annotationValue as PathConditionExpression<T>).$Path, undefined, visitedNavigationPaths, pathVisitor);
 	} else if (annotationValue.hasOwnProperty("$Apply")) {
-		return annotationExpression(
+		return getExpressionFromAnnotation(
 			{
 				type: "Apply",
 				Function: (annotationValue as any).$Function,
@@ -859,9 +925,9 @@ function parseAnnotationCondition<T extends PrimitiveType>(
 			visitedNavigationPaths,
 			undefined,
 			pathVisitor
-		);
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$If")) {
-		return annotationExpression(
+		return getExpressionFromAnnotation(
 			{
 				type: "If",
 				If: (annotationValue as any).$If
@@ -869,7 +935,7 @@ function parseAnnotationCondition<T extends PrimitiveType>(
 			visitedNavigationPaths,
 			undefined,
 			pathVisitor
-		);
+		) as BindingToolkitExpression<T>;
 	} else if (annotationValue.hasOwnProperty("$EnumMember")) {
 		return constant(resolveEnumValue((annotationValue as any).$EnumMember) as T);
 	}
@@ -883,13 +949,13 @@ function parseAnnotationCondition<T extends PrimitiveType>(
  * @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
+ * @returns The equivalent ifElse expression
  */
 export function annotationIfExpression<T extends PrimitiveType>(
 	annotationValue: IfAnnotationExpressionValue<T>,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
-): Expression<T> {
+): BindingToolkitExpression<T> {
 	return ifElse(
 		parseAnnotationCondition(annotationValue[0], visitedNavigationPaths, pathVisitor),
 		parseAnnotationCondition(annotationValue[1] as any, visitedNavigationPaths, pathVisitor),
@@ -901,7 +967,7 @@ export function annotationApplyExpression(
 	applyExpression: ApplyAnnotationExpression<string>,
 	visitedNavigationPaths: string[] = [],
 	pathVisitor?: Function
-): Expression<string> {
+): BindingToolkitExpression<string> {
 	switch (applyExpression.Function) {
 		case "odata.concat":
 			return concat(
@@ -924,7 +990,7 @@ export function annotationApplyExpression(
 							Apply: applyParam.$Apply
 						};
 					}
-					return annotationExpression(applyParamConverted, visitedNavigationPaths, undefined, pathVisitor);
+					return getExpressionFromAnnotation(applyParamConverted, visitedNavigationPaths, undefined, pathVisitor);
 				})
 			);
 	}
@@ -938,13 +1004,13 @@ export function annotationApplyExpression(
  * @param operator The operator to apply
  * @param leftOperand The operand on the left side of the operator
  * @param rightOperand The operand on the right side of the operator
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 function comparison<T extends PrimitiveType>(
 	operator: ComparisonOperator,
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const leftExpression = wrapPrimitive(leftOperand);
 	const rightExpression = wrapPrimitive(rightOperand);
 	if (hasUnresolveableExpression(leftExpression, rightExpression)) {
@@ -975,13 +1041,13 @@ function comparison<T extends PrimitiveType>(
 	}
 }
 
-export function length(expression: BindingExpressionExpression<any> | UnresolveableBindingExpression): Expression<number> {
+export function length(expression: PathInModelExpression<any> | UnresolveablePathExpression): BindingToolkitExpression<number> {
 	if (expression._type === "Unresolvable") {
 		return expression;
 	}
 	return {
 		_type: "Length",
-		bindingExpression: expression
+		pathInModel: expression
 	};
 }
 
@@ -991,12 +1057,12 @@ export function length(expression: BindingExpressionExpression<any> | Unresolvea
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function equal<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	const leftExpression = wrapPrimitive(leftOperand);
 	const rightExpression = wrapPrimitive(rightOperand);
 	if (hasUnresolveableExpression(leftExpression, rightExpression)) {
@@ -1006,7 +1072,7 @@ export function equal<T extends PrimitiveType>(
 		return constant(true);
 	}
 
-	function reduce(left: Expression<T>, right: Expression<T>) {
+	function reduce(left: BindingToolkitExpression<T>, right: BindingToolkitExpression<T>) {
 		if (left._type === "Comparison" && isTrue(right)) {
 			// compare(a, b) === true ~~> compare(a, b)
 			return left;
@@ -1043,12 +1109,12 @@ export function equal<T extends PrimitiveType>(
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function notEqual<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	return not(equal(leftOperand, rightOperand));
 }
 
@@ -1058,12 +1124,12 @@ export function notEqual<T extends PrimitiveType>(
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function greaterOrEqual<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	return comparison(">=", leftOperand, rightOperand);
 }
 
@@ -1073,12 +1139,12 @@ export function greaterOrEqual<T extends PrimitiveType>(
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function greaterThan<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	return comparison(">", leftOperand, rightOperand);
 }
 
@@ -1088,12 +1154,12 @@ export function greaterThan<T extends PrimitiveType>(
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function lessOrEqual<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	return comparison("<=", leftOperand, rightOperand);
 }
 
@@ -1103,12 +1169,12 @@ export function lessOrEqual<T extends PrimitiveType>(
  * @template T The target type
  * @param leftOperand The operand on the left side
  * @param rightOperand The operand on the right side of the comparison
- * @returns {Expression<boolean>} An expression representing the comparison
+ * @returns An expression representing the comparison
  */
 export function lessThan<T extends PrimitiveType>(
 	leftOperand: ExpressionOrPrimitive<T>,
 	rightOperand: ExpressionOrPrimitive<T>
-): Expression<boolean> {
+): BindingToolkitExpression<boolean> {
 	return comparison("<", leftOperand, rightOperand);
 }
 
@@ -1121,13 +1187,13 @@ export function lessThan<T extends PrimitiveType>(
  * @param condition The condition to evaluate
  * @param onTrue Expression result if the condition evaluates to true
  * @param onFalse Expression result if the condition evaluates to false
- * @returns {Expression<T>} The expression that represents this conditional check
+ * @returns The expression that represents this conditional check
  */
 export function ifElse<T extends PrimitiveType>(
 	condition: ExpressionOrPrimitive<boolean>,
 	onTrue: ExpressionOrPrimitive<T>,
 	onFalse: ExpressionOrPrimitive<T>
-): Expression<T> {
+): BindingToolkitExpression<T> {
 	let conditionExpression = wrapPrimitive(condition);
 	let onTrueExpression = wrapPrimitive(onTrue);
 	let onFalseExpression = wrapPrimitive(onFalse);
@@ -1170,22 +1236,22 @@ export function ifElse<T extends PrimitiveType>(
 
 	// if X then a else false ~~> X && a
 	if (isFalse(onFalseExpression)) {
-		return and(conditionExpression, onTrueExpression as Expression<boolean>) as Expression<T>;
+		return and(conditionExpression, onTrueExpression as BindingToolkitExpression<boolean>) as BindingToolkitExpression<T>;
 	}
 
 	// if X then a else true ~~> !X || a
 	if (isTrue(onFalseExpression)) {
-		return or(not(conditionExpression), onTrueExpression as Expression<boolean>) as Expression<T>;
+		return or(not(conditionExpression), onTrueExpression as BindingToolkitExpression<boolean>) as BindingToolkitExpression<T>;
 	}
 
 	// if X then false else a ~~> !X && a
 	if (isFalse(onTrueExpression)) {
-		return and(not(conditionExpression), onFalseExpression as Expression<boolean>) as Expression<T>;
+		return and(not(conditionExpression), onFalseExpression as BindingToolkitExpression<boolean>) as BindingToolkitExpression<T>;
 	}
 
 	// if X then true else a ~~> X || a
 	if (isTrue(onTrueExpression)) {
-		return or(conditionExpression, onFalseExpression as Expression<boolean>) as Expression<T>;
+		return or(conditionExpression, onFalseExpression as BindingToolkitExpression<boolean>) as BindingToolkitExpression<T>;
 	}
 
 	return {
@@ -1200,9 +1266,9 @@ export function ifElse<T extends PrimitiveType>(
  * Checks whether the current expression has a reference to the default model (undefined).
  *
  * @param expression The expression to evaluate
- * @returns {boolean} `true` if there is a reference to the default context
+ * @returns `true` if there is a reference to the default context
  */
-function hasReferenceToDefaultContext(expression: Expression<any>): boolean {
+function hasReferenceToDefaultContext(expression: BindingToolkitExpression<any>): boolean {
 	switch (expression._type) {
 		case "Constant":
 		case "Formatter":
@@ -1210,12 +1276,10 @@ function hasReferenceToDefaultContext(expression: Expression<any>): boolean {
 			return false;
 		case "Set":
 			return expression.operands.some(hasReferenceToDefaultContext);
-		case "Binding":
+		case "PathInModel":
 			return expression.modelName === undefined;
 		case "Comparison":
 			return hasReferenceToDefaultContext(expression.operand1) || hasReferenceToDefaultContext(expression.operand2);
-		case "DefaultBinding":
-			return true;
 		case "IfElse":
 			return (
 				hasReferenceToDefaultContext(expression.condition) ||
@@ -1262,27 +1326,32 @@ type FunctionParameters<T, F extends FunctionOrName<T>> = F extends Fn<T> ? Para
  * @param parameters The list of parameter that should match the type and number of the formatter function
  * @param formatterFunction The function to call
  * @param [contextEntityType] The context entity type to consider
- * @returns {Expression<T>} The corresponding expression
+ * @returns The corresponding expression
  */
 export function formatResult<T, U extends Fn<T>>(
 	parameters: WrappedTuple<Parameters<U>>,
-	formatterFunction: U,
+	formatterFunction: U | string,
 	contextEntityType?: EntityType
-): Expression<T> {
+): BindingToolkitExpression<T> {
 	const parameterExpressions = (parameters as any[]).map(wrapPrimitive);
 
 	if (hasUnresolveableExpression(...parameterExpressions)) {
 		return unresolveableExpression;
 	}
-	if (!!contextEntityType) {
+	if (contextEntityType) {
 		// Otherwise, if the context is required and no context is provided make sure to add the default binding
 		if (!parameterExpressions.some(hasReferenceToDefaultContext)) {
-			contextEntityType.keys.forEach(key => parameterExpressions.push(bindingExpression(key.name, "")));
+			contextEntityType.keys.forEach((key) => parameterExpressions.push(pathInModel(key.name, "")));
 		}
 	}
-
+	let functionName = "";
+	if (typeof formatterFunction === "string") {
+		functionName = formatterFunction;
+	} else {
+		functionName = formatterFunction.__functionName;
+	}
 	// FormatterName can be of format sap.fe.core.xxx#methodName to have multiple formatter in one class
-	const [formatterClass, formatterName] = formatterFunction.__functionName.split("#");
+	const [formatterClass, formatterName] = functionName.split("#");
 
 	if (!!formatterName && formatterName.length > 0) {
 		parameterExpressions.unshift(constant(formatterName));
@@ -1301,16 +1370,18 @@ export function formatResult<T, U extends Fn<T>>(
  *
  * @template T
  * @template U
- * @param parameters The list of parameter that should match the type for the compplex type
+ * @param parameters The list of parameter that should match the type for the compplex type=
  * @param type The complex type to use
  * @param [contextEntityType] The context entity type to consider
- * @returns {Expression<T>} The corresponding expression
+ * @param oFormatOptions
+ * @returns The corresponding expression
  */
 export function addTypeInformation<T, U extends Fn<T>>(
 	parameters: WrappedTuple<Parameters<U>>,
 	type: string,
-	contextEntityType?: EntityType
-): Expression<T> {
+	contextEntityType?: EntityType,
+	oFormatOptions?: any
+): UnresolveablePathExpression | ComplexTypeExpression<T> | ConstantExpression<T> {
 	const parameterExpressions = (parameters as any[]).map(wrapPrimitive);
 	if (hasUnresolveableExpression(...parameterExpressions)) {
 		return unresolveableExpression;
@@ -1318,19 +1389,42 @@ export function addTypeInformation<T, U extends Fn<T>>(
 	// If there is only one parameter and it is a constant and we don't expect the context then return the constant
 	if (parameterExpressions.length === 1 && isConstant(parameterExpressions[0]) && !contextEntityType) {
 		return parameterExpressions[0];
-	} else if (!!contextEntityType) {
+	} else if (contextEntityType) {
 		// Otherwise, if the context is required and no context is provided make sure to add the default binding
 		if (!parameterExpressions.some(hasReferenceToDefaultContext)) {
-			contextEntityType.keys.forEach(key => parameterExpressions.push(bindingExpression(key.name, "")));
+			contextEntityType.keys.forEach((key) => parameterExpressions.push(pathInModel(key.name, "")));
+		}
+	}
+	// if showMeasure is set to false we want to not parse as string to see the 0
+	if (
+		oFormatOptions?.showMeasure === false &&
+		((parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Int") === 0 ||
+			(parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Decimal") === 0 ||
+			(parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Double") === 0)
+	) {
+		if ((parameters[0] as any)?.type === "sap.ui.model.odata.type.Int64") {
+			//sap.ui.model.odata.type.Int64 do not support parseAsString false
+			oFormatOptions = { emptyString: "", showMeasure: false };
+		} else {
+			oFormatOptions = { parseAsString: false, emptyString: "", showMeasure: false };
 		}
 	}
+	if (type === "sap.ui.model.odata.type.Unit") {
+		const uomPath = pathInModel("/##@@requestUnitsOfMeasure");
+		uomPath.targetType = "any";
+		uomPath.mode = "OneTime";
+		parameterExpressions.push(uomPath);
+	} else if (type === "sap.ui.model.odata.type.Currency") {
+		const currencyPath = pathInModel("/##@@requestCurrencyCodes");
+		currencyPath.targetType = "any";
+		currencyPath.mode = "OneTime";
+		parameterExpressions.push(currencyPath);
+	}
 
-	const oFormatOptions =
-		(parameters[0] as any)?.type?.indexOf("sap.ui.model.odata.type.Int") === 0 ? { parseAsString: false, emptyString: "" } : {};
 	return {
 		_type: "ComplexType",
 		type: type,
-		formatOptions: oFormatOptions,
+		formatOptions: oFormatOptions || {},
 		parameters: {},
 		bindingParameters: parameterExpressions
 	};
@@ -1341,14 +1435,14 @@ export function addTypeInformation<T, U extends Fn<T>>(
  * @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!)
+ * @returns Expression representing the function call (not the result of the function call!)
  */
 export function fn<T, U extends FunctionOrName<T>>(
 	func: U,
 	parameters: WrappedTuple<FunctionParameters<T, U>>,
 	on?: ExpressionOrPrimitive<object>
 ): FunctionExpression<T> {
-	const functionName = typeof func === "string" ? func : (func as Fn<T>).__functionName;
+	const functionName = typeof func === "string" ? func : func.__functionName;
 	return {
 		_type: "Function",
 		obj: on !== undefined ? wrapPrimitive(on) : undefined,
@@ -1363,14 +1457,14 @@ export function fn<T, U extends FunctionOrName<T>>(
  * @param expression
  * @returns A boolean expression evaluating the fact that the current element is empty
  */
-export function isEmpty(expression: Expression<string>): Expression<boolean> {
+export function isEmpty(expression: BindingToolkitExpression<string>): BindingToolkitExpression<boolean> {
 	if (expression._type === "Concat") {
 		return or(...expression.expressions.map(isEmpty));
 	}
 	return or(equal(expression, ""), equal(expression, undefined), equal(expression, null));
 }
 
-export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): Expression<string> {
+export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): BindingToolkitExpression<string> {
 	const expressions = inExpressions.map(wrapPrimitive);
 	if (hasUnresolveableExpression(...expressions)) {
 		return unresolveableExpression;
@@ -1381,6 +1475,16 @@ export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): Expre
 				return concatenated + (value as ConstantExpression<any>).value.toString();
 			}, "")
 		);
+	} else if (expressions.some(isComplexTypeExpression)) {
+		let pathIdx = 0;
+		const myConcatExpression = formatResult(expressions, "sap.fe.core.formatters.StandardFormatter#concat");
+		const allParts = [];
+		transformRecursively(myConcatExpression, "PathInModel", (constantPath: PathInModelExpression<any>) => {
+			allParts.push(constantPath);
+			return constant(`\$${pathIdx++}`) as ConstantExpression<any>;
+		});
+		allParts.unshift(constant(JSON.stringify(myConcatExpression)));
+		return formatResult(allParts, "sap.fe.core.formatters.StandardFormatter#evaluateComplexExpression");
 	}
 	return {
 		_type: "Concat",
@@ -1388,29 +1492,29 @@ export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): Expre
 	};
 }
 
-export type TransformFunction = <T extends PrimitiveType | unknown>(expressionPart: any) => Expression<T>;
-export type ExpressionType = Pick<Expression<any>, "_type">["_type"];
+export type TransformFunction = <T extends PrimitiveType | unknown>(expressionPart: any) => BindingToolkitExpression<T>;
+export type ExpressionType = Pick<BindingToolkitExpression<any>, "_type">["_type"];
 export function transformRecursively<T extends PrimitiveType | unknown>(
-	inExpression: Expression<T>,
+	inExpression: BindingToolkitExpression<T>,
 	expressionType: ExpressionType,
 	transformFunction: TransformFunction,
 	includeAllExpression = false
-): Expression<T> {
+): BindingToolkitExpression<T> {
 	let expression = inExpression;
 	switch (expression._type) {
 		case "Function":
 		case "Formatter":
-			expression.parameters = expression.parameters.map(parameter =>
+			expression.parameters = expression.parameters.map((parameter) =>
 				transformRecursively(parameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "Concat":
-			expression.expressions = expression.expressions.map(subExpression =>
+			expression.expressions = expression.expressions.map((subExpression) =>
 				transformRecursively(subExpression, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
 		case "ComplexType":
-			expression.bindingParameters = expression.bindingParameters.map(bindingParameter =>
+			expression.bindingParameters = expression.bindingParameters.map((bindingParameter) =>
 				transformRecursively(bindingParameter, expressionType, transformFunction, includeAllExpression)
 			);
 			break;
@@ -1421,19 +1525,19 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			if (includeAllExpression) {
 				condition = transformRecursively(expression.condition, expressionType, transformFunction, includeAllExpression);
 			}
-			expression = ifElse(condition, onTrue, onFalse) as Expression<T>;
+			expression = ifElse(condition, onTrue, onFalse) as BindingToolkitExpression<T>;
 			break;
 		case "Not":
 			if (includeAllExpression) {
 				const operand = transformRecursively(expression.operand, expressionType, transformFunction, includeAllExpression);
-				expression = not(operand) as Expression<T>;
+				expression = not(operand) as BindingToolkitExpression<T>;
 			}
 			break;
 		case "Truthy":
 			break;
 		case "Set":
 			if (includeAllExpression) {
-				expression.operands = expression.operands.map(operand =>
+				expression.operands = expression.operands.map((operand) =>
 					transformRecursively(operand, expressionType, transformFunction, includeAllExpression)
 				);
 			}
@@ -1442,14 +1546,16 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 			if (includeAllExpression) {
 				const operand1 = transformRecursively(expression.operand1, expressionType, transformFunction, includeAllExpression);
 				const operand2 = transformRecursively(expression.operand2, expressionType, transformFunction, includeAllExpression);
-				expression = comparison(expression.operator, operand1, operand2) as Expression<T>;
+				expression = comparison(expression.operator, operand1, operand2) as BindingToolkitExpression<T>;
 			}
 			break;
-		case "DefaultBinding":
 		case "Ref":
 		case "Length":
-		case "Binding":
+		case "PathInModel":
 		case "Constant":
+		case "EmbeddedBinding":
+		case "EmbeddedExpressionBinding":
+		case "Unresolvable":
 			// Do nothing
 			break;
 	}
@@ -1459,28 +1565,31 @@ export function transformRecursively<T extends PrimitiveType | unknown>(
 	return expression;
 }
 
-export type BindingExpression<T> = T | string | undefined;
+export type CompiledBindingToolkitExpression = 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";
+const needParenthesis = function <T extends PrimitiveType>(expr: ExpressionOrPrimitive<T>): boolean {
+	return (
+		!isConstant(expr) && !isPathInModelExpression(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
+ * @returns The compiled string
  */
-function compileConstantObject<T>(expr: ConstantExpression<object>, isNullable = false) {
+function compileConstantObject(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 => {
+	Object.keys(o).forEach((key) => {
 		const value = o[key];
-		const childResult = compileBinding(value, true, false, true);
+		const childResult = compileExpression(value, true, false, true);
 		if (childResult && childResult.length > 0) {
 			properties.push(`${key}: ${childResult}`);
 		}
@@ -1490,10 +1599,11 @@ function compileConstantObject<T>(expr: ConstantExpression<object>, isNullable =
 
 /**
  * Compiles a Constant Binding Expression.
+ *
  * @param expr
  * @param embeddedInBinding
  * @param isNullable
- * @returns {string} The compiled string
+ * @returns The compiled string
  */
 function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, embeddedInBinding: boolean, isNullable = false) {
 	if (expr.value === null) {
@@ -1504,7 +1614,7 @@ function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, e
 	}
 	if (typeof expr.value === "object") {
 		if (Array.isArray(expr.value)) {
-			const entries = expr.value.map(expression => compileBinding(expression, true));
+			const entries = expr.value.map((expression) => compileExpression(expression, true));
 			return `[${entries.join(", ")}]`;
 		} else {
 			return compileConstantObject(expr as ConstantExpression<object>, isNullable);
@@ -1533,10 +1643,10 @@ function compileConstant<T extends PrimitiveType>(expr: ConstantExpression<T>, e
  * @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
+ * @returns The corresponding expression binding
  */
-function compileBindingForBinding<T extends PrimitiveType>(
-	expressionForBinding: BindingExpressionExpression<T> | DefaultBindingExpressionExpression<T>,
+function compilePathInModelExpression<T extends PrimitiveType>(
+	expressionForBinding: PathInModelExpression<T>,
 	embeddedInBinding: boolean,
 	embeddedSeparator: string
 ) {
@@ -1549,22 +1659,22 @@ function compileBindingForBinding<T extends PrimitiveType>(
 	) {
 		// This is now a complex binding definition, let's prepare for it
 		const complexBindingDefinition = {
-			path: compileBindingPath(expressionForBinding),
+			path: compilePathInModel(expressionForBinding),
 			type: expressionForBinding.type,
 			targetType: expressionForBinding.targetType,
 			parameters: expressionForBinding.parameters,
 			formatOptions: expressionForBinding.formatOptions,
 			constraints: expressionForBinding.constraints
 		};
-		let outBinding = compileBinding(complexBindingDefinition);
+		let outBinding = compileExpression(complexBindingDefinition);
 		if (embeddedInBinding) {
-			outBinding = `${embeddedSeparator}` + outBinding;
+			outBinding = `${embeddedSeparator}${outBinding}`;
 		}
 		return outBinding;
 	} else if (embeddedInBinding) {
-		return `${embeddedSeparator}{${compileBindingPath(expressionForBinding)}}`;
+		return `${embeddedSeparator}{${compilePathInModel(expressionForBinding)}}`;
 	} else {
-		return `{${compileBindingPath(expressionForBinding)}}`;
+		return `{${compilePathInModel(expressionForBinding)}}`;
 	}
 }
 
@@ -1573,23 +1683,12 @@ function compileComplexTypeExpression<T extends PrimitiveType>(expression: Compl
 		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}'`;
-	}
+	let outputEnd = `], type: '${expression.type}'`;
 	if (hasElements(expression.formatOptions)) {
-		outputEnd += `, formatOptions: ${compileBinding(expression.formatOptions)}`;
+		outputEnd += `, formatOptions: ${compileExpression(expression.formatOptions)}`;
 	}
 	if (hasElements(expression.parameters)) {
-		outputEnd += `, parameters: ${compileBinding(expression.parameters)}`;
+		outputEnd += `, parameters: ${compileExpression(expression.parameters)}`;
 	}
 	outputEnd += "}";
 
@@ -1602,9 +1701,13 @@ function compileComplexTypeExpression<T extends PrimitiveType>(expression: Compl
  * @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
+ * @returns Finalized compiled expression
  */
-function wrapBindingExpression(expression: string, embeddedInBinding: boolean, parenthesisRequired = false): BindingExpression<string> {
+function wrapBindingExpression(
+	expression: string,
+	embeddedInBinding: boolean,
+	parenthesisRequired = false
+): CompiledBindingToolkitExpression {
 	if (embeddedInBinding) {
 		if (parenthesisRequired) {
 			return `(${expression})`;
@@ -1624,14 +1727,14 @@ function wrapBindingExpression(expression: string, embeddedInBinding: boolean, p
  * @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
+ * @returns The corresponding expression binding
  */
-export function compileBinding<T extends PrimitiveType>(
+export function compileExpression<T extends PrimitiveType>(
 	expression: ExpressionOrPrimitive<T>,
 	embeddedInBinding = false,
 	keepTargetType = false,
 	isNullable = false
-): BindingExpression<string> {
+): CompiledBindingToolkitExpression {
 	const expr = wrapPrimitive(expression);
 	const embeddedSeparator = keepTargetType ? "$" : "%";
 
@@ -1646,10 +1749,10 @@ export function compileBinding<T extends PrimitiveType>(
 			return expr.ref || "null";
 
 		case "Function":
-			const argumentString = `${expr.parameters.map(arg => compileBinding(arg, true)).join(", ")}`;
+			const argumentString = `${expr.parameters.map((arg) => compileExpression(arg, true)).join(", ")}`;
 			return expr.obj === undefined
 				? `${expr.fn}(${argumentString})`
-				: `${compileBinding(expr.obj, true)}.${expr.fn}(${argumentString})`;
+				: `${compileExpression(expr.obj, true)}.${expr.fn}(${argumentString})`;
 
 		case "EmbeddedExpressionBinding":
 			return embeddedInBinding ? `(${expr.value.substr(2, expr.value.length - 3)})` : `${expr.value}`;
@@ -1657,39 +1760,40 @@ export function compileBinding<T extends PrimitiveType>(
 		case "EmbeddedBinding":
 			return embeddedInBinding ? `${embeddedSeparator}${expr.value}` : `${expr.value}`;
 
-		case "DefaultBinding":
-		case "Binding":
-			return compileBindingForBinding(expr, embeddedInBinding, embeddedSeparator);
+		case "PathInModel":
+			return compilePathInModelExpression(expr, embeddedInBinding, embeddedSeparator);
 
 		case "Comparison":
 			const comparisonExpression = compileComparisonExpression(expr);
 			return wrapBindingExpression(comparisonExpression, embeddedInBinding);
 
 		case "IfElse":
-			const ifElseExpression = `${compileBinding(expr.condition, true)} ? ${compileBinding(expr.onTrue, true)} : ${compileBinding(
-				expr.onFalse,
+			const ifElseExpression = `${compileExpression(expr.condition, true)} ? ${compileExpression(
+				expr.onTrue,
 				true
-			)}`;
+			)} : ${compileExpression(expr.onFalse, true)}`;
 			return wrapBindingExpression(ifElseExpression, embeddedInBinding, true);
 
 		case "Set":
-			const setExpression = expr.operands.map(operand => compileBinding(operand, true)).join(` ${expr.operator} `);
+			const setExpression = expr.operands.map((operand) => compileExpression(operand, true)).join(` ${expr.operator} `);
 			return wrapBindingExpression(setExpression, embeddedInBinding, true);
 
 		case "Concat":
-			const concatExpression = expr.expressions.map(nestedExpression => compileBinding(nestedExpression, true, true)).join(" + ");
+			const concatExpression = expr.expressions
+				.map((nestedExpression) => compileExpression(nestedExpression, true, true))
+				.join(" + ");
 			return wrapBindingExpression(concatExpression, embeddedInBinding);
 
 		case "Length":
-			const lengthExpression = `${compileBinding(expr.bindingExpression, true)}.length`;
+			const lengthExpression = `${compileExpression(expr.pathInModel, true)}.length`;
 			return wrapBindingExpression(lengthExpression, embeddedInBinding);
 
 		case "Not":
-			const notExpression = `!${compileBinding(expr.operand, true)}`;
+			const notExpression = `!${compileExpression(expr.operand, true)}`;
 			return wrapBindingExpression(notExpression, embeddedInBinding);
 
 		case "Truthy":
-			const truthyExpression = `!!${compileBinding(expr.operand, true)}`;
+			const truthyExpression = `!!${compileExpression(expr.operand, true)}`;
 			return wrapBindingExpression(truthyExpression, embeddedInBinding);
 
 		case "Formatter":
@@ -1712,8 +1816,8 @@ export function compileBinding<T extends PrimitiveType>(
  * @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";
+	function compileOperand(operand: BindingToolkitExpression<any>) {
+		const compiledOperand = compileExpression(operand, true) ?? "undefined";
 		return wrapBindingExpression(compiledOperand, true, needParenthesis(operand));
 	}
 
@@ -1730,7 +1834,13 @@ function compileFormatterExpression<T extends PrimitiveType>(expression: Formatt
 	if (expression.parameters.length === 1) {
 		return `{${compilePathParameter(expression.parameters[0], true)}, formatter: '${expression.fn}'}`;
 	} else {
-		const parts = expression.parameters.map(param => compilePathParameter(param));
+		const parts = expression.parameters.map((param) => {
+			if (param._type === "ComplexType") {
+				return compileComplexTypeExpression(param);
+			} else {
+				return compilePathParameter(param);
+			}
+		});
 		return `{parts: [${parts.join(", ")}], formatter: '${expression.fn}'}`;
 	}
 }
@@ -1740,39 +1850,32 @@ function compileFormatterExpression<T extends PrimitiveType>(expression: Formatt
  *
  * @param expression The binding part to evaluate
  * @param singlePath Whether there is one or multiple path to consider
- * @returns {string} The string snippet to include in the overall binding definition
+ * @returns The string snippet to include in the overall binding definition
  */
-function compilePathParameter(expression: Expression<any>, singlePath = false): string {
+function compilePathParameter(expression: BindingToolkitExpression<any>, singlePath = false): string {
 	let 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;
+		if (expression.value === undefined) {
+			// Special case otherwise the JSTokenizer complains about incorrect content
+			outValue = `value: 'undefined'`;
+		} else {
+			outValue = `value: ${compileConstant(expression, true)}`;
 		}
-	} else if (expression._type === "DefaultBinding" || expression._type === "Binding") {
-		outValue = `path: '${compileBindingPath(expression)}'`;
+	} else if (expression._type === "PathInModel") {
+		outValue = `path: '${compilePathInModel(expression)}'`;
 
 		outValue += expression.type ? `, type: '${expression.type}'` : `, targetType: 'any'`;
-
+		if (hasElements(expression.mode)) {
+			outValue += `, mode: '${compileExpression(expression.mode)}'`;
+		}
 		if (hasElements(expression.constraints)) {
-			outValue += `, constraints: ${compileBinding(expression.constraints)}`;
+			outValue += `, constraints: ${compileExpression(expression.constraints)}`;
 		}
 		if (hasElements(expression.formatOptions)) {
-			outValue += `, formatOptions: ${compileBinding(expression.formatOptions)}`;
+			outValue += `, formatOptions: ${compileExpression(expression.formatOptions)}`;
 		}
 		if (hasElements(expression.parameters)) {
-			outValue += `, parameters: ${compileBinding(expression.parameters)}`;
+			outValue += `, parameters: ${compileExpression(expression.parameters)}`;
 		}
 	} else {
 		return "";
@@ -1790,6 +1893,6 @@ function hasElements(obj: any) {
  * @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}`;
+function compilePathInModel<T extends PrimitiveType>(expression: PathInModelExpression<T>) {
+	return `${expression.modelName ? `${expression.modelName}>` : ""}${expression.path}`;
 }