Rebase on tagged 4.8 shiboken

ApiExtractor/abstractmetabuilder.h

@@ -37,6 +37,7 @@ class TypeDatabase;
 class AbstractMetaBuilder
 {
 public:
+    typedef QHash<int, AbstractMetaType *> IntAbstractMetaHash;
     enum RejectReason {
         NotInTypeSystem,
         GenerationDisabled,
@@ -102,6 +103,9 @@ class AbstractMetaBuilder
     void figureOutDefaultEnumArguments();
 
     void addAbstractMetaClass(AbstractMetaClass *cls);
+    AbstractMetaClass *createInstantiationMetaClass(ComplexTypeEntry *entry);
+    void traverseInstantiation(ComplexTypeEntry *entry, AbstractMetaClass *metaClass);
+    void addRedirections(ComplexTypeEntry *entry, AbstractMetaClass* metaClass, AbstractMetaClass* fromClass, const QString &accessor);
     AbstractMetaClass *traverseTypeAlias(TypeAliasModelItem item);
     AbstractMetaClass *traverseClass(ClassModelItem item);
     AbstractMetaClass* currentTraversedClass(ScopeModelItem item);
@@ -117,8 +121,8 @@ class AbstractMetaBuilder
     void traverseFields(ScopeModelItem item, AbstractMetaClass *parent);
     void traverseStreamOperator(FunctionModelItem functionItem);
     void traverseOperatorFunction(FunctionModelItem item);
-    AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc);
-    AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc, AbstractMetaClass* metaClass);
+    AbstractMetaFunction* traverseFunction(const AddedFunction& addedFunc, AbstractMetaClass* metaClass = 0,
+                                           const IntAbstractMetaHash &templateArgs = IntAbstractMetaHash());
     AbstractMetaFunction *traverseFunction(FunctionModelItem function);
     AbstractMetaField *traverseField(VariableModelItem field, const AbstractMetaClass *cls);
     void checkFunctionModifications();
@@ -148,6 +152,7 @@ class AbstractMetaBuilder
                                   AbstractMetaFunction *fnc, AbstractMetaClass *,
                                   int argumentIndex);
     AbstractMetaType* translateType(double vr, const AddedFunction::TypeInfo& typeInfo);
+    AbstractMetaType* translateType(double vr, const AddedFunction::TypeInfo& typeInfo, const QHash<int, AbstractMetaType *> &templateArgs);
     AbstractMetaType *translateType(const TypeInfo &type, bool *ok, bool resolveType = true, bool resolveScope = true);
 
     int findOutValueFromString(const QString& stringValue, bool& ok);
@@ -166,7 +171,7 @@ class AbstractMetaBuilder
 
     AbstractMetaClass *findTemplateClass(const QString& name, const AbstractMetaClass *context,
                                          TypeParser::Info *info = 0, ComplexTypeEntry **baseContainerType = 0) const;
-    AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const;
+    AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass, bool useTemplate = true) const;
     bool ancestorHasPrivateCopyConstructor(const AbstractMetaClass* metaClass) const;
 
     bool inheritTemplate(AbstractMetaClass *subclass,

ApiExtractor/abstractmetalang.cpp

@@ -1469,10 +1469,25 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
     return false;
 }
 
+QString AbstractMetaClass::canonicalizeInstantiationName(QString name)
+{
+    name.replace(QRegExp("\\s+"), " ");
+    name.replace(QRegExp("<([^ ])"), "< \\1");
+    name.replace(QRegExp("([^ ])>"), "\\1 >");
+    return name;
+}
 
 QString AbstractMetaClass::name() const
 {
-    return QString(m_typeEntry->targetLangName()).split("::").last();
+    const QString& tlName = m_typeEntry->targetLangName();
+    QStringList templateParts = tlName.split('<');
+    if (templateParts.count() > 1) {
+        QString& templateBaseName = templateParts[0];
+        templateBaseName = templateBaseName.split("::").last();
+        return canonicalizeInstantiationName(templateParts.join("<"));
+    } else {
+        return QString(tlName).split("::").last();
+    }
 }
 
 void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass)

