shiboken: Refactor target lang name

- Devirtualize TypeEntry::targetLangName() and replace by
  QString buildTargetLangName() that walks up the hierarchy and
  builds the name from the components. It populates a mutable
  variable m_cachedTargetLangName.
- Implement setTargetLangName() to set m_cachedTargetLangName
  directly so that it works in all classes (for target-lang-name).
- Implement a targetLangEntryName() that returns the last name
  part using the same pattern.
- Remove the unused lookupName().

Fixes: PYSIDE-1133
Task-number: PYSIDE-990
Task-number: PYSIDE-1074
Change-Id: I15a6805a21584f1d7d4222e577e50907d7291841
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

7 files changed, 76 insertions, 157 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
index 32c8e437d..0ecf2dce4 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
@@ -539,9 +539,6 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                     cls->addDefaultCopyConstructor(ancestorHasPrivateCopyConstructor(cls));
             }
         }
-
-        if (cls->isAbstract() && !cls->isInterface())
-            cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + QLatin1String("$ConcreteWrapper"));
     }
     const auto &allEntries = types->entries();
 
@@ -584,7 +581,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 AbstractMetaClass *cls = AbstractMetaClass::findClass(m_metaClasses, name);
 
                 const bool enumFound = cls
-                    ? cls->findEnum(entry->targetLangName()) != nullptr
+                    ? cls->findEnum(entry->targetLangEntryName()) != nullptr
                     : m_enums.contains(entry);
 
                 if (!enumFound) {
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index a040f3caa..324dd8192 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -166,19 +166,9 @@ QString AbstractMetaType::package() const
     return m_typeEntry->targetLangPackage();
 }
 
-static QString lastNameSegment(QString name)
-{
-    const int index = name.lastIndexOf(QStringLiteral("::"));
-    if (index >= 0)
-        name.remove(0, index + 2);
-    return name;
-}
-
 QString AbstractMetaType::name() const
 {
-    if (m_name.isEmpty())
-        m_name = lastNameSegment(m_typeEntry->targetLangName());
-    return m_name;
+    return m_typeEntry->targetLangEntryName();
 }
 
 QString AbstractMetaType::fullName() const
@@ -1598,7 +1588,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
 
 QString AbstractMetaClass::name() const
 {
-    return lastNameSegment(m_typeEntry->targetLangName());
+    return m_typeEntry->targetLangEntryName();
 }
 
 void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass)
