5 files changed, 55 insertions, 26 deletions
diff --git a/src/qml/compiler/qqmlpropertycachecreator_p.h b/src/qml/compiler/qqmlpropertycachecreator_p.h
index 7d416561bb..a1e93702d1 100644
--- a/src/qml/compiler/qqmlpropertycachecreator_p.h
+++ b/src/qml/compiler/qqmlpropertycachecreator_p.h
@@ -693,11 +693,6 @@ inline QQmlCompileError QQmlPropertyCacheAliasCreator<ObjectContainer>::property
         const CompiledObject &component, const QV4::CompiledData::Alias &alias, int *type, int *minorVersion,
         QQmlPropertyData::Flags *propertyFlags)
 {
-    const int targetObjectIndex = objectForId(component, alias.targetObjectId);
-    Q_ASSERT(targetObjectIndex >= 0);
-
-    const CompiledObject &targetObject = *objectContainer->objectAt(targetObjectIndex);
-
     *type = 0;
     bool writable = false;
     bool resettable = false;
@@ -705,11 +700,36 @@ inline QQmlCompileError QQmlPropertyCacheAliasCreator<ObjectContainer>::property
     propertyFlags->isAlias = true;
 
     if (alias.aliasToLocalAlias) {
-        auto targetAlias = targetObject.aliasesBegin();
-        for (uint i = 0; i < alias.localAliasIndex; ++i)
-            ++targetAlias;
-        return propertyDataForAlias(component, *targetAlias, type, minorVersion, propertyFlags);
-    } else if (alias.encodedMetaPropertyIndex == -1) {
+        const QV4::CompiledData::Alias *lastAlias = &alias;
+        QVarLengthArray<const QV4::CompiledData::Alias *, 4> seenAliases({lastAlias});
+
+        do {
+            const CompiledObject *targetObject = objectContainer->objectAt(
+                    objectForId(component, lastAlias->targetObjectId));
+            Q_ASSERT(targetObject);
+
+            auto nextAlias = targetObject->aliasesBegin();
+            for (uint i = 0; i < lastAlias->localAliasIndex; ++i)
+                ++nextAlias;
+
+            const QV4::CompiledData::Alias *targetAlias = &(*nextAlias);
+            if (seenAliases.contains(targetAlias)) {
+                return QQmlCompileError(targetAlias->location,
+                                        QQmlPropertyCacheCreatorBase::tr("Cyclic alias"));
+            }
+
+            seenAliases.append(targetAlias);
+            lastAlias = targetAlias;
+        } while (lastAlias->aliasToLocalAlias);
+
+        return propertyDataForAlias(component, *lastAlias, type, minorVersion, propertyFlags);
+    }
+
+    const int targetObjectIndex = objectForId(component, alias.targetObjectId);
+    Q_ASSERT(targetObjectIndex >= 0);
+    const CompiledObject &targetObject = *objectContainer->objectAt(targetObjectIndex);
+
+    if (alias.encodedMetaPropertyIndex == -1) {
         Q_ASSERT(alias.flags & QV4::CompiledData::Alias::AliasPointsToPointerObject);
         auto *typeRef = objectContainer->resolvedType(targetObject.inheritedTypeNameIndex);
         if (!typeRef) {
diff --git a/src/qml/compiler/qqmlpropertyvalidator.cpp b/src/qml/compiler/qqmlpropertyvalidator.cpp
index 4714f505a7..8c06760d42 100644
--- a/src/qml/compiler/qqmlpropertyvalidator.cpp
+++ b/src/qml/compiler/qqmlpropertyvalidator.cpp
@@ -693,7 +693,10 @@ QQmlCompileError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *
     } else if (binding->flags & QV4::CompiledData::Binding::IsSignalHandlerObject && property->isFunction()) {
         return noError;
     } else if (QQmlValueTypeFactory::isValueType(property->propType())) {
-        return QQmlCompileError(binding->location, tr("Unexpected object assignment for property \"%1\"").arg(propertyName));
+        auto typeName = QMetaType::typeName(property->propType());
+        return QQmlCompileError(binding->location, tr("Can not assign value of type \"%1\" to property \"%2\", expecting an object")
+                                                      .arg(typeName ? QString::fromLatin1(typeName) : QString::fromLatin1("<unknown type>"))
+                                                      .arg(propertyName));
     } else if (property->propType() == qMetaTypeId<QQmlScriptString>()) {
         return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: script expected"));
     } else {
diff --git a/src/qml/compiler/qv4compileddata.cpp b/src/qml/compiler/qv4compileddata.cpp
index f280994d54..a78094f17c 100644
--- a/src/qml/compiler/qv4compileddata.cpp
+++ b/src/qml/compiler/qv4compileddata.cpp
@@ -470,8 +470,10 @@ Heap::Module *CompilationUnit::instantiate(ExecutionEngine *engine)
     ScopedString importName(scope);
 
     const uint importCount = data->importEntryTableSize;
-    imports = new const Value *[importCount];
-    memset(imports, 0, importCount * sizeof(Value *));
+    if (importCount > 0) {
+        imports = new const Value *[importCount];
+        memset(imports, 0, importCount * sizeof(Value *));
+    }
     for (uint i = 0; i < importCount; ++i) {
         const CompiledData::ImportEntry &entry = data->importEntryTable()[i];
         auto dependentModuleUnit = engine->loadModule(QUrl(stringAt(entry.moduleRequest)), this);
@@ -897,6 +899,8 @@ bool ResolvedTypeReference::addToHash(QCryptographicHash *hash, QQmlEngine *engi
         hash->addData(createPropertyCache(engine)->checksum(&ok));
         return ok;
     }
+    if (!compilationUnit)
+        return false;
     hash->addData(compilationUnit->unitData()->md5Checksum, sizeof(compilationUnit->unitData()->md5Checksum));
     return true;
 }
diff --git a/src/qml/compiler/qv4compilercontext_p.h b/src/qml/compiler/qv4compilercontext_p.h
index cb20ea9d57..57ef4be36e 100644
--- a/src/qml/compiler/qv4compilercontext_p.h
+++ b/src/qml/compiler/qv4compilercontext_p.h
@@ -217,7 +217,6 @@ struct Context {
     bool usesThis = false;
     bool innerFunctionAccessesThis = false;
     bool innerFunctionAccessesNewTarget = false;
-    bool hasTry = false;
     bool returnsClosure = false;
     mutable bool argumentsCanEscape = false;
     bool requiresExecutionContext = false;
diff --git a/src/qml/compiler/qv4compilerscanfunctions.cpp b/src/qml/compiler/qv4compilerscanfunctions.cpp
index 04593f202a..8984b6931e 100644
--- a/src/qml/compiler/qv4compilerscanfunctions.cpp
+++ b/src/qml/compiler/qv4compilerscanfunctions.cpp
@@ -741,9 +741,9 @@ void ScanFunctions::calcEscapingVariables()
         if (c->contextType != ContextType::ESModule)
             continue;
         for (const auto &entry: c->exportEntries) {
-            auto m = c->members.find(entry.localName);
-            if (m != c->members.end())
-                m->canEscape = true;
+            auto mIt = c->members.constFind(entry.localName);
+            if (mIt != c->members.constEnd())
+                mIt->canEscape = true;
         }
         break;
     }
@@ -759,8 +759,8 @@ void ScanFunctions::calcEscapingVariables()
             }
             Q_ASSERT(c != inner);
             while (c) {
-                Context::MemberMap::const_iterator it = c->members.find(var);
-                if (it != c->members.end()) {
+                Context::MemberMap::const_iterator it = c->members.constFind(var);
+                if (it != c->members.constEnd()) {
                     if (c->parent || it->isLexicallyScoped()) {
                         it->canEscape = true;
                         c->requiresExecutionContext = true;
@@ -816,15 +816,17 @@ void ScanFunctions::calcEscapingVariables()
             // add an escaping 'this' variable
             c->addLocalVar(QStringLiteral("this"), Context::VariableDefinition, VariableScope::Let);
             c->requiresExecutionContext = true;
-            auto m = c->members.find(QStringLiteral("this"));
-            m->canEscape = true;
+            auto mIt = c->members.constFind(QStringLiteral("this"));
+            Q_ASSERT(mIt != c->members.constEnd());
+            mIt->canEscape = true;
         }
         if (c->innerFunctionAccessesNewTarget) {
             // add an escaping 'new.target' variable
             c->addLocalVar(QStringLiteral("new.target"), Context::VariableDefinition, VariableScope::Let);
             c->requiresExecutionContext = true;
-            auto m = c->members.find(QStringLiteral("new.target"));
-            m->canEscape = true;
+            auto mIt = c->members.constFind(QStringLiteral("new.target"));
+            Q_ASSERT(mIt != c->members.constEnd());
+            mIt->canEscape = true;
         }
         if (c->allVarsEscape && c->contextType == ContextType::Block && c->members.isEmpty())
             c->allVarsEscape = false;
@@ -845,8 +847,9 @@ void ScanFunctions::calcEscapingVariables()
         }
         if (c->contextType == ContextType::Block && c->isCatchBlock) {
             c->requiresExecutionContext = true;
-            auto m = c->members.find(c->caughtVariable);
-            m->canEscape = true;
+            auto mIt = c->members.constFind(c->caughtVariable);
+            Q_ASSERT(mIt != c->members.constEnd());
+            mIt->canEscape = true;
         }
         const QLatin1String exprForOn("expression for on");
         if (c->contextType == ContextType::Binding && c->name.length() > exprForOn.size() &&
@@ -855,7 +858,7 @@ void ScanFunctions::calcEscapingVariables()
             // we don't know if the code is a signal handler or not.
             c->requiresExecutionContext = true;
         if (c->allVarsEscape) {
-            for (auto &m : c->members)
+            for (const auto &m : qAsConst(c->members))
                 m.canEscape = true;
         }
     }