ApiExtractor/abstractmetalang.h

@@ -325,8 +325,17 @@ class AbstractMetaType
     }
     QString name() const
     {
-        if (m_name.isNull())
-            m_name = m_typeEntry->targetLangName().split("::").last();
+        if (m_name.isNull()) {
+            const QString& tlName = m_typeEntry->targetLangName();
+            QStringList templateParts = tlName.split('<');
+            if (templateParts.count() > 1) {
+                QString& templateBaseName = templateParts[0];
+                templateBaseName = templateBaseName.split("::").last();
+                m_name = templateParts.join("<");
+            } else {
+                m_name = QString(tlName).split("::").last();
+            }
+        }
         return m_name;
     }
     QString fullName() const
@@ -1419,7 +1428,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
               m_extractedInterface(0),
               m_primaryInterfaceImplementor(0),
               m_typeEntry(0),
-              m_stream(false)
+              m_stream(false),
+              m_hasInjectedDependencies(false)
     {
     }
 
@@ -1565,6 +1575,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
         return package() + "." + name();
     }
 
+    static QString canonicalizeInstantiationName(QString);
+
     /**
      *   Retrieves the class name without any namespace/scope information.
      *   /return the class name without scope information
@@ -1689,6 +1701,21 @@ class AbstractMetaClass : public AbstractMetaAttributes
      */
     bool hasProtectedMembers() const;
 
+    /**
+     * Tells if this class has dependencies injected by the metabuilder.
+     * \return true if the class has injected dependencies.
+     */
+    bool hasInjectedDependencies() const
+    {
+        return m_hasInjectedDependencies;
+    }
+    /**
+     * Tell the metaclass that it has injected dependencies.
+     */
+    void setHasInjectedDependencies()
+    {
+        m_hasInjectedDependencies = true;
+    }
 
     QList<TypeEntry *> templateArguments() const
     {
@@ -1708,6 +1735,11 @@ class AbstractMetaClass : public AbstractMetaAttributes
         return m_baseClassNames;
     }
 
+    void addBaseClassName(const QString &name)
+    {
+        m_baseClassNames.append(name);
+    }
+
     void setBaseClassNames(const QStringList &names)
     {
         m_baseClassNames = names;
@@ -1955,6 +1987,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
 //     FunctionModelItem m_qDebugStreamFunction;
 
     bool m_stream;
+    bool m_hasInjectedDependencies;
     static int m_count;
 };
 

ApiExtractor/parser/binder.cpp

@@ -33,7 +33,6 @@
 #include "dumptree.h"
 
 #include <iostream>
-#include <QDebug>
 
 Binder::Binder(CodeModel *__model, LocationManager &__location, Control *__control)
         : _M_model(__model),
@@ -45,13 +44,13 @@ Binder::Binder(CodeModel *__model, LocationManager &__location, Control *__contr
         name_cc(this),
         decl_cc(this)
 {
-    _M_qualified_types["char"] = QString();
-    _M_qualified_types["double"] = QString();
-    _M_qualified_types["float"] = QString();
-    _M_qualified_types["int"] = QString();
-    _M_qualified_types["long"] = QString();
-    _M_qualified_types["short"] = QString();
-    _M_qualified_types["void"] = QString();
+    _M_qualified_types.insert("char");
+    _M_qualified_types.insert("double");
+    _M_qualified_types.insert("float");
+    _M_qualified_types.insert("int");
+    _M_qualified_types.insert("long");
+    _M_qualified_types.insert("short");
+    _M_qualified_types.insert("void");
 }
 
 Binder::~Binder()
@@ -521,7 +520,7 @@ void Binder::visitTypedef(TypedefAST *node)
         typeAlias->setName(alias_name);
         typeAlias->setType(qualifyType(typeInfo, currentScope()->qualifiedName()));
         typeAlias->setScope(typedefScope->qualifiedName());
-        _M_qualified_types[typeAlias->qualifiedName().join(".")] = QString();
+        addQualifiedType(typeAlias->qualifiedName());
         currentScope()->addTypeAlias(typeAlias);
     } while (it != end);
 }
