Re-do QML type compilation of ahead-of-time generated QML cache files

As we currently lack the ability to do type resolution at AOT cache
generation time, we need to re-do the work after loading the cache file,
making us essentially only re-use the code and avoiding the step of
parsing.

Change-Id: I12844692d4766345d8a313b59d21abf1f868e2d1
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 152 insertions, 0 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index 54d0cb4f46..8a7507c92e 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -2061,4 +2061,156 @@ QQmlPropertyData *PropertyResolver::signal(const QString &name, bool *notInRevis
     return 0;
 }
 
+IRLoader::IRLoader(const QV4::CompiledData::Unit *qmlData, QmlIR::Document *output)
+    : unit(qmlData)
+    , output(output)
+{
+    pool = output->jsParserEngine.pool();
+}
+
+void IRLoader::load()
+{
+    output->jsGenerator.stringTable.clear();
+    for (uint i = 0; i < unit->stringTableSize; ++i)
+        output->jsGenerator.stringTable.registerString(unit->stringAt(i));
+
+    for (quint32 i = 0; i < unit->nImports; ++i)
+        output->imports << unit->importAt(i);
+
+    if (unit->flags & QV4::CompiledData::Unit::IsSingleton) {
+        QmlIR::Pragma *p = New<QmlIR::Pragma>();
+        p->location = QV4::CompiledData::Location();
+        p->type = QmlIR::Pragma::PragmaSingleton;
+        output->pragmas << p;
+    }
+
+    output->indexOfRootObject = unit->indexOfRootObject;
+
+    for (uint i = 0; i < unit->nObjects; ++i) {
+        const QV4::CompiledData::Object *serializedObject = unit->objectAt(i);
+        QmlIR::Object *object = loadObject(serializedObject);
+        output->objects.append(object);
+    }
+}
+
+struct FakeExpression : public QQmlJS::AST::NullExpression
+{
+    FakeExpression(int start, int length)
+        : location(start, length)
+    {}
+
+    virtual QQmlJS::AST::SourceLocation firstSourceLocation() const
+    { return location; }
+
+    virtual QQmlJS::AST::SourceLocation lastSourceLocation() const
+    { return location; }
+
+private:
+    QQmlJS::AST::SourceLocation location;
+};
+
+QmlIR::Object *IRLoader::loadObject(const QV4::CompiledData::Object *serializedObject)
+{
+    QmlIR::Object *object = pool->New<QmlIR::Object>();
+    object->init(pool, serializedObject->inheritedTypeNameIndex, serializedObject->idNameIndex);
+
+    object->indexOfDefaultPropertyOrAlias = serializedObject->indexOfDefaultPropertyOrAlias;
+    object->defaultPropertyIsAlias = serializedObject->defaultPropertyIsAlias;
+
+    object->location = serializedObject->location;
+    object->locationOfIdProperty = serializedObject->locationOfIdProperty;
+
+    QVector<int> functionIndices;
+    functionIndices.reserve(serializedObject->nFunctions + serializedObject->nBindings / 2);
+
+    for (uint i = 0; i < serializedObject->nBindings; ++i) {
+        QmlIR::Binding *b = pool->New<QmlIR::Binding>();
+        *static_cast<QV4::CompiledData::Binding*>(b) = serializedObject->bindingTable()[i];
+        object->bindings->append(b);
+        if (b->type == QV4::CompiledData::Binding::Type_Script) {
+            functionIndices.append(b->value.compiledScriptIndex);
+            b->value.compiledScriptIndex = functionIndices.count() - 1;
+
+            QmlIR::CompiledFunctionOrExpression *foe = pool->New<QmlIR::CompiledFunctionOrExpression>();
+            foe->disableAcceleratedLookups = true;
+            foe->nameIndex = 0;
+
+            QQmlJS::AST::ExpressionNode *expr;
+
+            if (b->stringIndex != quint32(0)) {
+                const int start = output->code.length();
+                const QString script = output->stringAt(b->stringIndex);
+                const int length = script.length();
+                output->code.append(script);
+                expr = new (pool) FakeExpression(start, length);
+            } else
+                expr = new (pool) QQmlJS::AST::NullExpression();
+            foe->node = new (pool) QQmlJS::AST::ExpressionStatement(expr); // dummy
+            object->functionsAndExpressions->append(foe);
+        }
+    }
+
+    Q_ASSERT(object->functionsAndExpressions->count == functionIndices.count());
+
+    for (uint i = 0; i < serializedObject->nSignals; ++i) {
+        const QV4::CompiledData::Signal *serializedSignal = serializedObject->signalAt(i);
+        QmlIR::Signal *s = pool->New<QmlIR::Signal>();
+        s->nameIndex = serializedSignal->nameIndex;
+        s->location = serializedSignal->location;
+        s->parameters = pool->New<QmlIR::PoolList<QmlIR::SignalParameter> >();
+
+        for (uint i = 0; i < serializedSignal->nParameters; ++i) {
+            QmlIR::SignalParameter *p = pool->New<QmlIR::SignalParameter>();
+            *static_cast<QV4::CompiledData::Parameter*>(p) = *serializedSignal->parameterAt(i);
+            s->parameters->append(p);
+        }
+
+        object->qmlSignals->append(s);
+    }
+
+    const QV4::CompiledData::Property *serializedProperty = serializedObject->propertyTable();
+    for (uint i = 0; i < serializedObject->nProperties; ++i, ++serializedProperty) {
+        QmlIR::Property *p = pool->New<QmlIR::Property>();
+        *static_cast<QV4::CompiledData::Property*>(p) = *serializedProperty;
+        object->properties->append(p);
+    }
+
+    QQmlJS::Engine *jsParserEngine = &output->jsParserEngine;
+
+    const QV4::CompiledData::LEUInt32 *functionIdx = serializedObject->functionOffsetTable();
+    for (uint i = 0; i < serializedObject->nFunctions; ++i, ++functionIdx) {
+        QmlIR::Function *f = pool->New<QmlIR::Function>();
+        const QV4::CompiledData::Function *compiledFunction = unit->functionAt(*functionIdx);
+
+        functionIndices.append(*functionIdx);
+        f->index = functionIndices.count() - 1;
+        f->location = compiledFunction->location;
+        f->nameIndex = compiledFunction->nameIndex;
+
+        QQmlJS::AST::FormalParameterList *paramList = 0;
+        const QV4::CompiledData::LEUInt32 *formalNameIdx = compiledFunction->formalsTable();
+        for (uint i = 0; i < compiledFunction->nFormals; ++i, ++formalNameIdx) {
+            const QString formal = unit->stringAt(*formalNameIdx);
+            QStringRef paramNameRef = jsParserEngine->newStringRef(formal);
+
+            if (paramList)
+                paramList = new (pool) QQmlJS::AST::FormalParameterList(paramList, paramNameRef);
+            else
+                paramList = new (pool) QQmlJS::AST::FormalParameterList(paramNameRef);
+        }
+
+        if (paramList)
+            paramList = paramList->finish();
+
+        const QString name = unit->stringAt(compiledFunction->nameIndex);
+        f->functionDeclaration = new(pool) QQmlJS::AST::FunctionDeclaration(jsParserEngine->newStringRef(name), paramList, /*body*/0);
+
+        object->functions->append(f);
+    }
+
+    object->runtimeFunctionIndices.allocate(pool, functionIndices);
+
+    return object;
+}
+
 #endif // V4_BOOTSTRAP