function getResolvedBinding(sValue, oElement, oWithControl, bMandatory,
					fnCallIfConstant) {
				try {
					Measurement.average(sPerformanceGetResolvedBinding, "", aPerformanceCategories);

					let vBindingInfo;
					try {
						vBindingInfo = BindingParser.complexParser(sValue, oScope, bMandatory, true,
							true, true, null, /*bResolveTypesAsync*/!oViewInfo.sync);
					} catch (e) {
						return SyncPromise.reject(e);
					}

					let oTypesPromise;
					if (vBindingInfo) {
						if (!oViewInfo.sync) {
							if (vBindingInfo.wait) {
								oTypesPromise = SyncPromise.resolve(vBindingInfo.resolved);
							}
							vBindingInfo = vBindingInfo.bindingInfo;
						}
						if (typeof vBindingInfo === "string") {
							fnCallIfConstant?.();
							return SyncPromise.resolve(vBindingInfo);
						}
						vBindingInfo = BindingInfo.createProperty(vBindingInfo);
					} else { // in case there is no binding and nothing to unescape
						fnCallIfConstant?.();
						return SyncPromise.resolve(sValue);
					}

					if (vBindingInfo.functionsNotFound) {
						if (bMandatory) {
							warn(oElement, "Function name(s)",
								vBindingInfo.functionsNotFound.join(", "), "not found");
						}
						return null; // treat incomplete bindings as unrelated
					}

					if (!BindingInfo.isReady(vBindingInfo, oWithControl)) {
						if (bMandatory) {
							warn(oElement, "Binding not ready");
						}
						return null;
					}

					const bStaticOnly
						= vBindingInfo.parts.every((oPart) => oPart.value !== undefined);
					if (bStaticOnly) {
						fnCallIfConstant?.();
					}

					if (!oTypesPromise) {
						const oPromise = getAny(oWithControl, vBindingInfo, mSettings, oScope,
							!oViewInfo.sync);
						if (oViewInfo.sync && oPromise.isPending()) {
							error("Async formatter in sync view in " + sValue + " of ", oElement);
						}
						return oPromise;
					}

					return oTypesPromise.then(function () {
						return getAny(oWithControl, vBindingInfo, mSettings, oScope, true);
					});
				} finally {
					Measurement.end(sPerformanceGetResolvedBinding);
				}
			}
Interprets the given value as a binding and returns the resulting value; takes care
of unescaping and thus also of constant expressions.

@param {string} sValue
  an XML DOM attribute value
@param {Element} oElement
  the XML DOM element
@param {sap.ui.core.util._with} oWithControl
  the "with" control
@param {boolean} bMandatory
  whether a binding is actually required (e.g. by a <code>template:if</code>) and not
  optional (e.g. for {@link resolveAttributeBinding}); if so, the binding parser
  unescapes the given value (which is a prerequisite for constant expressions) and
  warnings are logged for functions not found
@param {function} [fnCallIfConstant]
  optional function to be called in case the return value is obviously a constant,
  not influenced by any binding
@returns {sap.ui.base.SyncPromise|null}
  a sync promise which resolves with the property value or is rejected with a
  corresponding error (for example, an error thrown by a formatter), or
  <code>null</code> in case the binding is not ready (because it refers to a model
  which is not available)
@throws {Error}
  if a formatter returns a promise in sync mode