@@ -574,7 +573,7 @@ void Binder::visitForwardDeclarationSpecifier(ForwardDeclarationSpecifierAST *no
         return;
 
     ScopeModelItem scope = currentScope();
-    _M_qualified_types[(scope->qualifiedName() + name_cc.qualifiedName()).join(".")] = QString();
+    addQualifiedType((scope->qualifiedName() + name_cc.qualifiedName()));
 }
 
 void Binder::visitClassSpecifier(ClassSpecifierAST *node)
@@ -624,7 +623,7 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
     CodeModel::FunctionType oldFunctionType = changeCurrentFunctionType(CodeModel::Normal);
 
     _M_current_class->setScope(scope->qualifiedName());
-    _M_qualified_types[_M_current_class->qualifiedName().join(".")] = QString();
+    addQualifiedType(_M_current_class->qualifiedName());
 
     scope->addClass(_M_current_class);
 
@@ -673,7 +672,7 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
     _M_current_enum->setAnonymous(isAnonymous);
     _M_current_enum->setScope(enumScope->qualifiedName());
 
-    _M_qualified_types[_M_current_enum->qualifiedName().join(".")] = QString();
+    addQualifiedType(_M_current_enum->qualifiedName());
 
     enumScope->addEnum(_M_current_enum);
 
@@ -806,6 +805,33 @@ void Binder::applyFunctionSpecifiers(const ListNode<std::size_t> *it, FunctionMo
     } while (it != end);
 }
 
+static QString normalizeInstantiationName(const QString &name)
+{
+    const int n = name.indexOf('<');
+    if (n < 0)
+        return name;
+
+    // Convert template arguments into a 'standard' placeholder. This isn't perfect
+    // because it can't hope to understand '<' / '>' used as an operator in an
+    // argument (assuming we don't already fall apart on those elsewhere), but should
+    // suffice to handle most cases.
+    QString result = name;
+
+    // First remove any nested instantiation names
+    QRegExp nested("<([^<>]+)>");
+    int i;
+    while ((i = nested.lastIndexIn(result)) != n) {
+        result.replace(i, nested.matchedLength(), "_");
+    }
+
+    // Now rebuild the name with the template arguments replaced with placeholders
+    QStringList args = result.split(',');
+    result = args[0].left(n + 1) + "_1";
+    for (int a = 1; a < args.count(); ++a)
+        result += QString(", _%1").arg(a + 1);
+    return result + ">";
+}
+
 TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) const
 {
     // ### Potentially improve to use string list in the name table to
@@ -817,7 +843,9 @@ TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) c
     } else {
         QStringList expanded = context;
         expanded << type.qualifiedName();
-        if (_M_qualified_types.contains(expanded.join("."))) {
+        QStringList normalized = expanded;
+        normalized.last() = normalizeInstantiationName(normalized.last());
+        if (_M_qualified_types.contains(normalized.join("."))) {
             TypeInfo modified_type = type;
             modified_type.setQualifiedName(expanded);
             return modified_type;
@@ -843,6 +871,17 @@ TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) c
     }
 }
 
