Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-doc-team into 4.7

12 files changed, 397 insertions, 144 deletions

diff --git a/src/declarative/qml/qdeclarativecompileddata.cpp b/src/declarative/qml/qdeclarativecompileddata.cpp
index 5d73d89..a4ecc77 100644
--- a/src/declarative/qml/qdeclarativecompileddata.cpp
+++ b/src/declarative/qml/qdeclarativecompileddata.cpp
@@ -205,7 +205,7 @@ const QMetaObject *QDeclarativeCompiledData::TypeReference::metaObject() const
         return type->metaObject();
     } else {
         Q_ASSERT(component);
-        return static_cast<QDeclarativeComponentPrivate *>(QObjectPrivate::get(component))->cc->root;
+        return component->root;
     }
 }
 
diff --git a/src/declarative/qml/qdeclarativecompiler.cpp b/src/declarative/qml/qdeclarativecompiler.cpp
index 74bc5bd..b2740b8 100644
--- a/src/declarative/qml/qdeclarativecompiler.cpp
+++ b/src/declarative/qml/qdeclarativecompiler.cpp
@@ -590,7 +590,7 @@ bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,
                 COMPILE_EXCEPTION(parserRef->refObjects.first(), err);
             }
         } else if (tref.typeData) {
-            ref.component = tref.typeData->component();
+            ref.component = tref.typeData->compiledData();
             ref.ref = tref.typeData;
             ref.ref->addref();
         }
@@ -722,7 +722,7 @@ bool QDeclarativeCompiler::buildObject(Object *obj, const BindingContext &ctxt)
     obj->metatype = tr.metaObject();
 
     if (tr.component)
-        obj->url = tr.component->url();
+        obj->url = tr.component->url;
     if (tr.type)
         obj->typeName = tr.type->qmlTypeName();
     obj->className = tr.className;
@@ -940,7 +940,7 @@ void QDeclarativeCompiler::genObject(QDeclarativeParser::Object *obj)
         // ### Surely the creation of this property cache could be more efficient
         QDeclarativePropertyCache *propertyCache = 0;
         if (tr.component)
-            propertyCache = QDeclarativeComponentPrivate::get(tr.component)->cc->rootPropertyCache->copy();
+            propertyCache = tr.component->rootPropertyCache->copy();
         else
             propertyCache = enginePrivate->cache(obj->metaObject()->superClass())->copy();
 
@@ -957,7 +957,7 @@ void QDeclarativeCompiler::genObject(QDeclarativeParser::Object *obj)
         output->bytecode << meta;
     } else if (obj == unitRoot) {
         if (tr.component)
-            output->rootPropertyCache = QDeclarativeComponentPrivate::get(tr.component)->cc->rootPropertyCache;
+            output->rootPropertyCache = tr.component->rootPropertyCache;
         else
             output->rootPropertyCache = enginePrivate->cache(obj->metaObject());
 
diff --git a/src/declarative/qml/qdeclarativecompiler_p.h b/src/declarative/qml/qdeclarativecompiler_p.h
index 89eef09..43a0901 100644
--- a/src/declarative/qml/qdeclarativecompiler_p.h
+++ b/src/declarative/qml/qdeclarativecompiler_p.h
@@ -93,10 +93,11 @@ public:
 
         QByteArray className;
         QDeclarativeType *type;
-        QDeclarativeComponent *component;
+//        QDeclarativeComponent *component;
+        QDeclarativeCompiledData *component;
 
         QDeclarativeRefCount *ref;
-        QObject *createInstance(QDeclarativeContextData *, const QBitField &) const;
+        QObject *createInstance(QDeclarativeContextData *, const QBitField &, QList<QDeclarativeError> *) const;
         const QMetaObject *metaObject() const;
     };
     QList<TypeReference> types;
diff --git a/src/declarative/qml/qdeclarativecomponent.cpp b/src/declarative/qml/qdeclarativecomponent.cpp
index cfef9cf..0a2a6db 100644
--- a/src/declarative/qml/qdeclarativecomponent.cpp
+++ b/src/declarative/qml/qdeclarativecomponent.cpp
@@ -733,48 +733,45 @@ QDeclarativeComponentPrivate::beginCreate(QDeclarativeContextData *context, cons
         return 0;
     }
 
