diff --git a/kdevplatform/language/duchain/types/typerepository.cpp b/kdevplatform/language/duchain/types/typerepository.cpp
index 14361f713d..938574f836 100644
--- a/kdevplatform/language/duchain/types/typerepository.cpp
+++ b/kdevplatform/language/duchain/types/typerepository.cpp
@@ -1,155 +1,157 @@
 /*
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "typerepository.h"
 
 #include <QMutex>
 #include <QMutexLocker>
 
 #include <debug.h>
 #include "../types/typesystemdata.h"
 #include "../types/typeregister.h"
 #include <serialization/referencecounting.h>
 #include <serialization/itemrepository.h>
 
 #define DEBUG_TYPE_REPOSITORY
 #define ASSERT_ON_PROBLEM
 
 namespace KDevelop  {
 
 class AbstractTypeDataRequest {
   public:
   AbstractTypeDataRequest(const AbstractType& type) : m_item(type) {
   }
 
   enum {
     AverageSize = sizeof(AbstractTypeData) + 12
   };
 
   unsigned int hash() const {
     return m_item.hash();
   }
 
   uint itemSize() const {
     return TypeSystem::self().dynamicSize(*m_item.d_ptr);
   }
 
   void createItem(AbstractTypeData* item) const {
     TypeSystem::self().copy(*m_item.d_ptr, *item, true);
     Q_ASSERT(!item->m_dynamic);
 #ifdef DEBUG_TYPE_REPOSITORY
     AbstractType::Ptr otherType( TypeSystem::self().create(const_cast<AbstractTypeData*>(item)) );
     if(!otherType->equals(&m_item)) {
       //For debugging, so one can trace what happened
       qCWarning(LANGUAGE) << "created type in repository does not equal source type:" << m_item.toString() << otherType->toString();
       TypeSystem::self().copy(*m_item.d_ptr, *item, true);
       otherType->equals(&m_item);
     }
 #ifdef ASSERT_ON_PROBLEM
     Q_ASSERT(otherType->equals(&m_item));
 #endif
 #endif
     item->inRepository = true;
   }
   
   static void destroy(AbstractTypeData* item, KDevelop::AbstractItemRepository&) {
     TypeSystem::self().callDestructor(item);
   }
   
   static bool persistent(const AbstractTypeData* item) {
     // Don't try to delete release items for which the factory is not loaded, as that will lead to a crash/assertion later
     return (bool)item->refCount || !TypeSystem::self().isFactoryLoaded(*item);
   }
 
   bool equals(const AbstractTypeData* item) const {
+    if (!TypeSystem::self().isFactoryLoaded(*item))
+        return false;
+
     AbstractType::Ptr otherType( TypeSystem::self().create(const_cast<AbstractTypeData*>(item)) );
-    if(!otherType)
-      return false;
+    Q_ASSERT(otherType);
     return m_item.equals(otherType.data());
   }
 
   const AbstractType& m_item;
 };
 
 //The object is created in a function, to prevent initialization-order issues
 static RepositoryManager< ItemRepository<AbstractTypeData, AbstractTypeDataRequest>, false>& typeRepository() {
   static RepositoryManager< ItemRepository<AbstractTypeData, AbstractTypeDataRequest>, false> repository(QStringLiteral("Type Repository"));
   return repository;
 }
 
 void initTypeRepository() {
   typeRepository();
 }
 
 AbstractRepositoryManager* typeRepositoryManager() {
   return &typeRepository();
 }
 
 uint TypeRepository::indexForType(const AbstractType::Ptr input) {
   if(!input)
     return 0;
 
   uint i = typeRepository()->index(AbstractTypeDataRequest(*input));
 #ifdef DEBUG_TYPE_REPOSITORY
   AbstractType::Ptr t = typeForIndex(i);
   if(!t->equals(input.data())) {
       qCWarning(LANGUAGE) << "found type in repository does not equal source type:" << input->toString() << t->toString();
       t->equals(input.data());
   }
 #ifdef ASSERT_ON_PROBLEM
   Q_ASSERT(t->equals(input.data()));
   Q_ASSERT(input->equals(t.data()));
 #endif
 #endif
   return i;
 }
 
 AbstractType::Ptr TypeRepository::typeForIndex(uint index) {
   if(index == 0)
     return AbstractType::Ptr();
 
   return AbstractType::Ptr( TypeSystem::self().create(const_cast<AbstractTypeData*>(typeRepository()->itemFromIndex(index))) );
 }
 
 void TypeRepository::increaseReferenceCount(uint index, ReferenceCountManager* manager) {
   if(!index)
     return;
   QMutexLocker lock(typeRepository()->mutex());
   AbstractTypeData* data = typeRepository()->dynamicItemFromIndexSimple(index);
   Q_ASSERT(data);
   if(manager)
     manager->increase(data->refCount, index);
   else
     ++data->refCount;
 }
 
 void TypeRepository::decreaseReferenceCount(uint index, ReferenceCountManager* manager) {
   if(!index)
     return;
   QMutexLocker lock(typeRepository()->mutex());
   AbstractTypeData* data = typeRepository()->dynamicItemFromIndexSimple(index);
   Q_ASSERT(data);
   Q_ASSERT(data->refCount > 0);
   if(manager)
     manager->decrease(data->refCount, index);
   else
   --data->refCount;
 }
 
 
 }