+void Binder::addQualifiedType(const QStringList &name)
+{
+    _M_qualified_types.insert(name.join("."));
+
+    if (name.last().contains('<')) {
+        QStringList normalized = name;
+        normalized.last() = normalizeInstantiationName(normalized.last());
+        _M_qualified_types.insert(normalized.join("."));
+    }
+}
+
 void Binder::updateItemPosition(CodeModelItem item, AST *node)
 {
     QString filename;

ApiExtractor/parser/binder.h

@@ -32,6 +32,8 @@
 #include "name_compiler.h"
 #include "declarator_compiler.h"
 
+#include <QtCore/QSet>
+
 class TokenStream;
 class LocationManager;
 class Control;
@@ -98,6 +100,8 @@ class Binder: protected DefaultVisitor
 
     void updateItemPosition(CodeModelItem item, AST *node);
 
+    void addQualifiedType(const QStringList &name);
+
 private:
     CodeModel *_M_model;
     LocationManager &_M_location;
@@ -113,7 +117,7 @@ class Binder: protected DefaultVisitor
     EnumModelItem _M_current_enum;
     QStringList _M_context;
     TemplateParameterList _M_current_template_parameters; // ### check me
-    QHash<QString, QString> _M_qualified_types;
+    QSet<QString> _M_qualified_types;
     QHash<QString, int> _M_anonymous_enums;
 
 protected:

ApiExtractor/parser/codemodel.cpp

@@ -406,7 +406,10 @@ FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
 
 EnumList _ScopeModelItem::enums() const
 {
-    return _M_enums.values();
+    EnumList result;
+    foreach (const QString& name, _M_enumNames)
+        result.append(_M_enums.value(name));
+    return result;
 }
 
 void _ScopeModelItem::addClass(ClassModelItem item)
@@ -440,7 +443,9 @@ void _ScopeModelItem::addTypeAlias(TypeAliasModelItem item)
 
 void _ScopeModelItem::addEnum(EnumModelItem item)
 {
+    _M_enumNames.removeOne(item->name());
     _M_enums.insert(item->name(), item);
+    _M_enumNames.append(item->name());
 }
 
 void _ScopeModelItem::removeClass(ClassModelItem item)
@@ -499,8 +504,10 @@ void _ScopeModelItem::removeEnum(EnumModelItem item)
 {
     QHash<QString, EnumModelItem>::Iterator it = _M_enums.find(item->name());
 
-    if (it != _M_enums.end() && it.value() == item)
+    if (it != _M_enums.end() && it.value() == item) {
+        _M_enumNames.removeOne(item->name());
         _M_enums.erase(it);
+    }
 }
 
 ClassModelItem _ScopeModelItem::findClass(const QString &name) const

ApiExtractor/parser/codemodel.h

@@ -401,6 +401,7 @@ class _ScopeModelItem: public _CodeModelItem
     _ScopeModelItem(const _ScopeModelItem &other);
     void operator = (const _ScopeModelItem &other);
 
+    QStringList _M_enumNames;
     QStringList _M_enumsDeclarations;
 };
 

ApiExtractor/parser/lexer.cpp

@@ -1387,6 +1387,19 @@ void Lexer::scanKeyword8()
         }
         break;
 
+    case 'n':
+        if (*(cursor + 1) == 'o' &&
+            *(cursor + 2) == 'e' &&
+            *(cursor + 3) == 'x' &&
+            *(cursor + 4) == 'c' &&
+            *(cursor + 5) == 'e' &&
+            *(cursor + 6) == 'p' &&
+            *(cursor + 7) == 't') {
+            token_stream[(int) index++].kind = Token_noexcept;
+            return;
+        }
+        break;
+
     case 'o':
         if (*(cursor + 1) == 'p' &&
             *(cursor + 2) == 'e' &&

ApiExtractor/parser/parser.cpp

@@ -1124,6 +1124,7 @@ bool Parser::parseDeclarator(DeclaratorAST *&node)
             token_stream.nextToken();  // skip ')'
 
             parseCvQualify(ast->fun_cv);
+            parseNoExcept();
             parseExceptionSpecification(ast->exception_spec);
 
             if (token_stream.lookAhead() == Token___attribute__)
@@ -1863,6 +1864,14 @@ bool Parser::parseElaboratedTypeSpecifier(TypeSpecifierAST *&node)
     return false;
 }
 
+bool Parser::parseNoExcept()
+{
+    // right now we only accept 'noexcept' with no conditional
+    CHECK(Token_noexcept);
+
+    return true;
+}
+
 bool Parser::parseExceptionSpecification(ExceptionSpecificationAST *&node)
 {
     std::size_t start = token_stream.cursor();