-    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
+    return begin(context, creationContext, cc, start, count, &state, 0, bindings);
+}
+
+QObject * QDeclarativeComponentPrivate::begin(QDeclarativeContextData *parentContext, 
+                                              QDeclarativeContextData *componentCreationContext,
+                                              QDeclarativeCompiledData *component, int start, int count,
+                                              ConstructionState *state, QList<QDeclarativeError> *errors,
+                                              const QBitField &bindings)
+{
+    QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(parentContext->engine);
+    bool isRoot = !enginePriv->inBeginCreate;
+
+    Q_ASSERT(!isRoot || state); // Either this isn't a root component, or a state data must be provided
+    Q_ASSERT((state != 0) ^ (errors != 0)); // One of state or errors (but not both) must be provided
 
-    bool isRoot = !ep->inBeginCreate;
     if (isRoot) 
         QDeclarativeDebugTrace::startRange(QDeclarativeDebugTrace::Creating);
-    QDeclarativeDebugTrace::rangeData(QDeclarativeDebugTrace::Creating, cc->url);
 
     QDeclarativeContextData *ctxt = new QDeclarativeContextData;
     ctxt->isInternal = true;
-    ctxt->url = cc->url;
-    ctxt->imports = cc->importCache;
+    ctxt->url = component->url;
+    ctxt->imports = component->importCache;
 
     // Nested global imports
-    if (creationContext && start != -1) 
-        ctxt->importedScripts = creationContext->importedScripts;
-
-    cc->importCache->addref();
-    ctxt->setParent(context);
+    if (componentCreationContext && start != -1) 
+        ctxt->importedScripts = componentCreationContext->importedScripts;
 
-    QObject *rv = begin(ctxt, ep, cc, start, count, &state, bindings);
+    component->importCache->addref();
+    ctxt->setParent(parentContext);
 
-    if (ep->isDebugging && rv) {
-        if  (!context->isInternal)
-            context->asQDeclarativeContextPrivate()->instances.append(rv);
-        QDeclarativeEngineDebugServer::instance()->objectCreated(engine, rv);
-    }
-
-    return rv;
-}
-
-QObject * QDeclarativeComponentPrivate::begin(QDeclarativeContextData *ctxt, QDeclarativeEnginePrivate *enginePriv,
-                                              QDeclarativeCompiledData *component, int start, int count,
-                                              ConstructionState *state, const QBitField &bindings)
-{
-    bool isRoot = !enginePriv->inBeginCreate;
     enginePriv->inBeginCreate = true;
 
     QDeclarativeVME vme;
     QObject *rv = vme.run(ctxt, component, start, count, bindings);
 
-    if (vme.isError()) 
-        state->errors = vme.errors();
+    if (vme.isError()) {
+       if(errors) *errors = vme.errors();
+       else state->errors = vme.errors();
+    }
 
     if (isRoot) {
         enginePriv->inBeginCreate = false;
@@ -794,6 +791,12 @@ QObject * QDeclarativeComponentPrivate::begin(QDeclarativeContextData *ctxt, QDe
         enginePriv->inProgressCreations++;
     }
 
+    if (enginePriv->isDebugging && rv) {
+        if  (!parentContext->isInternal)
+            parentContext->asQDeclarativeContextPrivate()->instances.append(rv);
+        QDeclarativeEngineDebugServer::instance()->objectCreated(parentContext->engine, rv);
+    }
+
     return rv;
 }
 
diff --git a/src/declarative/qml/qdeclarativecomponent_p.h b/src/declarative/qml/qdeclarativecomponent_p.h
index a551cc8..7b30bad 100644
--- a/src/declarative/qml/qdeclarativecomponent_p.h
+++ b/src/declarative/qml/qdeclarativecomponent_p.h
@@ -109,9 +109,10 @@ public:
     };
     ConstructionState state;
 
-    static QObject *begin(QDeclarativeContextData *ctxt, QDeclarativeEnginePrivate *enginePriv,
-                          QDeclarativeCompiledData *component, int start, int count,
-                          ConstructionState *state, const QBitField &bindings = QBitField());
+    static QObject *begin(QDeclarativeContextData *parentContext, QDeclarativeContextData *componentCreationContext,
+                          QDeclarativeCompiledData *component, int start, int count, 
+                          ConstructionState *state, QList<QDeclarativeError> *errors, 
+                          const QBitField &bindings = QBitField());
     static void beginDeferred(QDeclarativeEnginePrivate *enginePriv, QObject *object, 
                               ConstructionState *state);
     static void complete(QDeclarativeEnginePrivate *enginePriv, ConstructionState *state);