@@ -2549,7 +2539,7 @@ QString AbstractMetaType::formatPythonSignature(bool minimal) const
         else
             result.append(formatArraySize(m_arrayElementCount));
     } else {
-        result += typeEntry()->qualifiedCppName();
+        result += typeEntry()->targetLangName();
     }
     if (!m_instantiations.isEmpty()) {
         result += QLatin1Char('[');
@@ -2778,7 +2768,7 @@ AbstractMetaEnumValue *AbstractMetaEnum::findEnumValue(const QString &value) con
 
 QString AbstractMetaEnum::name() const
 {
-    return m_typeEntry->targetLangName();
+    return m_typeEntry->targetLangEntryName();
 }
 
 QString AbstractMetaEnum::qualifier() const
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index e9ce4d71b..2a620a972 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -537,7 +537,6 @@ private:
     const TypeEntry *m_typeEntry = nullptr;
     AbstractMetaTypeList m_instantiations;
     QString m_package;
-    mutable QString m_name;
     mutable QString m_cachedCppSignature;
     mutable QString m_cachedPythonSignature;
     QString m_originalTypeDescription;
diff --git a/sources/shiboken2/ApiExtractor/typedatabase.cpp b/sources/shiboken2/ApiExtractor/typedatabase.cpp
index de51f6586..014f4dadc 100644
--- a/sources/shiboken2/ApiExtractor/typedatabase.cpp
+++ b/sources/shiboken2/ApiExtractor/typedatabase.cpp
@@ -793,7 +793,8 @@ void TypeEntry::formatDebug(QDebug &d) const
     if (m_name != cppName)
         d << "\", cppName=\"" << cppName << '"';
     d << ", type=" << m_type << ", codeGeneration=0x"
-        << hex << m_codeGeneration << dec;
+        << hex << m_codeGeneration << dec
+        << ", target=\"" << targetLangName() << '"';
     FORMAT_NONEMPTY_STRING("package", m_targetLangPackage)
     FORMAT_BOOL("stream", m_stream)
     FORMAT_LIST_SIZE("codeSnips", m_codeSnips)
@@ -812,7 +813,6 @@ void TypeEntry::formatDebug(QDebug &d) const
 void ComplexTypeEntry::formatDebug(QDebug &d) const
 {
     TypeEntry::formatDebug(d);
-    FORMAT_NONEMPTY_STRING("targetLangName", m_targetLangName)
     FORMAT_BOOL("polymorphicBase", m_polymorphicBase)
     FORMAT_BOOL("genericClass", m_genericClass)
     FORMAT_BOOL("deleteInMainThread", m_deleteInMainThread)
@@ -822,7 +822,6 @@ void ComplexTypeEntry::formatDebug(QDebug &d) const
         << ", except=" << int(m_exceptionHandling);
     FORMAT_NONEMPTY_STRING("defaultSuperclass", m_defaultSuperclass)
     FORMAT_NONEMPTY_STRING("polymorphicIdValue", m_polymorphicIdValue)
-    FORMAT_NONEMPTY_STRING("lookupName", m_lookupName)
     FORMAT_NONEMPTY_STRING("targetType", m_targetType)
     FORMAT_NONEMPTY_STRING("hash", m_hashFunction)
     FORMAT_LIST_SIZE("addedFunctions", m_addedFunctions)
@@ -840,8 +839,6 @@ void TypedefEntry::formatDebug(QDebug &d) const
 void EnumTypeEntry::formatDebug(QDebug &d) const
 {
     TypeEntry::formatDebug(d);
-    FORMAT_NONEMPTY_STRING("package", m_packageName)
-    FORMAT_NONEMPTY_STRING("targetLangName", m_targetLangName)
     if (m_flags)
         d << ", flags=(" << m_flags << ')';
 }
diff --git a/sources/shiboken2/ApiExtractor/typesystem.cpp b/sources/shiboken2/ApiExtractor/typesystem.cpp
index f70871598..abd2bfb07 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystem.cpp
@@ -50,11 +50,6 @@ PrimitiveTypeEntry::PrimitiveTypeEntry(const QString &entryName, const QVersionN
 {
 }
 
-QString PrimitiveTypeEntry::targetLangName() const
-{
-    return m_targetLangName;
-}
-
 QString PrimitiveTypeEntry::targetLangApiName() const
 {
     return m_targetLangApiName;
@@ -119,12 +114,6 @@ FieldModification ComplexTypeEntry::fieldModification(const QString &name) const
     return mod;
 }
 
-QString ComplexTypeEntry::targetLangName() const
-{
-    return m_targetLangName.isEmpty() ?
-        TypeEntry::targetLangName() : m_targetLangName;
-}
-
 void ComplexTypeEntry::setDefaultConstructor(const QString& defaultConstructor)
 {
     m_defaultConstructor = defaultConstructor;
@@ -148,36 +137,11 @@ void ComplexTypeEntry::useAsTypedef(const ComplexTypeEntry *source)
 {
     TypeEntry::useAsTypedef(source);
     m_qualifiedCppName = source->m_qualifiedCppName;
-    m_targetLangName = source->m_targetLangName;
-    m_lookupName = source->m_lookupName;
     m_targetType = source->m_targetType;
 }
 
 ComplexTypeEntry::ComplexTypeEntry(const ComplexTypeEntry &) = default;
 
-QString ContainerTypeEntry::targetLangName() const
-{
-
-    switch (m_type) {
-    case StringListContainer: return QLatin1String("QStringList");
-    case ListContainer: return QLatin1String("QList");
-    case LinkedListContainer: return QLatin1String("QLinkedList");
-    case VectorContainer: return QLatin1String("QVector");
-    case StackContainer: return QLatin1String("QStack");
-    case QueueContainer: return QLatin1String("QQueue");
-    case SetContainer: return QLatin1String("QSet");
-    case MapContainer: return QLatin1String("QMap");
-    case MultiMapContainer: return QLatin1String("QMultiMap");
-    case HashContainer: return QLatin1String("QHash");
-    case MultiHashContainer: return QLatin1String("QMultiHash");
-    case PairContainer: return QLatin1String("QPair");
-    default:
-        qWarning("bad type... %d", m_type);
-        break;
-    }
-    return QString();
-}
-
 QString ContainerTypeEntry::qualifiedCppName() const
 {
     if (m_type == StringListContainer)
@@ -202,21 +166,6 @@ QString EnumTypeEntry::targetLangQualifier() const
     return q;
 }
 
-QString EnumTypeEntry::qualifiedTargetLangName() const
-{
-    QString qualifiedName;
-    QString pkg = targetLangPackage();
-    QString qualifier = targetLangQualifier();
-
-    if (!pkg.isEmpty())
-        qualifiedName += pkg + QLatin1Char('.');
-    if (!qualifier.isEmpty())
-        qualifiedName += qualifier + QLatin1Char('.');
-    qualifiedName += targetLangName();
-
-    return qualifiedName;
-}
-
 QString EnumTypeEntry::qualifier() const
 {
     auto parentEntry = parent();
@@ -248,17 +197,6 @@ TypeEntry *FlagsTypeEntry::clone() const
 
 FlagsTypeEntry::FlagsTypeEntry(const FlagsTypeEntry &) = default;
 
-QString FlagsTypeEntry::qualifiedTargetLangName() const
-{
-    return targetLangPackage() + QLatin1Char('.') + m_enum->targetLangQualifier()
-        + QLatin1Char('.') + targetLangName();
-}
-
-QString FlagsTypeEntry::targetLangName() const
-{
-    return m_targetLangName;
-}
-
 QString TemplateInstance::expandCode() const
 {
     TemplateEntry *templateEntry = TypeDatabase::instance()->findTemplate(m_name);
@@ -650,11 +588,6 @@ bool ComplexTypeEntry::isComplex() const
     return true;
 }
 
-QString ComplexTypeEntry::lookupName() const
-{
-    return m_lookupName.isEmpty() ? targetLangName() : m_lookupName;
-}
-
 QString ComplexTypeEntry::targetLangApiName() const
 {
     return strings_jobject;
@@ -760,6 +693,42 @@ const TypeSystemTypeEntry *TypeEntry::typeSystemTypeEntry() const
     return nullptr;
 }
 
+QString TypeEntry::targetLangName() const
+{
+    if (m_cachedTargetLangName.isEmpty())
+        m_cachedTargetLangName = buildTargetLangName();
+    return m_cachedTargetLangName;
+}
+
+QString TypeEntry::buildTargetLangName() const
+{
+    QString result = m_entryName;
+    for (auto p = parent(); p && p->type() != TypeEntry::TypeSystemType; p = p->parent()) {
+        if (!result.isEmpty())
+            result.prepend(QLatin1Char('.'));
+        QString n = p->m_entryName;
+        n.replace(QLatin1String("::"), QLatin1String(".")); // Primitive types may have "std::"
+        result.prepend(n);
+    }
+    return result;
+}
+
+QString TypeEntry::targetLangEntryName() const
+{
+    if (m_cachedTargetLangEntryName.isEmpty()) {
+        m_cachedTargetLangEntryName = targetLangName();
+        const int lastDot = m_cachedTargetLangEntryName.lastIndexOf(QLatin1Char('.'));
+        if (lastDot != -1)
+            m_cachedTargetLangEntryName.remove(0, lastDot + 1);
+    }
+    return m_cachedTargetLangEntryName;
+}
+
+QString TypeEntry::qualifiedTargetLangName() const
+{
+    return targetLangPackage() + QLatin1Char('.') + targetLangName();
+}
+
 bool TypeEntry::hasCustomConversion() const
 {
     return m_customConversion != nullptr;
@@ -850,7 +819,7 @@ ArrayTypeEntry::ArrayTypeEntry(const TypeEntry *nested_type, const QVersionNumbe
     Q_ASSERT(m_nestedType);
 }
 
-QString ArrayTypeEntry::targetLangName() const
+QString ArrayTypeEntry::buildTargetLangName() const
 {
     return m_nestedType->targetLangName() + QLatin1String("[]");
 }
@@ -872,16 +841,10 @@ ArrayTypeEntry::ArrayTypeEntry(const ArrayTypeEntry &) = default;
 EnumTypeEntry::EnumTypeEntry(const QString &entryName,
                              const QVersionNumber &vr,
                              const TypeEntry *parent) :
-    TypeEntry(entryName, EnumType, vr, parent),
-    m_targetLangName(entryName)
+    TypeEntry(entryName, EnumType, vr, parent)
 {
 }
 
-QString EnumTypeEntry::targetLangName() const
-{
-    return m_targetLangName;
-}
-
 EnumValueTypeEntry::EnumValueTypeEntry(const QString &name, const QString &value,
                                        const EnumTypeEntry *enclosingEnum,
                                        bool isScopedEnum,
@@ -906,6 +869,13 @@ FlagsTypeEntry::FlagsTypeEntry(const QString &entryName, const QVersionNumber &v
 {
 }
 
+QString FlagsTypeEntry::buildTargetLangName() const
+{
+    QString on = m_originalName;
+    on.replace(QLatin1String("::"), QLatin1String("."));
+    return on;
+}
+
 ConstantValueTypeEntry::ConstantValueTypeEntry(const QString& name,
                                                const TypeEntry *parent) :
     TypeEntry(name, ConstantValueType, QVersionNumber(0, 0), parent)
diff --git a/sources/shiboken2/ApiExtractor/typesystem.h b/sources/shiboken2/ApiExtractor/typesystem.h
index 67e2420a1..4d0a23ca1 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.h
+++ b/sources/shiboken2/ApiExtractor/typesystem.h
@@ -756,28 +756,15 @@ public:
     }
 
     // The type's name in TargetLang
-    virtual QString targetLangName() const
-    {
-        return m_name;
-    }
-
-    // The type to lookup when converting to TargetLang
-    virtual QString lookupName() const
-    {
-        return targetLangName();
-    }
+    QString targetLangName() const; // "Foo.Bar"
+    void setTargetLangName(const QString &n) { m_cachedTargetLangName = n; }
+    QString targetLangEntryName() const; // "Bar"
 
     // The package
     QString targetLangPackage() const { return m_targetLangPackage; }
     void setTargetLangPackage(const QString &p) { m_targetLangPackage = p; }
 
-    virtual QString qualifiedTargetLangName() const
-    {
-        QString pkg = targetLangPackage();
-        if (pkg.isEmpty())
-            return targetLangName();
-        return pkg + QLatin1Char('.') + targetLangName();
-    }
+    QString qualifiedTargetLangName() const;
 
     virtual InterfaceTypeEntry *designatedInterface() const
     {
@@ -905,11 +892,15 @@ public:
 protected:
     TypeEntry(const TypeEntry &);
 
+    virtual QString buildTargetLangName() const;
+
 private:
     const TypeEntry *m_parent;
     QString m_name; // fully qualified
     QString m_entryName;
     QString m_targetLangPackage;
+    mutable QString m_cachedTargetLangName; // "Foo.Bar"
+    mutable QString m_cachedTargetLangEntryName; // "Bar"
     CustomFunction m_customConstructor;
     CustomFunction m_customDestructor;
     CodeSnipList m_codeSnips;
@@ -999,7 +990,6 @@ public:
         return m_nestedType;
     }
 
-    QString targetLangName() const override;
     QString targetLangApiName() const override;
 
     TypeEntry *clone() const override;
@@ -1007,6 +997,8 @@ public:
 protected:
     ArrayTypeEntry(const ArrayTypeEntry &);
 
+    QString buildTargetLangName() const override;
+
 private:
     const TypeEntry *m_nestedType;
 };
@@ -1018,12 +1010,6 @@ public:
     explicit PrimitiveTypeEntry(const QString &entryName, const QVersionNumber &vr,
                                 const TypeEntry *parent);
 
-    QString targetLangName() const override;
-    void setTargetLangName(const QString &targetLangName)
-    {
-        m_targetLangName  = targetLangName;
-    }
-
     QString targetLangApiName() const override;
     void setTargetLangApiName(const QString &targetLangApiName)
     {
@@ -1083,7 +1069,6 @@ protected:
     PrimitiveTypeEntry(const PrimitiveTypeEntry &);
 
 private:
-    QString m_targetLangName;
     QString m_targetLangApiName;
     QString m_defaultConstructor;
     uint m_preferredTargetLangType : 1;
@@ -1099,9 +1084,7 @@ public:
                            const QVersionNumber &vr,
                            const TypeEntry *parent);
 
-    QString targetLangName() const override;
     QString targetLangQualifier() const;
-    QString qualifiedTargetLangName() const override;
 
     QString targetLangApiName() const override;
 
@@ -1140,8 +1123,6 @@ protected:
     EnumTypeEntry(const EnumTypeEntry &);
 
 private:
-    QString m_packageName;
-    QString m_targetLangName;
     const EnumValueTypeEntry *m_nullValue = nullptr;
 
     QStringList m_rejectedEnums;
@@ -1178,8 +1159,6 @@ public:
     explicit FlagsTypeEntry(const QString &entryName, const QVersionNumber &vr,
                             const TypeEntry *parent);
 
-    QString qualifiedTargetLangName() const override;
-    QString targetLangName() const override;
     QString targetLangApiName() const override;
 
     QString originalName() const
@@ -1193,11 +1172,11 @@ public:
 
     QString flagsName() const
     {
-        return m_targetLangName;
+        return m_flagsName;
     }
     void setFlagsName(const QString &name)
     {
-        m_targetLangName = name;
+        m_flagsName = name;
     }
 
     EnumTypeEntry *originator() const
@@ -1214,9 +1193,11 @@ public:
 protected:
     FlagsTypeEntry(const FlagsTypeEntry &);
 
+    QString buildTargetLangName() const override;
+
 private:
     QString m_originalName;
-    QString m_targetLangName;
+    QString m_flagsName;
     EnumTypeEntry *m_enum = nullptr;
 };
 
@@ -1253,13 +1234,6 @@ public:
 
     bool isComplex() const override;
 
-    void setLookupName(const QString &name)
-    {
-        m_lookupName = name;
-    }
-
-    QString lookupName() const override;
-
     QString targetLangApiName() const override;
 
     void setTypeFlags(TypeFlags flags)
@@ -1351,12 +1325,6 @@ public:
         m_targetType = code;
     }
 
-    QString targetLangName() const override;
-    void setTargetLangName(const QString &name)
-    {
-        m_targetLangName = name;
-    }
-
     bool isGenericClass() const
     {
         return m_genericClass;
@@ -1424,14 +1392,12 @@ private:
     QString m_defaultConstructor;
     QString m_defaultSuperclass;
     QString m_qualifiedCppName;
-    QString m_targetLangName;
 
     uint m_polymorphicBase : 1;
     uint m_genericClass : 1;
     uint m_deleteInMainThread : 1;
 
     QString m_polymorphicIdValue;
-    QString m_lookupName;
     QString m_targetType;
     TypeFlags m_typeFlags;
     CopyableFlag m_copyableFlag = Unknown;
@@ -1506,7 +1472,6 @@ public:
     }
 
     QString typeName() const;
-    QString targetLangName() const override;
     QString qualifiedCppName() const override;
 
     TypeEntry *clone() const override;
diff --git a/sources/shiboken2/ApiExtractor/typesystemparser.cpp b/sources/shiboken2/ApiExtractor/typesystemparser.cpp
index 6d9e409a4..7388b07fc 100644
--- a/sources/shiboken2/ApiExtractor/typesystemparser.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystemparser.cpp
@@ -81,6 +81,7 @@ static inline QString preferredTargetLangTypeAttribute() { return QStringLiteral
 static inline QString removeAttribute() { return QStringLiteral("remove"); }
 static inline QString renameAttribute() { return QStringLiteral("rename"); }
 static inline QString readAttribute() { return QStringLiteral("read"); }
+static inline QString targetLangNameAttribute() { return QStringLiteral("target-lang-name"); }
 static inline QString writeAttribute() { return QStringLiteral("write"); }
 static inline QString replaceAttribute() { return QStringLiteral("replace"); }
 static inline QString toAttribute() { return QStringLiteral("to"); }
@@ -1087,11 +1088,12 @@ FlagsTypeEntry *
     applyCommonAttributes(ftype, attributes);
 
     QStringList lst = flagName.split(colonColon());
+    const QString targetLangFlagName = QStringList(lst.mid(0, lst.size() - 1)).join(QLatin1Char('.'));
     const QString &targetLangQualifier = enumEntry->targetLangQualifier();
-    if (QStringList(lst.mid(0, lst.size() - 1)).join(colonColon()) != targetLangQualifier) {
+    if (targetLangFlagName != targetLangQualifier) {
         qCWarning(lcShiboken).noquote().nospace()
             << QStringLiteral("enum %1 and flags %2 (%3) differ in qualifiers")
-                              .arg(targetLangQualifier, lst.constFirst(), flagName);
+                              .arg(targetLangQualifier, lst.constFirst(), targetLangFlagName);
     }
 
     ftype->setFlagsName(lst.constLast());
@@ -1174,8 +1176,8 @@ PrimitiveTypeEntry *
     applyCommonAttributes(type, attributes);
     for (int i = attributes->size() - 1; i >= 0; --i) {
         const QStringRef name = attributes->at(i).qualifiedName();
-        if (name == QLatin1String("target-lang-name")) {
-             type->setTargetLangName(attributes->takeAt(i).value().toString());
+        if (name == targetLangNameAttribute()) {
+            type->setTargetLangName(attributes->takeAt(i).value().toString());
         } else if (name == QLatin1String("target-lang-api-name")) {
             type->setTargetLangApiName(attributes->takeAt(i).value().toString());
         } else if (name == preferredConversionAttribute()) {
@@ -1190,8 +1192,6 @@ PrimitiveTypeEntry *
         }
     }
 
-    if (type->targetLangName().isEmpty())
-        type->setTargetLangName(type->name());
     if (type->targetLangApiName().isEmpty())
         type->setTargetLangApiName(type->name());
     type->setTargetLangPackage(m_defaultPackage);
@@ -1274,7 +1274,7 @@ ObjectTypeEntry *
     bool generate = true;
     for (int i = attributes->size() - 1; i >= 0; --i) {
         const QStringRef name = attributes->at(i).qualifiedName();
-        if (name == QLatin1String("target-lang-name")) {
+        if (name == targetLangNameAttribute()) {
             targetLangName = attributes->takeAt(i).value().toString();
         } else if (name == generateAttribute()) {
             generate = convertBoolean(attributes->takeAt(i).value(),
@@ -1284,6 +1284,7 @@ ObjectTypeEntry *
 
     auto itype = new InterfaceTypeEntry(InterfaceTypeEntry::interfaceName(targetLangName),
                                         since, currentParentTypeEntry());
+    itype->setTargetLangName(targetLangName);
 
     if (generate)
         itype->setCodeGeneration(m_generate);
@@ -1436,7 +1437,7 @@ void TypeSystemParser::applyComplexTypeAttributes(const QXmlStreamReader &reader
                       qPrintable(msgUnimplementedAttributeWarning(reader, name)));
             const bool v = convertBoolean(attributes->takeAt(i).value(), genericClassAttribute(), false);
             ctype->setGenericClass(v);
-        } else if (name == QLatin1String("target-lang-name")) {
+        } else if (name == targetLangNameAttribute()) {
             ctype->setTargetLangName(attributes->takeAt(i).value().toString());
         } else if (name == QLatin1String("polymorphic-base")) {
             ctype->setPolymorphicIdValue(attributes->takeAt(i).value().toString());