Code model: Rename TypeAliasModelItem to TypedefModelItem

"TypeAlias" becomes confusing as the term "Alias" gets a different
meaning in C++ 11.

Rename classes and related API.
Also rename aliasedType to referencedType in the type database.

Task-number: PYSIDE-323
Change-Id: Ic13049bde1cf94090de0dbf46e4ce484992dcbbf
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

14 files changed, 118 insertions, 125 deletions

diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index 995bfe0ee..d0b106da0 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -520,11 +520,11 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
 
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
-    TypeAliasList typeAliases = dom->typeAliases();
-    ReportHandler::setProgressReference(typeAliases);
-    foreach (TypeAliasModelItem typeAlias, typeAliases) {
+    TypeDefList typeDefs = dom->typeDefs();
+    ReportHandler::setProgressReference(typeDefs);
+    foreach (const TypeDefModelItem &typeDef, typeDefs) {
         ReportHandler::progress(QLatin1String("Resolving typedefs..."));
-        AbstractMetaClass* cls = traverseTypeAlias(dom, typeAlias);
+        AbstractMetaClass* cls = traverseTypeDef(dom, typeDef);
         addAbstractMetaClass(cls);
     }
 
@@ -810,9 +810,9 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
-    TypeAliasList typeAliases = namespaceItem->typeAliases();
-    foreach (const TypeAliasModelItem &typeAlias, typeAliases) {
-        AbstractMetaClass* cls = traverseTypeAlias(dom, typeAlias);
+    const TypeDefList typeDefs = namespaceItem->typeDefs();
+    foreach (const TypeDefModelItem &typeDef, typeDefs) {
+        AbstractMetaClass *cls = traverseTypeDef(dom, typeDef);
         if (cls) {
             metaClass->addInnerClass(cls);
             cls->setEnclosingClass(metaClass);
@@ -1162,11 +1162,11 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumIte
     return metaEnum;
 }
 
-AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeAlias(const FileModelItem &dom,
-                                                                 const TypeAliasModelItem &typeAlias)
+AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom,
+                                                               const TypeDefModelItem &typeDef)
 {
     TypeDatabase* types = TypeDatabase::instance();
-    QString className = stripTemplateArgs(typeAlias->name());
+    QString className = stripTemplateArgs(typeDef->name());
 
     QString fullClassName = className;
     // we have an inner class
@@ -1180,8 +1180,8 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeAlias(const FileModel
     // TypeEntry
     PrimitiveTypeEntry* ptype = types->findPrimitiveType(className);
     if (ptype) {
-        QString typeAliasName = typeAlias->type().qualifiedName()[0];
-        ptype->setAliasedTypeEntry(types->findPrimitiveType(typeAliasName));
+        QString typeDefName = typeDef->type().qualifiedName()[0];
+        ptype->setReferencedTypeEntry(types->findPrimitiveType(typeDefName));
         return 0;
     }
 
@@ -1192,17 +1192,17 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeAlias(const FileModel
         return 0;
 
     if (type->isObject())
-        static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(dom, stripTemplateArgs(typeAlias->type().qualifiedName().join(colonColon()))));
+        static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(dom, stripTemplateArgs(typeDef->type().qualifiedName().join(colonColon()))));
 
     AbstractMetaClass *metaClass = q->createMetaClass();
-    metaClass->setTypeAlias(true);
+    metaClass->setTypeDef(true);
     metaClass->setTypeEntry(type);
-    metaClass->setBaseClassNames(QStringList() << typeAlias->type().qualifiedName().join(colonColon()));
+    metaClass->setBaseClassNames(QStringList() << typeDef->type().qualifiedName().join(colonColon()));
     *metaClass += AbstractMetaAttributes::Public;
 
     // Set the default include file name
     if (!type->include().isValid())
-        setInclude(type, typeAlias->fileName());
+        setInclude(type, typeDef->fileName());
 
     fillAddedFunctions(metaClass);
 
@@ -1301,9 +1301,9 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
 
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
-    TypeAliasList typeAliases = classItem->typeAliases();
-    foreach (const TypeAliasModelItem &typeAlias, typeAliases) {
-        AbstractMetaClass* cls = traverseTypeAlias(dom, typeAlias);
+    const TypeDefList typeDefs = classItem->typeDefs();
+    foreach (const TypeDefModelItem &typeDef, typeDefs) {
+        AbstractMetaClass *cls = traverseTypeDef(dom, typeDef);
         if (cls) {
             cls->setEnclosingClass(metaClass);
             addAbstractMetaClass(cls);
@@ -2777,7 +2777,7 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
     QList<TypeParser::Info> targs = info.template_instantiations;
     QList<AbstractMetaType*> templateTypes;
 
-    if (subclass->isTypeAlias()) {
+    if (subclass->isTypeDef()) {
         subclass->setHasCloneOperator(templateClass->hasCloneOperator());
         subclass->setHasEqualsOperator(templateClass->hasEqualsOperator());
         subclass->setHasHashFunction(templateClass->hasHashFunction());
@@ -2863,7 +2863,7 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
         f->setDeclaringClass(subclass);
 
 
-        if (f->isConstructor() && subclass->isTypeAlias()) {
+        if (f->isConstructor() && subclass->isTypeDef()) {
             f->setName(subclass->name());
             f->setOriginalName(subclass->name());
         } else if (f->isConstructor()) {
diff --git a/ApiExtractor/abstractmetabuilder_p.h b/ApiExtractor/abstractmetabuilder_p.h
index e8852b621..17bbb9a10 100644
--- a/ApiExtractor/abstractmetabuilder_p.h
+++ b/ApiExtractor/abstractmetabuilder_p.h
@@ -66,8 +66,8 @@ public:
     void figureOutDefaultEnumArguments();
 
     void addAbstractMetaClass(AbstractMetaClass *cls);
-    AbstractMetaClass *traverseTypeAlias(const FileModelItem &dom,
-                                         const TypeAliasModelItem &item);
+    AbstractMetaClass *traverseTypeDef(const FileModelItem &dom,
+                                       const TypeDefModelItem &typeDef);
     AbstractMetaClass *traverseClass(const FileModelItem &dom,
                                      const ClassModelItem &item);
     AbstractMetaClass *currentTraversedClass(ScopeModelItem item);
diff --git a/ApiExtractor/abstractmetalang.h b/ApiExtractor/abstractmetalang.h
index 0ad2d68c2..673e9c9b2 100644
--- a/ApiExtractor/abstractmetalang.h
+++ b/ApiExtractor/abstractmetalang.h
@@ -1440,7 +1440,7 @@ public:
               m_hasHashFunction(false),
               m_hasEqualsOperator(false),
               m_hasCloneOperator(false),
-              m_isTypeAlias(false),
+              m_isTypeDef(false),
               m_hasToStringCapability(false),
               m_enclosingClass(0),
               m_baseClass(0),
@@ -1892,15 +1892,8 @@ public:
     AbstractMetaTypeList templateBaseClassInstantiations() const;
     void setTemplateBaseClassInstantiations(AbstractMetaTypeList& instantiations);
 
-    void setTypeAlias(bool typeAlias)
-    {
-        m_isTypeAlias = typeAlias;
-    }
-
-    bool isTypeAlias() const
-    {
-        return m_isTypeAlias;
-    }
+    void setTypeDef(bool typeDef) { m_isTypeDef = typeDef; }
+    bool isTypeDef() const { return m_isTypeDef; }
 
     void setStream(bool stream)
     {
@@ -1938,7 +1931,7 @@ private:
     uint m_hasHashFunction : 1;
     uint m_hasEqualsOperator : 1;
     uint m_hasCloneOperator : 1;
-    uint m_isTypeAlias : 1;
+    uint m_isTypeDef : 1;
     uint m_hasToStringCapability : 1;
 
     const AbstractMetaClass *m_enclosingClass;
diff --git a/ApiExtractor/parser/binder.cpp b/ApiExtractor/parser/binder.cpp
index f6d4d2fee..e2b648733 100644
--- a/ApiExtractor/parser/binder.cpp
+++ b/ApiExtractor/parser/binder.cpp
@@ -529,13 +529,13 @@ void Binder::visitTypedef(TypedefAST *node)
         CodeModelFinder finder(model(), this);
         ScopeModelItem typedefScope = finder.resolveScope(declarator->id, scope);
 
-        TypeAliasModelItem typeAlias(new _TypeAliasModelItem(model()));
-        updateItemPosition(typeAlias, node);
-        typeAlias->setName(alias_name);
-        typeAlias->setType(qualifyType(typeInfo, currentScope()->qualifiedName()));
-        typeAlias->setScope(typedefScope->qualifiedName());
-        _M_qualified_types[typeAlias->qualifiedName().join(QLatin1Char('.'))] = QString();
-        currentScope()->addTypeAlias(typeAlias);
+        TypeDefModelItem typeDef(new _TypeDefModelItem(model()));
+        updateItemPosition(typeDef, node);
+        typeDef->setName(alias_name);
+        typeDef->setType(qualifyType(typeInfo, currentScope()->qualifiedName()));
+        typeDef->setScope(typedefScope->qualifiedName());
+        _M_qualified_types[typeDef->qualifiedName().join(QLatin1Char('.'))] = QString();
+        currentScope()->addTypeDef(typeDef);
     } while (it != end);
 }
 
diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
index a2a28e741..263ae32b7 100644
--- a/ApiExtractor/parser/codemodel.cpp
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -100,7 +100,7 @@ CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelIte
             } else if (EnumModelItem es = ss->findEnum(name)) {
                 if (i == qualifiedName.size() - 1)
                     return es;
-            } else if (TypeAliasModelItem tp = ss->findTypeAlias(name)) {
+            } else if (TypeDefModelItem tp = ss->findTypeDef(name)) {
                 if (i == qualifiedName.size() - 1)
                     return tp;
             } else {
@@ -149,8 +149,8 @@ TypeInfo TypeInfo::resolveType(CodeModelItem __item, TypeInfo const &__type, Cod
         otherType.setQualifiedName(__item->qualifiedName());
     }
 
-    if (TypeAliasModelItem __alias = qSharedPointerDynamicCast<_TypeAliasModelItem>(__item)) {
-        const TypeInfo combined = TypeInfo::combine(__alias->type(), otherType);
+    if (TypeDefModelItem __typedef = qSharedPointerDynamicCast<_TypeDefModelItem>(__item)) {
+        const TypeInfo combined = TypeInfo::combine(__typedef->type(), otherType);
         const CodeModelItem nextItem = __scope->model()->findItem(combined.qualifiedName(), __scope);
         if (!nextItem)
             return combined;
@@ -412,9 +412,9 @@ ClassList _ScopeModelItem::classes() const
     return result;
 }
 
-TypeAliasList _ScopeModelItem::typeAliases() const
+TypeDefList _ScopeModelItem::typeDefs() const
 {
-    return _M_typeAliases.values();
+    return _M_typeDefs.values();
 }
 
 VariableList _ScopeModelItem::variables() const
@@ -469,9 +469,9 @@ void _ScopeModelItem::addVariable(VariableModelItem item)
     _M_variables.insert(item->name(), item);
 }
 
-void _ScopeModelItem::addTypeAlias(TypeAliasModelItem item)
+void _ScopeModelItem::addTypeDef(TypeDefModelItem item)
 {
-    _M_typeAliases.insert(item->name(), item);
+    _M_typeDefs.insert(item->name(), item);
 }
 
 void _ScopeModelItem::addEnum(EnumModelItem item)
@@ -525,12 +525,12 @@ void _ScopeModelItem::removeVariable(VariableModelItem item)
         _M_variables.erase(it);
 }
 
-void _ScopeModelItem::removeTypeAlias(TypeAliasModelItem item)
+void _ScopeModelItem::removeTypeDef(TypeDefModelItem item)
 {
-    QHash<QString, TypeAliasModelItem>::Iterator it = _M_typeAliases.find(item->name());
+    QHash<QString, TypeDefModelItem>::Iterator it = _M_typeDefs.find(item->name());
 
-    if (it != _M_typeAliases.end() && it.value() == item)
-        _M_typeAliases.erase(it);
+    if (it != _M_typeDefs.end() && it.value() == item)
+        _M_typeDefs.erase(it);
 }
 
 void _ScopeModelItem::removeEnum(EnumModelItem item)
@@ -553,9 +553,9 @@ VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
     return _M_variables.value(name);
 }
 
-TypeAliasModelItem _ScopeModelItem::findTypeAlias(const QString &name) const
+TypeDefModelItem _ScopeModelItem::findTypeDef(const QString &name) const
 {
-    return _M_typeAliases.value(name);
+    return _M_typeDefs.value(name);
 }
 
 EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
@@ -751,12 +751,12 @@ _FunctionDefinitionModelItem::~_FunctionDefinitionModelItem()
 }
 
 // ---------------------------------------------------------------------------
-TypeInfo _TypeAliasModelItem::type() const
+TypeInfo _TypeDefModelItem::type() const
 {
     return _M_type;
 }
 
-void _TypeAliasModelItem::setType(const TypeInfo &type)
+void _TypeDefModelItem::setType(const TypeInfo &type)
 {
     _M_type = type;
 }
diff --git a/ApiExtractor/parser/codemodel.h b/ApiExtractor/parser/codemodel.h
index 9f9cc0492..d00262658 100644
--- a/ApiExtractor/parser/codemodel.h
+++ b/ApiExtractor/parser/codemodel.h
@@ -229,7 +229,7 @@ public:
         Kind_File = 5 << FirstKind | Kind_Namespace,
         Kind_FunctionDefinition = 6 << FirstKind | Kind_Function,
         Kind_TemplateParameter = 7 << FirstKind,
-        Kind_TypeAlias = 8 << FirstKind,
+        Kind_TypeDef = 8 << FirstKind,
         Kind_Variable = 9 << FirstKind | Kind_Member
     };
 
@@ -291,28 +291,28 @@ public:
     EnumList enums() const;
     FunctionDefinitionList functionDefinitions() const;
     FunctionList functions() const;
-    TypeAliasList typeAliases() const;
+    TypeDefList typeDefs() const;
     VariableList variables() const;
 
     void addClass(ClassModelItem item);
     void addEnum(EnumModelItem item);
     void addFunction(FunctionModelItem item);
     void addFunctionDefinition(FunctionDefinitionModelItem item);
-    void addTypeAlias(TypeAliasModelItem item);
+    void addTypeDef(TypeDefModelItem item);
     void addVariable(VariableModelItem item);
 
     void removeClass(ClassModelItem item);
     void removeEnum(EnumModelItem item);
     void removeFunction(FunctionModelItem item);
     void removeFunctionDefinition(FunctionDefinitionModelItem item);
-    void removeTypeAlias(TypeAliasModelItem item);
+    void removeTypeDef(TypeDefModelItem item);
     void removeVariable(VariableModelItem item);
 
     ClassModelItem findClass(const QString &name) const;
     EnumModelItem findEnum(const QString &name) const;
     FunctionDefinitionList findFunctionDefinitions(const QString &name) const;
     FunctionList findFunctions(const QString &name) const;
-    TypeAliasModelItem findTypeAlias(const QString &name) const;
+    TypeDefModelItem findTypeDef(const QString &name) const;
     VariableModelItem findVariable(const QString &name) const;
 
     void addEnumsDeclaration(const QString &enumsDeclaration);
@@ -329,9 +329,9 @@ public:
     {
         return _M_enums;
     }
-    inline QHash<QString, TypeAliasModelItem> typeAliasMap() const
+    inline QHash<QString, TypeDefModelItem> typeDefMap() const
     {
-        return _M_typeAliases;
+        return _M_typeDefs;
     }
     inline QHash<QString, VariableModelItem> variableMap() const
     {
@@ -357,7 +357,7 @@ protected:
 private:
     QHash<QString, ClassModelItem> _M_classes;
     QHash<QString, EnumModelItem> _M_enums;
-    QHash<QString, TypeAliasModelItem> _M_typeAliases;
+    QHash<QString, TypeDefModelItem> _M_typeDefs;
     QHash<QString, VariableModelItem> _M_variables;
     QMultiHash<QString, FunctionDefinitionModelItem> _M_functionDefinitions;
     QMultiHash<QString, FunctionModelItem> _M_functions;
@@ -631,14 +631,14 @@ public:
         : _MemberModelItem(model, name, kind) {}
 };
 
-class _TypeAliasModelItem: public _CodeModelItem
+class _TypeDefModelItem: public _CodeModelItem
 {
 public:
-    DECLARE_MODEL_NODE(TypeAlias)
+    DECLARE_MODEL_NODE(TypeDef)
 
-    explicit _TypeAliasModelItem(CodeModel *model, int kind = __node_kind)
+    explicit _TypeDefModelItem(CodeModel *model, int kind = __node_kind)
         : _CodeModelItem(model, kind) {}
-    explicit _TypeAliasModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
+    explicit _TypeDefModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
         : _CodeModelItem(model, name, kind) {}
 
     TypeInfo type() const;
diff --git a/ApiExtractor/parser/codemodel_fwd.h b/ApiExtractor/parser/codemodel_fwd.h
index dcdead7ac..087e06ce5 100644
--- a/ApiExtractor/parser/codemodel_fwd.h
+++ b/ApiExtractor/parser/codemodel_fwd.h
@@ -47,7 +47,7 @@ class _FunctionModelItem;
 class _NamespaceModelItem;
 class _ScopeModelItem;
 class _TemplateParameterModelItem;
-class _TypeAliasModelItem;
+class _TypeDefModelItem;
 class _VariableModelItem;
 class _MemberModelItem;
 class TypeInfo;
@@ -63,7 +63,7 @@ typedef QSharedPointer<_FunctionModelItem> FunctionModelItem;
 typedef QSharedPointer<_NamespaceModelItem> NamespaceModelItem;
 typedef QSharedPointer<_ScopeModelItem> ScopeModelItem;
 typedef QSharedPointer<_TemplateParameterModelItem> TemplateParameterModelItem;
-typedef QSharedPointer<_TypeAliasModelItem> TypeAliasModelItem;
+typedef QSharedPointer<_TypeDefModelItem> TypeDefModelItem;
 typedef QSharedPointer<_VariableModelItem> VariableModelItem;
 typedef QSharedPointer<_MemberModelItem> MemberModelItem;
 
@@ -78,7 +78,7 @@ typedef QList<FunctionModelItem> FunctionList;
 typedef QList<NamespaceModelItem> NamespaceList;
 typedef QList<ScopeModelItem> ScopeList;
 typedef QList<TemplateParameterModelItem> TemplateParameterList;
-typedef QList<TypeAliasModelItem> TypeAliasList;
+typedef QList<TypeDefModelItem> TypeDefList;
 typedef QList<VariableModelItem> VariableList;
 typedef QList<MemberModelItem> MemberList;
 
diff --git a/ApiExtractor/tests/testabstractmetatype.cpp b/ApiExtractor/tests/testabstractmetatype.cpp
index 8fc0d01a9..4519932d5 100644
--- a/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/ApiExtractor/tests/testabstractmetatype.cpp
@@ -145,7 +145,7 @@ void TestAbstractMetaType::testTypedef()
     QCOMPARE(classes.size(), 1);
     AbstractMetaClass* c = classes.findClass(QLatin1String("C"));
     QVERIFY(c);
-    QVERIFY(c->isTypeAlias());
+    QVERIFY(c->isTypeDef());
 }
 
 void TestAbstractMetaType::testTypedefWithTemplates()
diff --git a/ApiExtractor/tests/testtemplates.cpp b/ApiExtractor/tests/testtemplates.cpp
index b753add9d..01cd08804 100644
--- a/ApiExtractor/tests/testtemplates.cpp
+++ b/ApiExtractor/tests/testtemplates.cpp
@@ -332,7 +332,7 @@ void TestTemplates::testTypedefOfInstantiationOfTemplateClass()
     QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
     QCOMPARE(one->functions().count(), base->functions().count());
-    QVERIFY(one->isTypeAlias());
+    QVERIFY(one->isTypeDef());
     const ComplexTypeEntry* oneType = one->typeEntry();
     const ComplexTypeEntry* baseType = base->typeEntry();
     QCOMPARE(oneType->baseContainerType(), baseType);
diff --git a/ApiExtractor/typesystem.cpp b/ApiExtractor/typesystem.cpp
index 94bdb10ec..b9a57e532 100644
--- a/ApiExtractor/typesystem.cpp
+++ b/ApiExtractor/typesystem.cpp
@@ -1871,16 +1871,16 @@ bool Handler::startElement(const QString &, const QString &n,
     return true;
 }
 
-PrimitiveTypeEntry* PrimitiveTypeEntry::basicAliasedTypeEntry() const
+PrimitiveTypeEntry *PrimitiveTypeEntry::basicReferencedTypeEntry() const
 {
-    if (!m_aliasedTypeEntry)
+    if (!m_referencedTypeEntry)
         return 0;
 
-    PrimitiveTypeEntry* baseAliasTypeEntry = m_aliasedTypeEntry->basicAliasedTypeEntry();
-    if (baseAliasTypeEntry)
-        return baseAliasTypeEntry;
+    PrimitiveTypeEntry *baseReferencedTypeEntry = m_referencedTypeEntry->basicReferencedTypeEntry();
+    if (baseReferencedTypeEntry)
+        return baseReferencedTypeEntry;
     else
-        return m_aliasedTypeEntry;
+        return m_referencedTypeEntry;
 }
 
 typedef QHash<const PrimitiveTypeEntry*, QString> PrimitiveTypeEntryTargetLangPackageMap;
@@ -2360,9 +2360,9 @@ bool TypeEntry::isCppPrimitive() const
     if (!isPrimitive())
         return false;
 
-    const PrimitiveTypeEntry *aliasedType =
-        static_cast<const PrimitiveTypeEntry *>(this)->basicAliasedTypeEntry();
-    QByteArray typeName = (aliasedType ? aliasedType->name() : m_name).toUtf8();
+    const PrimitiveTypeEntry *referencedType =
+        static_cast<const PrimitiveTypeEntry *>(this)->basicReferencedTypeEntry();
+    QByteArray typeName = (referencedType ? referencedType->name() : m_name).toUtf8();
 
     if (typeName.contains(' ') || m_type == VoidType)
         return true;
diff --git a/ApiExtractor/typesystem.h b/ApiExtractor/typesystem.h
index a645cfc46..279d3f0de 100644
--- a/ApiExtractor/typesystem.h
+++ b/ApiExtractor/typesystem.h
@@ -1026,7 +1026,7 @@ public:
             : TypeEntry(name, PrimitiveType, vr),
               m_preferredConversion(true),
               m_preferredTargetLangType(true),
-              m_aliasedTypeEntry(0)
+              m_referencedTypeEntry(0)
     {
     }
 
@@ -1063,28 +1063,28 @@ public:
 
     /**
      *   The PrimitiveTypeEntry pointed by this type entry if it
-     *   represents an alias (i.e. a typedef).
-     *   /return the type pointed by the alias, or a null pointer
-     *   if the current object is not an alias
+     *   represents a typedef).
+     *   /return the type referenced by the typedef, or a null pointer
+     *   if the current object is not an typedef
      */
-    PrimitiveTypeEntry* aliasedTypeEntry() const { return m_aliasedTypeEntry; }
+    PrimitiveTypeEntry* referencedTypeEntry() const { return m_referencedTypeEntry; }
 
     /**
-     *   Defines type aliased by this entry.
-     *   /param aliasedTypeEntry type aliased by this entry
+     *   Defines type referenced by this entry.
+     *   /param referencedTypeEntry type referenced by this entry
      */
-    void setAliasedTypeEntry(PrimitiveTypeEntry* aliasedTypeEntry)
+    void setReferencedTypeEntry(PrimitiveTypeEntry* referencedTypeEntry)
     {
-        m_aliasedTypeEntry = aliasedTypeEntry;
+        m_referencedTypeEntry = referencedTypeEntry;
     }
 
     /**
      *   Finds the most basic primitive type that the typedef represents,
-     *   i.e. a type that is not an alias.
-     *   /return the most basic non-aliased primitive type represented
+     *   i.e. a type that is not an typedef'ed.
+     *   /return the most basic non-typedef'ed primitive type represented
      *   by this typedef
      */
-    PrimitiveTypeEntry* basicAliasedTypeEntry() const;
+    PrimitiveTypeEntry* basicReferencedTypeEntry() const;
 
     virtual bool preferredConversion() const
     {
@@ -1112,7 +1112,7 @@ private:
     QString m_defaultConstructor;
     uint m_preferredConversion : 1;
     uint m_preferredTargetLangType : 1;
-    PrimitiveTypeEntry* m_aliasedTypeEntry;
+    PrimitiveTypeEntry* m_referencedTypeEntry;
 };
 
 struct EnumValueRedirection
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index 42ff38303..67ebfe063 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -171,8 +171,8 @@ bool CppGenerator::hasBoolCast(const AbstractMetaClass* metaClass) const
     if (!func || !func->type() || !func->type()->typeEntry()->isPrimitive() || !func->isPublic())
         return false;
     const PrimitiveTypeEntry* pte = static_cast<const PrimitiveTypeEntry*>(func->type()->typeEntry());
-    while (pte->aliasedTypeEntry())
-        pte = pte->aliasedTypeEntry();
+    while (pte->referencedTypeEntry())
+        pte = pte->referencedTypeEntry();
     return func && func->isConstant() && pte->name() == QLatin1String("bool") && func->arguments().isEmpty();
 }
 
@@ -687,8 +687,8 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
                             || arg->type()->isReference();
 
             if (!convert && argType->isPrimitive()) {
-                if (argType->basicAliasedTypeEntry())
-                    argType = argType->basicAliasedTypeEntry();
+                if (argType->basicReferencedTypeEntry())
+                    argType = argType->basicReferencedTypeEntry();
                 convert = !m_formatUnits.contains(argType->name());
             }
 
@@ -1773,8 +1773,8 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
                     strArg = QLatin1String("\" SBK_STR_NAME \"");
                 } else if (argType->isPrimitive()) {
                     const PrimitiveTypeEntry* ptp = reinterpret_cast<const PrimitiveTypeEntry*>(argType->typeEntry());
-                    while (ptp->aliasedTypeEntry())
-                        ptp = ptp->aliasedTypeEntry();
+                    while (ptp->referencedTypeEntry())
+                        ptp = ptp->referencedTypeEntry();
                     strArg = ptp->name();
                     if (strArg == QLatin1String("QString")) {
                         strArg = QLatin1String("unicode");
@@ -5010,10 +5010,10 @@ bool CppGenerator::finishGeneration()
     foreach(const PrimitiveTypeEntry* pte, primitiveTypes()) {
         if (!pte->generateCode() || !pte->isCppPrimitive())
             continue;
-        const TypeEntry* alias = pte->basicAliasedTypeEntry();
-        if (!alias)
+        const TypeEntry *referencedType = pte->basicReferencedTypeEntry();
+        if (!referencedType)
             continue;
-        QString converter = converterObject(alias);
+        QString converter = converterObject(referencedType);
         QStringList cppSignature = pte->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts);
         while (!cppSignature.isEmpty()) {
             QString signature = cppSignature.join(QLatin1String("::"));
diff --git a/generator/shiboken2/overloaddata.cpp b/generator/shiboken2/overloaddata.cpp
index b7d639325..2e757e74a 100644
--- a/generator/shiboken2/overloaddata.cpp
+++ b/generator/shiboken2/overloaddata.cpp
@@ -36,12 +36,12 @@
 #include <QtCore/QFile>
 #include <QtCore/QTemporaryFile>
 
-static const TypeEntry* getAliasedTypeEntry(const TypeEntry* typeEntry)
+static const TypeEntry *getReferencedTypeEntry(const TypeEntry *typeEntry)
 {
     if (typeEntry->isPrimitive()) {
         const PrimitiveTypeEntry* pte = dynamic_cast<const PrimitiveTypeEntry*>(typeEntry);
-        while (pte->aliasedTypeEntry())
-            pte = pte->aliasedTypeEntry();
+        while (pte->referencedTypeEntry())
+            pte = pte->referencedTypeEntry();
         typeEntry = pte;
     }
     return typeEntry;
@@ -49,12 +49,12 @@ static const TypeEntry* getAliasedTypeEntry(const TypeEntry* typeEntry)
 
 static QString getTypeName(const AbstractMetaType* type)
 {
-    const TypeEntry* typeEntry = getAliasedTypeEntry(type->typeEntry());
+    const TypeEntry* typeEntry = getReferencedTypeEntry(type->typeEntry());
     QString typeName = typeEntry->name();
     if (typeEntry->isContainer()) {
         QStringList types;
         foreach (const AbstractMetaType* cType, type->instantiations()) {
-            const TypeEntry* typeEntry = getAliasedTypeEntry(cType->typeEntry());
+            const TypeEntry *typeEntry = getReferencedTypeEntry(cType->typeEntry());
             types << typeEntry->name();
         }
         typeName += QLatin1Char('<') + types.join(QLatin1Char(',')) + QLatin1String(" >");
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index 036043cdf..5b2d75830 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -627,8 +627,8 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
             result += QLatin1Char(objType);
         } else if (arg->type()->isPrimitive()) {
             const PrimitiveTypeEntry* ptype = (const PrimitiveTypeEntry*) arg->type()->typeEntry();
-            if (ptype->basicAliasedTypeEntry())
-                ptype = ptype->basicAliasedTypeEntry();
+            if (ptype->basicReferencedTypeEntry())
+                ptype = ptype->basicReferencedTypeEntry();
             if (m_formatUnits.contains(ptype->name()))
                 result += m_formatUnits[ptype->name()];
             else
@@ -666,8 +666,8 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type)
         baseName = QLatin1String("Sbk_") + type->name();
     } else if (type->isPrimitive()) {
         const PrimitiveTypeEntry* ptype = (const PrimitiveTypeEntry*) type;
-        while (ptype->basicAliasedTypeEntry())
-            ptype = ptype->basicAliasedTypeEntry();
+        while (ptype->basicReferencedTypeEntry())
+            ptype = ptype->basicReferencedTypeEntry();
         if (ptype->targetLangApiName() == ptype->name())
             baseName = pythonPrimitiveTypeName(ptype->name());
         else
@@ -756,8 +756,8 @@ QString ShibokenGenerator::converterObject(const TypeEntry* type)
         qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName();
         return QString::null;
     }
-    if (pte->basicAliasedTypeEntry())
-        pte = pte->basicAliasedTypeEntry();
+    if (pte->basicReferencedTypeEntry())
+        pte = pte->basicReferencedTypeEntry();
     if (pte->isPrimitive() && !pte->isCppPrimitive() && !pte->customConversion())
         return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(pte->qualifiedCppName());
 
@@ -831,8 +831,8 @@ QString ShibokenGenerator::pythonPrimitiveTypeName(const QString& cppTypeName)
 
 QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry* type)
 {
-    while (type->basicAliasedTypeEntry())
-        type = type->basicAliasedTypeEntry();
+    while (type->basicReferencedTypeEntry())
+        type = type->basicReferencedTypeEntry();
     return pythonPrimitiveTypeName(type->name());
 }
 
@@ -967,8 +967,8 @@ bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type)
     if (!type->isPrimitive())
         return false;
     const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
-    if (trueType->basicAliasedTypeEntry())
-        trueType = trueType->basicAliasedTypeEntry();
+    if (trueType->basicReferencedTypeEntry())
+        trueType = trueType->basicReferencedTypeEntry();
     return trueType->isPrimitive() && !trueType->isCppPrimitive()
            && trueType->qualifiedCppName() != QLatin1String("std::string");
 }
@@ -987,8 +987,8 @@ bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type)
     if (!type->isPrimitive())
         return false;
     const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
-    if (trueType->basicAliasedTypeEntry())
-        trueType = trueType->basicAliasedTypeEntry();
+    if (trueType->basicReferencedTypeEntry())
+        trueType = trueType->basicReferencedTypeEntry();
     return trueType->qualifiedCppName() == QLatin1String("std::string");
 }
 
@@ -2467,8 +2467,8 @@ QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type)
 {
     if (type->isCppPrimitive()) {
         const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
-        if (trueType->basicAliasedTypeEntry())
-            type = trueType->basicAliasedTypeEntry();
+        if (trueType->basicReferencedTypeEntry())
+            type = trueType->basicReferencedTypeEntry();
     }
     return QString::fromLatin1("SBK_%1_IDX").arg(_fixedCppTypeName(type->qualifiedCppName()).toUpper());
 }
@@ -2555,8 +2555,8 @@ bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type)
     if (!type->isCppPrimitive())
         return false;
     const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
-    if (trueType->basicAliasedTypeEntry())
-        trueType = trueType->basicAliasedTypeEntry();
+    if (trueType->basicReferencedTypeEntry())
+        trueType = trueType->basicReferencedTypeEntry();
     QString typeName = trueType->qualifiedCppName();
     return !typeName.contains(QLatin1String("double"))
         && !typeName.contains(QLatin1String("float"))