diff --git a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
index 61a1f55..ea92111 100644
--- a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
+++ b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
@@ -838,9 +838,19 @@ QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::
 {
     MethodData *method = static_cast<MethodData *>(o);
 
-    if (method->data.flags & QDeclarativePropertyCache::Data::HasArguments) {
+    if (method->data.relatedIndex == -1)
+        return callPrecise(method->object, method->data, ctxt);
+    else
+        return callOverloaded(method, ctxt);
+}
 
-        QMetaMethod m = method->object->metaObject()->method(method->data.coreIndex);
+QDeclarativeObjectMethodScriptClass::Value 
+QDeclarativeObjectMethodScriptClass::callPrecise(QObject *object, const QDeclarativePropertyCache::Data &data, 
+                                                 QScriptContext *ctxt)
+{
+    if (data.flags & QDeclarativePropertyCache::Data::HasArguments) {
+
+        QMetaMethod m = object->metaObject()->method(data.coreIndex);
         QList<QByteArray> argTypeNames = m.parameterTypes();
         QVarLengthArray<int, 9> argTypes(argTypeNames.count());
 
@@ -848,7 +858,7 @@ QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::
         for (int ii = 0; ii < argTypeNames.count(); ++ii) {
             argTypes[ii] = QMetaType::type(argTypeNames.at(ii));
             if (argTypes[ii] == QVariant::Invalid) 
-                argTypes[ii] = enumType(method->object->metaObject(), QString::fromLatin1(argTypeNames.at(ii)));
+                argTypes[ii] = enumType(object->metaObject(), QString::fromLatin1(argTypeNames.at(ii)));
             if (argTypes[ii] == QVariant::Invalid) 
                 return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii)))));
         }
@@ -856,39 +866,301 @@ QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::
         if (argTypes.count() > ctxt->argumentCount())
             return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments")));
 
-        QVarLengthArray<MetaCallArgument, 9> args(argTypes.count() + 1);
-        args[0].initAsType(method->data.propType, engine);
+        return callMethod(object, data.coreIndex, data.propType, argTypes.count(), argTypes.data(), ctxt);
+
+    } else {
+
+        return callMethod(object, data.coreIndex, data.propType, 0, 0, ctxt);
+
+    }
+}
+
+QDeclarativeObjectMethodScriptClass::Value 
+QDeclarativeObjectMethodScriptClass::callMethod(QObject *object, int index, 
+                                                int returnType, int argCount, int *argTypes, 
+                                                QScriptContext *ctxt)
+{
+    if (argCount > 0) {
 
-        for (int ii = 0; ii < argTypes.count(); ++ii)
+        QVarLengthArray<MetaCallArgument, 9> args(argCount + 1);
+        args[0].initAsType(returnType, engine);
+
+        for (int ii = 0; ii < argCount; ++ii)
             args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii));
 
         QVarLengthArray<void *, 9> argData(args.count());
         for (int ii = 0; ii < args.count(); ++ii)
             argData[ii] = args[ii].dataPtr();
 
-        QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, argData.data());
+        QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, argData.data());
 
         return args[0].toValue(engine);
 
-    } else if (method->data.propType != 0) {
-
+    } else if (returnType != 0) {
+        
         MetaCallArgument arg;
-        arg.initAsType(method->data.propType, engine);
+        arg.initAsType(returnType, engine);
 
         void *args[] = { arg.dataPtr() };
 
-        QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
+        QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
 
         return arg.toValue(engine);
 
     } else {
 
         void *args[] = { 0 };
-        QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
+        QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
         return Value();
 
     }
