From a687af8324bb92531bb1531297ea638ae75a14c6 Mon Sep 17 00:00:00 2001
From: Thomas Hartmann <thomas.hartmann@qt.io>
Date: Thu, 1 Jun 2023 13:14:47 +0200
Subject: [PATCH] QmlDesigner: Unify and fix property comparison

So far string and QString were not considered equal.
Unifying the type comparison.

Task-number: QDS-9938
Change-Id: Ia64fee9b56b8cf916669aca1d3f09a3f05ecf29f
Reviewed-by: Aleksei German <aleksei.german@qt.io>
---
 .../bindingeditor/bindingeditor.cpp           | 58 +++++++++----------
 1 file changed, 28 insertions(+), 30 deletions(-)

diff --git a/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp b/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
index 6cd3e814929..8c8d0911793 100644
--- a/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
+++ b/src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp
@@ -174,27 +174,38 @@ void BindingEditor::prepareBindings()
 
     QList<BindingEditorDialog::BindingOption> bindings;
 
-    const QList<TypeName> variantTypes = {"alias", "unknown", "variant", "var"};
-    const QList<TypeName> numericTypes = {"double", "real", "int"};
-    const QList<TypeName> colorTypes = {"QColor", "color"};
-    auto isVariant = [&variantTypes](const TypeName &compareType) { return variantTypes.contains(compareType); };
-    auto isNumeric = [&numericTypes](const TypeName &compareType) { return numericTypes.contains(compareType); };
-    auto isColor = [&colorTypes](const TypeName &compareType) { return colorTypes.contains(compareType); };
+    const QVarLengthArray<TypeName> variantTypes = {"alias", "unknown", "variant", "var"};
+    const QVarLengthArray<TypeName> numericTypes = {"double", "real", "int"};
+    const QVarLengthArray<TypeName> colorTypes = {"QColor", "color"};
+    const QVarLengthArray<TypeName> stringTypes = {"QString", "string"};
 
-    const bool skipTypeFiltering = isVariant(m_backendValueTypeName);
-    const bool targetTypeIsNumeric = isNumeric(m_backendValueTypeName);
+    auto isVariant = [&variantTypes](const TypeName &compareType) {
+        return variantTypes.contains(compareType);
+    };
+    auto isNumeric = [&numericTypes](const TypeName &compareType) {
+        return numericTypes.contains(compareType);
+    };
+    auto isColor = [&colorTypes](const TypeName &compareType) {
+        return colorTypes.contains(compareType);
+    };
+    auto isString = [&stringTypes](const TypeName &compareType) {
+        return stringTypes.contains(compareType);
+    };
+
+    auto compareTypes = [&](const TypeName &targetType, const TypeName &sourceType) {
+        return isVariant(targetType) || isVariant(sourceType) || (targetType == sourceType)
+               || (isNumeric(targetType) && isNumeric(sourceType))
+               || (isColor(targetType) && isColor(sourceType))
+               || (isString(targetType) && isString(sourceType));
+    };
 
     for (const auto &objnode : allNodes) {
         BindingEditorDialog::BindingOption binding;
         for (const auto &property : objnode.metaInfo().properties()) {
             const TypeName &propertyTypeName = property.propertyType().simplifiedTypeName();
 
-            if (skipTypeFiltering
-                    || (m_backendValueTypeName == propertyTypeName)
-                    || isVariant(propertyTypeName)
-                    || (targetTypeIsNumeric && isNumeric(propertyTypeName))) {
+            if (compareTypes(m_backendValueTypeName, propertyTypeName))
                 binding.properties.append(QString::fromUtf8(property.name()));
-            }
         }
 
         //dynamic properties:
@@ -202,12 +213,8 @@ void BindingEditor::prepareBindings()
             if (bindingProperty.isValid()) {
                 if (bindingProperty.isDynamic()) {
                     const TypeName dynamicTypeName = bindingProperty.dynamicTypeName();
-                    if (skipTypeFiltering
-                            || (dynamicTypeName == m_backendValueTypeName)
-                            || isVariant(dynamicTypeName)
-                            || (targetTypeIsNumeric && isNumeric(dynamicTypeName))) {
+                    if (compareTypes(m_backendValueTypeName, dynamicTypeName))
                         binding.properties.append(QString::fromUtf8(bindingProperty.name()));
-                    }
                 }
             }
         }
@@ -215,12 +222,8 @@ void BindingEditor::prepareBindings()
             if (variantProperty.isValid()) {
                 if (variantProperty.isDynamic()) {
                     const TypeName dynamicTypeName = variantProperty.dynamicTypeName();
-                    if (skipTypeFiltering
-                            || (dynamicTypeName == m_backendValueTypeName)
-                            || isVariant(dynamicTypeName)
-                            || (targetTypeIsNumeric && isNumeric(dynamicTypeName))) {
+                    if (compareTypes(m_backendValueTypeName, dynamicTypeName))
                         binding.properties.append(QString::fromUtf8(variantProperty.name()));
-                    }
                 }
             }
         }
@@ -241,15 +244,10 @@ void BindingEditor::prepareBindings()
                     BindingEditorDialog::BindingOption binding;
 
                     for (const auto &property : metaInfo.properties()) {
-                        TypeName propertyTypeName = property.propertyType().typeName();
+                        const TypeName propertyTypeName = property.propertyType().typeName();
 
-                        if (skipTypeFiltering
-                                || (m_backendValueTypeName == propertyTypeName)
-                                || (isVariant(propertyTypeName))
-                                || (targetTypeIsNumeric && isNumeric(propertyTypeName))
-                                || (isColor(m_backendValueTypeName) && isColor(propertyTypeName))) {
+                        if (compareTypes(m_backendValueTypeName, propertyTypeName))
                             binding.properties.append(QString::fromUtf8(property.name()));
-                        }
                     }
 
                     if (!binding.properties.isEmpty()) {