-    return Value();
+}
+
+/*!
+Resolve the overloaded method to call.  The algorithm works conceptually like this:
+    1.  Resolve the set of overloads it is *possible* to call.
+        Impossible overloads include those that have too many parameters or have parameters 
+        of unknown type.  
+    2.  Filter the set of overloads to only contain those with the closest number of 
+        parameters.
+        For example, if we are called with 3 parameters and there are 2 overloads that
+        take 2 parameters and one that takes 3, eliminate the 2 parameter overloads.
+    3.  Find the best remaining overload based on its match score.  
+        If two or more overloads have the same match score, call the last one.  The match
+        score is constructed by adding the matchScore() result for each of the parameters.
+*/
+QDeclarativeObjectMethodScriptClass::Value
+QDeclarativeObjectMethodScriptClass::callOverloaded(MethodData *method, QScriptContext *ctxt)
+{
+    int argumentCount = ctxt->argumentCount();
+
+    QDeclarativePropertyCache::Data *best = 0;
+    int bestParameterScore = INT_MAX;
+    int bestMatchScore = INT_MAX;
+
+    QDeclarativePropertyCache::Data dummy;
+    QDeclarativePropertyCache::Data *attempt = &method->data;
+
+    do {
+        QList<QByteArray> methodArgTypeNames;
+
+        if (attempt->flags & QDeclarativePropertyCache::Data::HasArguments)
+            methodArgTypeNames = method->object->metaObject()->method(attempt->coreIndex).parameterTypes();
+
+        int methodArgumentCount = methodArgTypeNames.count();
+
+        if (methodArgumentCount > argumentCount)
+            continue; // We don't have sufficient arguments to call this method
+
+        int methodParameterScore = argumentCount - methodArgumentCount;
+        if (methodParameterScore > bestParameterScore)
+            continue; // We already have a better option
+
+        int methodMatchScore = 0;
+        QVarLengthArray<int, 9> methodArgTypes(methodArgumentCount);
+
+        bool unknownArgument = false;
+        for (int ii = 0; ii < methodArgumentCount; ++ii) {
+            methodArgTypes[ii] = QMetaType::type(methodArgTypeNames.at(ii));
+            if (methodArgTypes[ii] == QVariant::Invalid) 
+                methodArgTypes[ii] = enumType(method->object->metaObject(), 
+                                              QString::fromLatin1(methodArgTypeNames.at(ii)));
+            if (methodArgTypes[ii] == QVariant::Invalid) {
+                unknownArgument = true;
+                break;
+            }
+            methodMatchScore += matchScore(ctxt->argument(ii), methodArgTypes[ii], methodArgTypeNames.at(ii));
+        }
+        if (unknownArgument)
+            continue; // We don't understand all the parameters
+
+        if (bestParameterScore > methodParameterScore || bestMatchScore > methodMatchScore) {
+            best = attempt;
+            bestParameterScore = methodParameterScore;
+            bestMatchScore = methodMatchScore;
+        }
+
+        if (bestParameterScore == 0 && bestMatchScore == 0)
+            break; // We can't get better than that
+
+    } while((attempt = relatedMethod(method->object, attempt, dummy)) != 0);
+
+    if (best) {
+        return callPrecise(method->object, *best, ctxt);
+    } else {
+        QString error = QLatin1String("Unable to determine callable overload.  Candidates are:");
+        QDeclarativePropertyCache::Data *candidate = &method->data;
+        while (candidate) {
+            error += QLatin1String("\n    ") + QString::fromUtf8(method->object->metaObject()->method(candidate->coreIndex).signature());
+            candidate = relatedMethod(method->object, candidate, dummy);
+        }
+        return Value(ctxt, ctxt->throwError(error));
+    }
+}
+
+/*!
+    Returns the match score for converting \a actual to be of type \a conversionType.  A 
+    zero score means "perfect match" whereas a higher score is worse.
+
+    The conversion table is copied out of the QtScript callQtMethod() function.
+*/
+int QDeclarativeObjectMethodScriptClass::matchScore(const QScriptValue &actual, int conversionType, 
+                                                    const QByteArray &conversionTypeName)
+{
+    if (actual.isNumber()) {
+        switch (conversionType) {
+        case QMetaType::Double:
+            return 0;
+        case QMetaType::Float:
+            return 1;
+        case QMetaType::LongLong:
+        case QMetaType::ULongLong:
+            return 2;
+        case QMetaType::Long:
+        case QMetaType::ULong:
+            return 3;
+        case QMetaType::Int:
+        case QMetaType::UInt:
+            return 4;
+        case QMetaType::Short:
+        case QMetaType::UShort:
+            return 5;
+            break;
+        case QMetaType::Char:
+        case QMetaType::UChar:
+            return 6;
+        default:
+            return 10;
+        }
+    } else if (actual.isString()) {
+        switch (conversionType) {
+        case QMetaType::QString:
+            return 0;
+        default:
+            return 10;
+        }
+    } else if (actual.isBoolean()) {
+        switch (conversionType) {
+        case QMetaType::Bool:
+            return 0;
+        default:
+            return 10;
+        }
+    } else if (actual.isDate()) {
+        switch (conversionType) {
+        case QMetaType::QDateTime:
+            return 0;
+        case QMetaType::QDate:
+            return 1;
+        case QMetaType::QTime:
+            return 2;
+        default:
+            return 10;
+        }
+    } else if (actual.isRegExp()) {
+        switch (conversionType) {
+        case QMetaType::QRegExp:
+            return 0;
+        default:
+            return 10;
+        }
+    } else if (actual.isVariant()) {
+        if (conversionType == qMetaTypeId<QVariant>())
+            return 0;
+        else if (actual.toVariant().userType() == conversionType)
+            return 0;
+        else
+            return 10;
+    } else if (actual.isArray()) {
+        switch (conversionType) {
+        case QMetaType::QStringList:
+        case QMetaType::QVariantList:
+            return 5;
+        default:
+            return 10;
+        }
+    } else if (actual.isQObject()) {
+        switch (conversionType) {
+        case QMetaType::QObjectStar:
+            return 0;
+        default:
+            return 10;
+        }
+    } else if (actual.isNull()) {
+        switch (conversionType) {
+        case QMetaType::VoidStar:
+        case QMetaType::QObjectStar:
+            return 0;
+        default:
+            if (!conversionTypeName.endsWith('*'))
+                return 10;
+            else
+                return 0;
+        }
+    } else {
+        return 10;
+    }
+}
+
+static inline int QMetaObject_methods(const QMetaObject *metaObject)
+{
+    struct Private
+    {
+        int revision;
+        int className;
+        int classInfoCount, classInfoData;
+        int methodCount, methodData;
+    };
+
+    return reinterpret_cast<const Private *>(metaObject->d.data)->methodCount;
+}
+
+static QByteArray QMetaMethod_name(const QMetaMethod &m)
+{
+    QByteArray sig = m.signature();
+    int paren = sig.indexOf('(');
+    if (paren == -1)
+        return sig;
+    else
+        return sig.left(paren);
+}
+
+/*!
+Returns the next related method, if one, or 0.
+*/
+QDeclarativePropertyCache::Data *
+QDeclarativeObjectMethodScriptClass::relatedMethod(QObject *object, QDeclarativePropertyCache::Data *current, 
+                                                   QDeclarativePropertyCache::Data &dummy)
+{
+    QDeclarativePropertyCache *cache = QDeclarativeData::get(object)->propertyCache;
+    if (current->relatedIndex == -1)
+        return 0;
+
+    if (cache) {
+        return cache->method(current->relatedIndex);
+    } else {
+        const QMetaObject *mo = object->metaObject();
+        int methodOffset = mo->methodCount() - QMetaObject_methods(mo);
+
+        while (methodOffset > current->relatedIndex) {
+            mo = mo->superClass();
+            methodOffset -= QMetaObject_methods(mo);
+        }
+
+        QMetaMethod method = mo->method(current->relatedIndex);
+        dummy.load(method);
+        
+        // Look for overloaded methods
+        QByteArray methodName = QMetaMethod_name(method);
+        for (int ii = current->relatedIndex - 1; ii >= methodOffset; --ii) {
+            if (methodName == QMetaMethod_name(mo->method(ii))) {
+                dummy.relatedIndex = ii;
+                return &dummy;
+            }
+        }
+
+        return &dummy;
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qdeclarativeobjectscriptclass_p.h b/src/declarative/qml/qdeclarativeobjectscriptclass_p.h
index 75e384c..7956c40 100644
--- a/src/declarative/qml/qdeclarativeobjectscriptclass_p.h
+++ b/src/declarative/qml/qdeclarativeobjectscriptclass_p.h
@@ -65,6 +65,7 @@ class QDeclarativeEngine;
 class QScriptContext;
 class QScriptEngine;
 class QDeclarativeContextData;
+class MethodData;
 
 class Q_AUTOTEST_EXPORT QDeclarativeObjectMethodScriptClass : public QScriptDeclarativeClass
 {
@@ -82,6 +83,14 @@ protected:
 private:
     int enumType(const QMetaObject *, const QString &);
 
+    Value callPrecise(QObject *, const QDeclarativePropertyCache::Data &, QScriptContext *);
+    Value callOverloaded(MethodData *, QScriptContext *);
+    Value callMethod(QObject *, int index, int returnType, int argCount, int *argTypes, QScriptContext *ctxt);
+
+    int matchScore(const QScriptValue &, int, const QByteArray &);
+    QDeclarativePropertyCache::Data *relatedMethod(QObject *, QDeclarativePropertyCache::Data *current, 
+                                                   QDeclarativePropertyCache::Data &dummy);
+
     PersistentIdentifier m_connectId;
     PersistentIdentifier m_disconnectId;
     QScriptValue m_connect;
diff --git a/src/declarative/qml/qdeclarativepropertycache.cpp b/src/declarative/qml/qdeclarativepropertycache.cpp
index 9e1ceb8..91aaaa4 100644
--- a/src/declarative/qml/qdeclarativepropertycache.cpp
+++ b/src/declarative/qml/qdeclarativepropertycache.cpp
@@ -93,6 +93,7 @@ void QDeclarativePropertyCache::Data::load(const QMetaProperty &p, QDeclarativeE
 void QDeclarativePropertyCache::Data::load(const QMetaMethod &m)
 {
     coreIndex = m.methodIndex();
+    relatedIndex = -1;
     flags |= Data::IsFunction;
     if (m.methodType() == QMetaMethod::Signal)
         flags |= Data::IsSignal;
@@ -140,15 +141,25 @@ void QDeclarativePropertyCache::clear()
         if (indexCache.at(ii)) indexCache.at(ii)->release();
     }
 
+    for (int ii = 0; ii < methodIndexCache.count(); ++ii) {
+        RData *data = methodIndexCache.at(ii);
+        if (data) data->release(); 
+    }
+
     for (StringCache::ConstIterator iter = stringCache.begin(); 
-            iter != stringCache.end(); ++iter)
-        (*iter)->release();
+            iter != stringCache.end(); ++iter) {
+        RData *data = (*iter);
+        data->release(); 
+    }
 
     for (IdentifierCache::ConstIterator iter = identifierCache.begin(); 
-            iter != identifierCache.end(); ++iter)
-        (*iter)->release();
+            iter != identifierCache.end(); ++iter) {
+        RData *data = (*iter);
+        data->release(); 
+    }
 
     indexCache.clear();
+    methodIndexCache.clear();
     stringCache.clear();
     identifierCache.clear();
 }
@@ -202,12 +213,16 @@ QDeclarativePropertyCache *QDeclarativePropertyCache::copy() const
 {
     QDeclarativePropertyCache *cache = new QDeclarativePropertyCache(engine);
     cache->indexCache = indexCache;
+    cache->methodIndexCache = methodIndexCache;
     cache->stringCache = stringCache;
     cache->identifierCache = identifierCache;
 
     for (int ii = 0; ii < indexCache.count(); ++ii) {
         if (indexCache.at(ii)) indexCache.at(ii)->addref();
     }
+    for (int ii = 0; ii < methodIndexCache.count(); ++ii) {
+        if (methodIndexCache.at(ii)) methodIndexCache.at(ii)->addref();
+    }
     for (StringCache::ConstIterator iter = stringCache.begin(); iter != stringCache.end(); ++iter)
         (*iter)->addref();
     for (IdentifierCache::ConstIterator iter = identifierCache.begin(); iter != identifierCache.end(); ++iter)
@@ -227,19 +242,18 @@ void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaOb
     indexCache.resize(propCount);
     for (int ii = propOffset; ii < propCount; ++ii) {
         QMetaProperty p = metaObject->property(ii);
-        if (!p.isScriptable()) 
+        if (!p.isScriptable())  
             continue;
         
         QString propName = QString::fromUtf8(p.name());
 
         RData *data = new RData;
         data->identifier = enginePriv->objectClass->createPersistentIdentifier(propName);
+        indexCache[ii] = data;
 
         data->load(p, engine);
         data->flags |= propertyFlags;
 
-        indexCache[ii] = data;
-
         if (stringCache.contains(propName)) {
             stringCache[propName]->release();
             identifierCache[data->identifier.identifier]->release();
@@ -252,12 +266,13 @@ void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaOb
     }
 
     int methodCount = metaObject->methodCount();
-    int methodOffset = qMax(2, metaObject->methodOffset()); // 2 to block the destroyed signal
+    // 3 to block the destroyed signal and the deleteLater() slot
+    int methodOffset = qMax(3, metaObject->methodOffset()); 
 
     methodIndexCache.resize(methodCount);
     for (int ii = methodOffset; ii < methodCount; ++ii) {
         QMetaMethod m = metaObject->method(ii);
-        if (m.access() == QMetaMethod::Private)
+        if (m.access() == QMetaMethod::Private) 
             continue;
         QString methodName = QString::fromUtf8(m.signature());
 
@@ -267,11 +282,7 @@ void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaOb
 
         RData *data = new RData;
         data->identifier = enginePriv->objectClass->createPersistentIdentifier(methodName);
-
-        if (stringCache.contains(methodName)) {
-            stringCache[methodName]->release();
-            identifierCache[data->identifier.identifier]->release();
-        }
+        methodIndexCache[ii] = data;  
 
         data->load(m);
         if (m.methodType() == QMetaMethod::Slot || m.methodType() == QMetaMethod::Method) 
@@ -279,14 +290,32 @@ void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaOb
         else if (m.methodType() == QMetaMethod::Signal)
             data->flags |= signalFlags;
 
-        methodIndexCache[ii] = data;
+        if (stringCache.contains(methodName)) {
+            RData *old = stringCache[methodName];
+            // We only overload methods in the same class, exactly like C++
+            if (old->flags & Data::IsFunction && old->coreIndex >= methodOffset)
+                data->relatedIndex = old->coreIndex;
+            stringCache[methodName]->release();
+            identifierCache[data->identifier.identifier]->release();
+        }
 
         stringCache.insert(methodName, data);
         identifierCache.insert(data->identifier.identifier, data);
         data->addref();
+        data->addref();
     }
 }
 
+void QDeclarativePropertyCache::updateRecur(QDeclarativeEngine *engine, const QMetaObject *metaObject)
+{
+    if (!metaObject)
+        return;
+
+    updateRecur(engine, metaObject->superClass());
+
+    append(engine, metaObject);
+}
+
 void QDeclarativePropertyCache::update(QDeclarativeEngine *engine, const QMetaObject *metaObject)
 {
     Q_ASSERT(engine);
@@ -295,57 +324,11 @@ void QDeclarativePropertyCache::update(QDeclarativeEngine *engine, const QMetaOb
 
     clear();
 
-    // ### The properties/methods should probably be spliced on a per-metaobject basis
-    int propCount = metaObject->propertyCount();
-
-    indexCache.resize(propCount);
-    for (int ii = propCount - 1; ii >= 0; --ii) {
-        QMetaProperty p = metaObject->property(ii);
-        if (!p.isScriptable()) {
-            indexCache[ii] = 0;
-            continue;
-        }
-        QString propName = QString::fromUtf8(p.name());
-
-        RData *data = new RData;
-        data->identifier = enginePriv->objectClass->createPersistentIdentifier(propName);
-
-        data->load(p, engine);
-
-        indexCache[ii] = data;
-
-        if (stringCache.contains(propName))
-            continue;
-
-        stringCache.insert(propName, data);
-        identifierCache.insert(data->identifier.identifier, data);
-        data->addref();
-        data->addref();
-    }
-
-    int methodCount = metaObject->methodCount();
-    for (int ii = methodCount - 1; ii >= 3; --ii) { // >=3 to block the destroyed signal and deleteLater() slot
-        QMetaMethod m = metaObject->method(ii);
-        if (m.access() == QMetaMethod::Private)
-            continue;
-        QString methodName = QString::fromUtf8(m.signature());
-
-        int parenIdx = methodName.indexOf(QLatin1Char('('));
-        Q_ASSERT(parenIdx != -1);
-        methodName = methodName.left(parenIdx);
-
-        if (stringCache.contains(methodName))
-            continue;
+    // Optimization to prevent unnecessary reallocation of lists
+    indexCache.reserve(metaObject->propertyCount());
+    methodIndexCache.reserve(metaObject->methodCount());
 
-        RData *data = new RData;
-        data->identifier = enginePriv->objectClass->createPersistentIdentifier(methodName);
-
-        data->load(m);
-
-        stringCache.insert(methodName, data);
-        identifierCache.insert(data->identifier.identifier, data);
-        data->addref();
-    }
+    updateRecur(engine,metaObject);
 }
 
 QDeclarativePropertyCache::Data *
diff --git a/src/declarative/qml/qdeclarativepropertycache_p.h b/src/declarative/qml/qdeclarativepropertycache_p.h
index 79b126d..922010d 100644
--- a/src/declarative/qml/qdeclarativepropertycache_p.h
+++ b/src/declarative/qml/qdeclarativepropertycache_p.h
@@ -96,7 +96,7 @@ public:
                     IsVMEFunction     = 0x00000400,
                     HasArguments      = 0x00000800,
                     IsSignal          = 0x00001000,
-                    IsVMESignal       = 0x00002000,
+                    IsVMESignal       = 0x00002000
         };
         Q_DECLARE_FLAGS(Flags, Flag)
 
@@ -105,7 +105,10 @@ public:
         Flags flags;
         int propType;
         int coreIndex;
-        int notifyIndex;
+        union {
+            int notifyIndex; // When !IsFunction
+            int relatedIndex; // When IsFunction
+        };
 
         static Flags flagsForProperty(const QMetaProperty &, QDeclarativeEngine *engine = 0);
         void load(const QMetaProperty &, QDeclarativeEngine *engine = 0);
@@ -152,6 +155,8 @@ private:
     typedef QHash<QString, RData *> StringCache;
     typedef QHash<QScriptDeclarativeClass::Identifier, RData *> IdentifierCache;
 
+    void updateRecur(QDeclarativeEngine *, const QMetaObject *);
+
     QDeclarativeEngine *engine;
     IndexCache indexCache;
     IndexCache methodIndexCache;
diff --git a/src/declarative/qml/qdeclarativetypeloader.cpp b/src/declarative/qml/qdeclarativetypeloader.cpp
index c8e1a07..c015519 100644
--- a/src/declarative/qml/qdeclarativetypeloader.cpp
+++ b/src/declarative/qml/qdeclarativetypeloader.cpp
@@ -719,7 +719,7 @@ void QDeclarativeTypeLoader::clearCache()
 QDeclarativeTypeData::QDeclarativeTypeData(const QUrl &url, QDeclarativeTypeLoader::Options options, 
                                            QDeclarativeTypeLoader *manager)
 : QDeclarativeDataBlob(url, QmlFile), m_options(options), m_typesResolved(false), 
-  m_compiledData(0), m_component(0), m_typeLoader(manager)
+  m_compiledData(0), m_typeLoader(manager)
 {
 }
 
@@ -768,23 +768,6 @@ QDeclarativeCompiledData *QDeclarativeTypeData::compiledData() const
     return m_compiledData;
 }
 
-QDeclarativeComponent *QDeclarativeTypeData::component() const
-{
-    if (!m_component) {
-
-        if (m_compiledData) {
-            m_component = new QDeclarativeComponent(typeLoader()->engine(), m_compiledData, -1, -1, 0);
-        } else {
-            m_component = new QDeclarativeComponent(typeLoader()->engine());
-            QDeclarativeComponentPrivate::get(m_component)->url = finalUrl();
-            QDeclarativeComponentPrivate::get(m_component)->state.errors = errors();
-        }
-
-    }
-
-    return m_component;
-}
-
 void QDeclarativeTypeData::registerCallback(TypeDataCallback *callback)
 {
     Q_ASSERT(!m_callbacks.contains(callback));
diff --git a/src/declarative/qml/qdeclarativetypeloader_p.h b/src/declarative/qml/qdeclarativetypeloader_p.h
index 7381f28..718537a 100644
--- a/src/declarative/qml/qdeclarativetypeloader_p.h
+++ b/src/declarative/qml/qdeclarativetypeloader_p.h
@@ -243,7 +243,6 @@ public:
     const QList<ScriptReference> &resolvedScripts() const;
 
     QDeclarativeCompiledData *compiledData() const;
-    QDeclarativeComponent *component() const;
 
     // Used by QDeclarativeComponent to get notifications
     struct TypeDataCallback {
@@ -278,7 +277,6 @@ private:
     bool m_typesResolved:1;
 
     QDeclarativeCompiledData *m_compiledData;
-    mutable QDeclarativeComponent *m_component;
 
     QList<TypeDataCallback *> m_callbacks;
    
diff --git a/src/declarative/qml/qdeclarativevme.cpp b/src/declarative/qml/qdeclarativevme.cpp
index 360186c..db90aff 100644
--- a/src/declarative/qml/qdeclarativevme.cpp
+++ b/src/declarative/qml/qdeclarativevme.cpp
@@ -185,12 +185,9 @@ QObject *QDeclarativeVME::run(QDeclarativeVMEStack<QObject *> &stack,
                     bindings = bindings.united(bindingSkipList);
 
                 QObject *o = 
-                    types.at(instr.create.type).createInstance(ctxt, bindings);
+                    types.at(instr.create.type).createInstance(ctxt, bindings, &vmeErrors);
 
                 if (!o) {
-                    if(types.at(instr.create.type).component)
-                        vmeErrors << types.at(instr.create.type).component->errors();
-
                     VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create object of type %1").arg(QString::fromLatin1(types.at(instr.create.type).className)));
                 }
 
@@ -933,8 +930,9 @@ QList<QDeclarativeError> QDeclarativeVME::errors() const
 }
 
 QObject *
-QDeclarativeCompiledData::TypeReference::createInstance(QDeclarativeContextData *ctxt, 
-                                                        const QBitField &bindings) const
+QDeclarativeCompiledData::TypeReference::createInstance(QDeclarativeContextData *ctxt,
+                                                        const QBitField &bindings,
+                                                        QList<QDeclarativeError> *errors) const
 {
     if (type) {
         QObject *rv = 0;
@@ -948,7 +946,7 @@ QDeclarativeCompiledData::TypeReference::createInstance(QDeclarativeContextData
         return rv;
     } else {
         Q_ASSERT(component);
-        return QDeclarativeComponentPrivate::get(component)->create(ctxt, bindings);
+        return QDeclarativeComponentPrivate::begin(ctxt, 0, component, -1, -1, 0, errors, bindings);
     } 
 }