diff --git a/duchain/builders/contextbuilder.cpp b/duchain/builders/contextbuilder.cpp
index 1ab66a1..bf730f1 100644
--- a/duchain/builders/contextbuilder.cpp
+++ b/duchain/builders/contextbuilder.cpp
@@ -1,497 +1,498 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2008 Niko Sams <niko.sams@gmail.com>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #include "contextbuilder.h"
 
 #include <KLocalizedString>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/classdeclaration.h>
+#include <language/editor/documentrange.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 
 #include "../editorintegrator.h"
 #include "../helper.h"
 #include "../duchaindebug.h"
 #include "../phpducontext.h"
 
 #include "../parser/parsesession.h"
 #include "../parser/phpast.h"
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 ContextBuilder::ContextBuilder()
     : m_isInternalFunctions(false), m_reportErrors(true),
       m_mapAst(false), m_hadUnresolvedIdentifiers(false),
       m_editor(nullptr), m_openNamespaces(nullptr)
 {
 }
 
 ContextBuilder::~ContextBuilder()
 {
 }
 
 EditorIntegrator* ContextBuilder::editor() const
 {
     return m_editor;
 }
 
 ReferencedTopDUContext ContextBuilder::build(const IndexedString& url, AstNode* node,
                                              ReferencedTopDUContext updateContext)
 {
     m_isInternalFunctions = url == internalFunctionFile();
     if ( m_isInternalFunctions ) {
         m_reportErrors = false;
     } else if ( ICore::self() ) {
         m_reportErrors = ICore::self()->languageController()->completionSettings()->highlightSemanticProblems();
     }
 
     if (!updateContext) {
         DUChainReadLocker lock(DUChain::lock());
         updateContext = DUChain::self()->chainForDocument(url);
     }
     if (updateContext) {
         qCDebug(DUCHAIN) << "re-compiling" << url.str();
         DUChainWriteLocker lock(DUChain::lock());
         updateContext->clearImportedParentContexts();
         updateContext->parsingEnvironmentFile()->clearModificationRevisions();
         updateContext->clearProblems();
         updateContext->updateImportsCache();
     } else {
         qCDebug(DUCHAIN) << "compiling" << url.str();
     }
     ReferencedTopDUContext top = ContextBuilderBase::build(url, node, updateContext);
 
     {
         DUChainWriteLocker lock(DUChain::lock());
         top->updateImportsCache();
     }
 
     return top;
 }
 
 bool ContextBuilder::hadUnresolvedIdentifiers() const
 {
     return m_hadUnresolvedIdentifiers;
 }
 
 
 void ContextBuilder::startVisiting(AstNode* node)
 {
     if (compilingContexts()) {
         TopDUContext* top = dynamic_cast<TopDUContext*>(currentContext());
         Q_ASSERT(top);
         {
             DUChainWriteLocker lock(DUChain::lock());
             top->updateImportsCache(); //Mark that we will use a cached import-structure
         }
 
         bool hasImports;
         {
             DUChainReadLocker lock(DUChain::lock());
             hasImports = !top->importedParentContexts().isEmpty();
         }
         if (!hasImports && top->url() != internalFunctionFile()) {
             DUChainWriteLocker lock(DUChain::lock());
             TopDUContext* import = DUChain::self()->chainForDocument(internalFunctionFile());
             if (!import) {
                 qWarning() << "importing internalFunctions failed" << currentContext()->url().str();
                 Q_ASSERT(false);
             } else {
                 top->addImportedParentContext(import);
                 top->updateImportsCache();
             }
         }
 
     }
     visitNode(node);
     if (m_openNamespaces) {
         closeNamespaces(m_openNamespaces);
         m_openNamespaces = nullptr;
     }
 }
 
 DUContext* ContextBuilder::newContext(const RangeInRevision& range)
 {
     return new PhpDUContext<DUContext>(range, currentContext());
 }
 
 TopDUContext* ContextBuilder::newTopContext(const RangeInRevision& range, ParsingEnvironmentFile* file)
 {
     if (!file) {
         file = new ParsingEnvironmentFile(m_editor->parseSession()->currentDocument());
         /// Indexed string for 'Php', identifies environment files from this language plugin
         static const IndexedString phpLangString("Php");
         file->setLanguage(phpLangString);
     }
     TopDUContext* ret = new PhpDUContext<TopDUContext>(m_editor->parseSession()->currentDocument(), range, file);
     ret->setType(DUContext::Global);
     return ret;
 }
 
 void ContextBuilder::setContextOnNode(AstNode* node, DUContext* ctx)
 {
     node->ducontext = ctx;
 }
 
 DUContext* ContextBuilder::contextFromNode(AstNode* node)
 {
     return node->ducontext;
 }
 
 RangeInRevision ContextBuilder::editorFindRange(AstNode* fromRange, AstNode* toRange)
 {
     return m_editor->findRange(fromRange, toRange ? toRange : fromRange);
 }
 
 CursorInRevision ContextBuilder::startPos(AstNode* node)
 {
     return m_editor->findPosition(node->startToken, EditorIntegrator::FrontEdge);
 }
 
 QualifiedIdentifier ContextBuilder::identifierForNode(IdentifierAst* id)
 {
     if (!id)
         return QualifiedIdentifier();
 
     return QualifiedIdentifier(stringForNode(id));
 }
 QualifiedIdentifier ContextBuilder::identifierForNode(VariableIdentifierAst* id)
 {
     if (!id)
         return QualifiedIdentifier();
     QString ret(stringForNode(id));
     ret = ret.mid(1); //cut off $
     return QualifiedIdentifier(ret);
 }
 
 IdentifierPair ContextBuilder::identifierPairForNode( IdentifierAst* id )
 {
     if (!id) {
         return qMakePair(IndexedString(), QualifiedIdentifier());
     }
     const QString ret = stringForNode(id);
 
     return qMakePair(IndexedString(ret), QualifiedIdentifier(ret.toLower()));
 }
 
 QString ContextBuilder::stringForNode(IdentifierAst* node) const
 {
     return m_editor->parseSession()->symbol(node->string);
 }
 QString ContextBuilder::stringForNode(VariableIdentifierAst* node) const
 {
     return m_editor->parseSession()->symbol(node->variable);
 }
 
 void ContextBuilder::visitClassDeclarationStatement(ClassDeclarationStatementAst* node)
 {
     openContext(node, editorFindRange(node, node), DUContext::Class, identifierPairForNode(node->className).second);
     classContextOpened(currentContext()); //This callback is needed, so we can set the internal context and so find the declaration for the context (before closeDeclaration())
     DefaultVisitor::visitClassDeclarationStatement(node);
     closeContext();
 }
 
 void ContextBuilder::classContextOpened(DUContext* context)
 {
     Q_UNUSED(context);
 }
 
 void ContextBuilder::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst* node)
 {
     openContext(node, editorFindRange(node, node), DUContext::Class, identifierPairForNode(node->interfaceName).second);
     classContextOpened(currentContext()); //This callback is needed, so we can set the internal context and so find the declaration for the context (before closeDeclaration())
     DefaultVisitor::visitInterfaceDeclarationStatement(node);
     closeContext();
 }
 
 void ContextBuilder::visitTraitDeclarationStatement(TraitDeclarationStatementAst* node)
 {
     openContext(node, editorFindRange(node, node), DUContext::Class, identifierPairForNode(node->traitName).second);
     classContextOpened(currentContext()); //This callback is needed, so we can set the internal context and so find the declaration for the context (before closeDeclaration())
     DefaultVisitor::visitTraitDeclarationStatement(node);
     closeContext();
 }
 
 void ContextBuilder::visitClassStatement(ClassStatementAst *node)
 {
     visitOptionalModifiers(node->modifiers);
     if (node->methodName) {
         //method declaration
         DUContext* parameters = openContext(node->parameters, DUContext::Function, node->methodName);
         Q_ASSERT(!parameters->inSymbolTable());
 
         visitParameterList(node->parameters);
         closeContext();
 
         if ( !m_isInternalFunctions && node->methodBody ) {
             // the internal functions file has only empty method bodies, so skip them
             DUContext* body = openContext(node->methodBody, DUContext::Other, node->methodName);
             if (compilingContexts()) {
                 DUChainWriteLocker lock(DUChain::lock());
                 body->addImportedParentContext(parameters);
                 body->setInSymbolTable(false);
             }
             visitMethodBody(node->methodBody);
             closeContext();
         }
     } else {
         //member-variable or const
         DefaultVisitor::visitClassStatement(node);
     }
 }
 
 void ContextBuilder::visitFunctionDeclarationStatement(FunctionDeclarationStatementAst* node)
 {
     visitIdentifier(node->functionName);
 
     DUContext* parameters = openContext(node->parameters, DUContext::Function, node->functionName);
     Q_ASSERT(!parameters->inSymbolTable());
 
     visitParameterList(node->parameters);
     closeContext();
 
     if ( !m_isInternalFunctions && node->functionBody ) {
         // the internal functions file has only empty method bodies, so skip them
         DUContext* body = openContext(node->functionBody, DUContext::Other, node->functionName);
         if (compilingContexts()) {
             DUChainWriteLocker lock(DUChain::lock());
             body->addImportedParentContext(parameters);
             body->setInSymbolTable(false);
         }
         visitInnerStatementList(node->functionBody);
         closeContext();
     }
 }
 
 void ContextBuilder::visitClosure(ClosureAst* node)
 {
     DUContext* parameters = openContext(node->parameters, DUContext::Function);
     Q_ASSERT(!parameters->inSymbolTable());
 
     visitParameterList(node->parameters);
     closeContext();
 
     DUContext* imported = nullptr;
     if ( node->lexicalVars ) {
         imported = openContext(node->lexicalVars, DUContext::Other);
         Q_ASSERT(!imported->inSymbolTable());
 
         visitLexicalVarList(node->lexicalVars);
         closeContext();
     }
 
     if ( !m_isInternalFunctions && node->functionBody ) {
         // the internal functions file has only empty method bodies, so skip them
         DUContext* body = openContext(node->functionBody, DUContext::Other);
         if (compilingContexts()) {
             DUChainWriteLocker lock;
             body->addImportedParentContext(parameters);
             if (imported) {
                 body->addImportedParentContext(imported, CursorInRevision::invalid(), true);
             }
             body->setInSymbolTable(false);
         }
         visitInnerStatementList(node->functionBody);
         closeContext();
     }
 }
 
 void ContextBuilder::visitNamespaceDeclarationStatement(NamespaceDeclarationStatementAst* node)
 {
     // close existing namespace context
     if (m_openNamespaces) {
         closeNamespaces(m_openNamespaces);
         m_openNamespaces = nullptr;
     }
 
     if ( !node->namespaceNameSequence ) {
         if (node->body) {
             // global namespace
             DefaultVisitor::visitInnerStatementList(node->body);
         }
         return;
     }
 
     { // open
     ///TODO: support \ as separator
 
     RangeInRevision bodyRange;
     if (node->body) {
         bodyRange = editorFindRange(node->body, node->body);
     } else {
         bodyRange = RangeInRevision(m_editor->findPosition(node->endToken), currentContext()->topContext()->range().end);
     }
     const KDevPG::ListNode< IdentifierAst* >* it = node->namespaceNameSequence->front();
     do {
         openNamespace(node, it->element, identifierPairForNode(it->element), bodyRange);
     } while(it->hasNext() && (it = it->next));
     }
 
     if (node->body) {
         DefaultVisitor::visitInnerStatementList(node->body);
         closeNamespaces(node);
     } else {
         m_openNamespaces = node;
     }
 }
 
 void ContextBuilder::closeNamespaces(NamespaceDeclarationStatementAst* namespaces)
 {
     ///TODO: support \ as separator
     const KDevPG::ListNode< IdentifierAst* >* it = namespaces->namespaceNameSequence->front();
     do {
         Q_ASSERT(currentContext()->type() == DUContext::Namespace);
         closeNamespace(namespaces, it->element, identifierPairForNode(it->element));
     } while(it->hasNext() && (it = it->next));
 }
 
 void ContextBuilder::openNamespace(NamespaceDeclarationStatementAst* parent, IdentifierAst* node, const IdentifierPair& identifier, const RangeInRevision& range)
 {
     if ( node == parent->namespaceNameSequence->back()->element ) {
         openContext(node, range, DUContext::Namespace, identifier.second);
     } else {
         openContext(node, range, DUContext::Namespace, identifier.second);
     }
 }
 
 void ContextBuilder::closeNamespace(NamespaceDeclarationStatementAst* /*parent*/, IdentifierAst* /*node*/, const IdentifierPair& /*identifier*/)
 {
     closeContext();
 }
 
 void ContextBuilder::addBaseType(NamespacedIdentifierAst * identifier)
 {
     DUChainWriteLocker lock(DUChain::lock());
 
     Q_ASSERT(currentContext()->type() == DUContext::Class);
 
     ClassDeclaration* currentClass = dynamic_cast<ClassDeclaration*>(currentContext()->owner());
 
     ClassDeclaration* baseClass = dynamic_cast<ClassDeclaration*>(
         findDeclarationImport(ClassDeclarationType, identifierForNamespace(identifier, m_editor)).data() );
 
     if (currentClass && baseClass) {
         if (DUContext* baseContext = baseClass->logicalInternalContext(nullptr)) {
             // prevent circular context imports which could lead to segfaults
             if (!baseContext->imports(currentContext()) && !currentContext()->imports(baseContext)) {
                 currentContext()->addImportedParentContext(baseContext);
                 BaseClassInstance base;
                 base.baseClass = baseClass->indexedType();
                 base.access = Declaration::Public;
                 base.virtualInheritance = false;
                 currentClass->addBaseClass(base);
             } else if (m_reportErrors) {
                 reportError(i18n("Circular inheritance of %1 and %2", currentClass->toString(), baseClass->toString()), identifier);
             }
         }
     }
     if (!baseClass) {
         qCDebug(DUCHAIN) << "unresolved identifier";
         m_hadUnresolvedIdentifiers = true;
     }
 }
 
 
 void ContextBuilder::visitUnaryExpression(UnaryExpressionAst* node)
 {
     DefaultVisitor::visitUnaryExpression(node);
     if (!compilingContexts()) {
         return;
     }
     IndexedString includeFile = getIncludeFileForNode(node, m_editor);
 
     if ( !includeFile.isEmpty() ) {
         DUChainWriteLocker lock(DUChain::lock());
         TopDUContext *top = DUChain::self()->chainForDocument(includeFile);
         if (top) {
             currentContext()->topContext()->addImportedParentContext(top);
             currentContext()->topContext()->parsingEnvironmentFile()
             ->addModificationRevisions(top->parsingEnvironmentFile()->allModificationRevisions());
         }
     }
 }
 
 void ContextBuilder::reportError(const QString& errorMsg, AstNode* node, IProblem::Severity severity)
 {
     reportError(errorMsg, m_editor->findRange(node), severity);
 }
 
 void ContextBuilder::reportError(const QString& errorMsg, QList< AstNode* > nodes, IProblem::Severity severity)
 {
     RangeInRevision range = RangeInRevision::invalid();
     foreach ( AstNode* node, nodes ) {
         if ( !range.isValid() ) {
             range = m_editor->findRange(node);
         } else {
             range.end = m_editor->findPosition(node->endToken);
         }
     }
     reportError(errorMsg, range, severity);
 }
 
 void ContextBuilder::reportError(const QString& errorMsg, RangeInRevision range, IProblem::Severity severity)
 {
     Problem *p = new Problem();
     p->setSeverity(severity);
     p->setSource(IProblem::DUChainBuilder);
     p->setDescription(errorMsg);
     p->setFinalLocation(DocumentRange(m_editor->parseSession()->currentDocument(),
                                                 range.castToSimpleRange()));
     {
         DUChainWriteLocker lock(DUChain::lock());
         qCDebug(DUCHAIN) << "Problem" << p->description() << p->finalLocation();
         currentContext()->topContext()->addProblem(ProblemPointer(p));
     }
 }
 
 DeclarationPointer ContextBuilder::findDeclarationImport(DeclarationType declarationType,
                                                          IdentifierAst* node)
 {
     QualifiedIdentifier id;
     if ( declarationType == ClassDeclarationType || declarationType == FunctionDeclarationType ) {
         id = identifierPairForNode(node).second;
     } else {
         id = identifierForNode(node);
     }
     return findDeclarationImportHelper(currentContext(), id, declarationType);
 }
 
 DeclarationPointer ContextBuilder::findDeclarationImport(DeclarationType declarationType,
                                                          VariableIdentifierAst* node)
 {
     return findDeclarationImportHelper(currentContext(), identifierForNode(node), declarationType);
 }
 
 DeclarationPointer ContextBuilder::findDeclarationImport(DeclarationType declarationType,
                                                          const QualifiedIdentifier &identifier)
 {
     return findDeclarationImportHelper(currentContext(), identifier, declarationType);
 }
 
 }
diff --git a/duchain/navigation/magicconstantnavigationcontext.cpp b/duchain/navigation/magicconstantnavigationcontext.cpp
index 4489e26..303e28c 100644
--- a/duchain/navigation/magicconstantnavigationcontext.cpp
+++ b/duchain/navigation/magicconstantnavigationcontext.cpp
@@ -1,124 +1,125 @@
 /*
    Copyright 2009 Milian Wolff <mail@milianw.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 "magicconstantnavigationcontext.h"
 
 #include <QtGui/QTextDocument>
 #include <KLocalizedString>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/functiontype.h>
+#include <serialization/indexedstring.h>
 
 using namespace KDevelop;
 
 namespace Php {
 
 MagicConstantNavigationContext::MagicConstantNavigationContext(TopDUContextPointer topContext,
                                                                 const KTextEditor::Cursor& position,
                                                                 const QString& constant)
     : AbstractNavigationContext(topContext, nullptr), m_position(position.line(), position.column()), m_constant(constant)
 {
 }
 
 
 QString MagicConstantNavigationContext::name() const
 {
     return m_constant;
 }
 
 DUContext* findContext(TopDUContextPointer topCtx, const CursorInRevision& pos, DUContext::ContextType type) {
     DUContext* ctx = topCtx->findContextAt(pos);
     while ( ctx && ctx->type() != type ) {
         ctx = ctx->parentContext();
     }
     if ( !ctx || ctx->type() != type ) {
         return nullptr;
     } else {
         return ctx;
     }
 }
 
 QString MagicConstantNavigationContext::html(bool /*shorten*/)
 {
     QString html = QStringLiteral("<html><body><p><small><small>");
     html += typeHighlight(i18n("magic constant"));
     html += ' ';
     html += nameHighlight(m_constant.toHtmlEscaped());
     html += QLatin1String("<br/>\n");
 
     QString value;
     ///TODO: php 5.3: __DIR__, __NAMESPACE__
     if ( m_constant == QLatin1String("__FILE__") ) {
         value = topContext()->url().str().toHtmlEscaped();
     } else if ( m_constant == QLatin1String("__LINE__") ) {
         value.setNum(m_position.line + 1);
     } else if ( m_constant == QLatin1String("__CLASS__") ) {
         if ( DUContext* ctx = findContext(topContext(), m_position, DUContext::Class) ) {
             value = codeHighlight(ctx->localScopeIdentifier().toString().toHtmlEscaped());
         } else {
             value = commentHighlight(i18n("empty (not inside a class)"));
         }
     } else if ( m_constant == QLatin1String("__METHOD__") ) {
         CursorInRevision pos = m_position;
         while ( DUContext* ctx = findContext(topContext(), pos, DUContext::Other) ) {
             if ( !ctx->parentContext() ) {
                 break;
             }
             if ( ctx->parentContext()->type() == DUContext::Class ) {
                 value = codeHighlight(QString(
                             ctx->parentContext()->localScopeIdentifier().toString() + "::"
                             + ctx->localScopeIdentifier().toString()
                         ).toHtmlEscaped());
                 break;
             }
             // might be a "normal" function inside a method...
             pos = ctx->range().start;
         }
         if ( value.isEmpty() ) {
             value = commentHighlight(i18n("empty (not inside a method)"));
         }
     } else if ( m_constant == QLatin1String("__FUNCTION__") ) {
         CursorInRevision pos = m_position;
         if ( DUContext* ctx = findContext(topContext(), pos, DUContext::Other) ) {
             if ( ctx->owner() && ctx->owner()->type<FunctionType>() ) {
                 value = codeHighlight(ctx->localScopeIdentifier().toString().toHtmlEscaped());
             }
         }
         if ( value.isEmpty() ) {
             value = commentHighlight(i18n("empty (not inside a function)"));
         }
     } else if ( m_constant == QLatin1String("__NAMESPACE__") ) {
         if ( DUContext* ctx = findContext(topContext(), m_position, DUContext::Namespace) ) {
             if ( ctx->owner() && ctx->owner()->kind() == Declaration::Namespace ) {
                 value = codeHighlight(ctx->localScopeIdentifier().toString().toHtmlEscaped());
             }
         }
         if ( value.isEmpty() ) {
             value = commentHighlight(i18n("empty (not inside a namespace)"));
         }
     }
 
     html += i18n("current value: %1", value);
 
     html += QLatin1String("</small></small></p></body></html>");
 
     return html;
 }
 
 
 }
diff --git a/duchain/tests/duchain.cpp b/duchain/tests/duchain.cpp
index e3b0194..d2e8fe6 100644
--- a/duchain/tests/duchain.cpp
+++ b/duchain/tests/duchain.cpp
@@ -1,3023 +1,3024 @@
 /* This file is part of KDevelop
     Copyright 2008 Niko Sams <niko.sams@gmail.com>
 
    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 "duchain.h"
 
 #include <QtTest/QtTest>
 
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/unsuretype.h>
 #include <language/duchain/namespacealiasdeclaration.h>
+#include <language/editor/documentrange.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 
 #include "helper.h"
 
 #include "../declarations/classdeclaration.h"
 #include "../declarations/classmethoddeclaration.h"
 #include "../declarations/functiondeclaration.h"
 #include "../declarations/variabledeclaration.h"
 
 #include "../types/structuretype.h"
 #include "../types/integraltypeextended.h"
 
 #include <QStandardPaths>
 
 using namespace KDevelop;
 using namespace Php;
 
 QTEST_MAIN(Php::TestDUChain)
 
 TestDUChain::TestDUChain()
 {
 }
 
 void TestDUChain::declareFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo() {}");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->localDeclarations().count(), 1);
 
     Declaration* dec = top->localDeclarations().at(0);
     QVERIFY(dec);
     QCOMPARE(dec->context(), top);
     QCOMPARE(dec->internalContext(), top->childContexts().at(1));
 
     // no return means void as return type
     FunctionType::Ptr ftype = FunctionType::Ptr::dynamicCast(dec->abstractType());
     QVERIFY(ftype);
     IntegralType::Ptr itype = IntegralType::Ptr::dynamicCast(ftype->returnType());
     QVERIFY(itype->dataType() == IntegralType::TypeVoid);
 
 
     QCOMPARE(top->childContexts().at(0)->type(), DUContext::Function);
     QCOMPARE(top->childContexts().at(1)->type(), DUContext::Other);
 }
 
 void TestDUChain::declareVar()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} class B {} $i = new A(); $j = new B(); $i = new B(); $i = 'foo';"
                         " $a = substr($i, 0, 1);");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->localDeclarations().count(), 5);
 
     //class A
     Declaration* dec = top->localDeclarations().at(0);
     QCOMPARE(dec->uses().count(), 1);
     QCOMPARE(dec->uses().begin()->count(), 1);
 
     //$i
     Declaration* decVar = top->localDeclarations().at(2);
     QCOMPARE(decVar->identifier(), Identifier("i"));
     qDebug() << decVar->abstractType()->toString();
     UnsureType::Ptr unsureType = decVar->type<UnsureType>();
     QVERIFY(unsureType);
     QCOMPARE(unsureType->typesSize(), 3u);
     // = new A();
     QCOMPARE(unsureType->types()[0].abstractType().cast<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QVERIFY(unsureType->types()[0].abstractType()->equals(dec->abstractType().data()));
     // = new B();
     //class B
     dec = top->localDeclarations().at(1);
     QCOMPARE(dec->uses().count(), 1);
     QCOMPARE(dec->uses().begin()->count(), 2);
     QCOMPARE(unsureType->types()[1].abstractType().cast<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(unsureType->types()[1].abstractType()->equals(dec->abstractType().data()));
     // = 'foo';
     QVERIFY(unsureType->types()[2].abstractType().cast<IntegralType>());
     QVERIFY(unsureType->types()[2].abstractType().cast<IntegralType>()->dataType() == IntegralType::TypeString);
 
     //$j
     decVar = top->localDeclarations().at(3);
     QCOMPARE(decVar->identifier(), Identifier("j"));
     StructureType::Ptr classType = decVar->type<StructureType>();
     QVERIFY(classType);
     QCOMPARE(classType->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(classType->equals(dec->abstractType().data()));
 
     // $a
     decVar = top->localDeclarations().at(4);
     QCOMPARE(decVar->identifier(), Identifier("a"));
     QVERIFY(decVar->type<IntegralType>());
 }
 
 void TestDUChain::varTypehint()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} /** @var A **/ $i = foo();");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     //class A
     Declaration* dec = top->localDeclarations().at(0);
 
     //$i
     Declaration* decVar = top->localDeclarations().at(1);
     QCOMPARE(decVar->identifier(), Identifier("i"));
     StructureType::Ptr classType = decVar->type<StructureType>();
     QVERIFY(classType);
     QCOMPARE(classType->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QVERIFY(classType->equals(dec->abstractType().data()));
 }
 
 void TestDUChain::declareClass()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { public function foo($i) {} protected static function bar() {} private function baz() {} function boo() {} }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 1);
 
     DUContext* contextClassA = top->childContexts().first();
 
 
     QCOMPARE(top->localDeclarations().count(), 1);
     Declaration* dec = top->localDeclarations().first();
     QCOMPARE(dec->kind(), Declaration::Type);
     QCOMPARE(dec->toString(), QString("class A"));
     QCOMPARE(dec->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(dec->isDefinition(), true);
     QCOMPARE(dec->logicalInternalContext(top), contextClassA);
 
     qDebug() << contextClassA->localScopeIdentifier().toString();
     QCOMPARE(contextClassA->localScopeIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(contextClassA->childContexts().count(), 8);
     QCOMPARE(contextClassA->childContexts().first()->localScopeIdentifier(), QualifiedIdentifier("foo"));
 
     DUContext* contextMethodBodyFoo = contextClassA->childContexts().at(1);
     QCOMPARE(contextMethodBodyFoo->localScopeIdentifier(), QualifiedIdentifier("foo"));
     QCOMPARE(contextMethodBodyFoo->importedParentContexts().count(), 1);
     QCOMPARE(contextMethodBodyFoo->childContexts().count(), 0);
     QVERIFY(contextMethodBodyFoo->importedParentContexts().first().context(top) ==
             contextClassA->childContexts().first());
 
     //foo()
     dec = contextClassA->localDeclarations().at(0);
     ClassFunctionDeclaration* funDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(funDec);
     QCOMPARE(funDec->kind(), Declaration::Type);
     QCOMPARE(funDec->identifier(), Identifier("foo"));
     QCOMPARE(funDec->accessPolicy(), Declaration::Public);
     QCOMPARE(funDec->isStatic(), false);
 
     {
         // no return means void as return type
         FunctionType::Ptr ftype = FunctionType::Ptr::dynamicCast(dec->abstractType());
         QVERIFY(ftype);
         IntegralType::Ptr itype = IntegralType::Ptr::dynamicCast(ftype->returnType());
         QVERIFY(itype->dataType() == IntegralType::TypeVoid);
     }
 
     //bar()
     dec = contextClassA->localDeclarations().at(1);
     funDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(funDec);
     QCOMPARE(funDec->identifier(), Identifier("bar"));
     QCOMPARE(funDec->accessPolicy(), Declaration::Protected);
     QCOMPARE(funDec->isStatic(), true);
 
     //baz()
     dec = contextClassA->localDeclarations().at(2);
     funDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(funDec);
     QCOMPARE(funDec->identifier(), Identifier("baz"));
     QCOMPARE(funDec->accessPolicy(), Declaration::Private);
     QCOMPARE(funDec->isStatic(), false);
 
     //boo()
     dec = contextClassA->localDeclarations().at(3);
     funDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(funDec);
     QCOMPARE(funDec->identifier(), Identifier("boo"));
     QCOMPARE(funDec->accessPolicy(), Declaration::Public);
 }
 
 void TestDUChain::classMemberVar()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { public $foo; /** @var A **/ protected $bar; private static $baz = ''; var $boo = 1; }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 1);
 
     DUContext* contextClassA = top->childContexts().first();
 
     QCOMPARE(top->localDeclarations().count(), 1);
     Declaration* dec = top->localDeclarations().first();
     QCOMPARE(dec->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(dec->isDefinition(), true);
     QCOMPARE(dec->logicalInternalContext(top), contextClassA);
 
     QCOMPARE(contextClassA->localScopeIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(contextClassA->childContexts().count(), 0);
     QCOMPARE(contextClassA->localDeclarations().count(), 4);
 
     //$foo
     ClassMemberDeclaration* var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().first());
     QVERIFY(var);
     QCOMPARE(var->identifier(), Identifier("foo"));
     QCOMPARE(var->accessPolicy(), Declaration::Public);
     QCOMPARE(var->isStatic(), false);
     QVERIFY(var->type<IntegralType>());
     QVERIFY(var->type<IntegralType>()->dataType() == IntegralType::TypeMixed);
 
     //$bar
     var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().at(1));
     QVERIFY(var);
     QCOMPARE(var->identifier(), Identifier("bar"));
     QCOMPARE(var->accessPolicy(), Declaration::Protected);
     QCOMPARE(var->isStatic(), false);
     StructureType::Ptr type = var->type<StructureType>();
     QVERIFY(type);
     QCOMPARE(type->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     //$baz
     var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().at(2));
     QVERIFY(var);
     QCOMPARE(var->identifier(), Identifier("baz"));
     QCOMPARE(var->accessPolicy(), Declaration::Private);
     QCOMPARE(var->isStatic(), true);
     QVERIFY(var->type<IntegralType>());
     QVERIFY(var->type<IntegralType>()->dataType() == IntegralType::TypeString);
 
     //$boo
     var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().at(3));
     QVERIFY(var);
     QCOMPARE(var->identifier(), Identifier("boo"));
     QCOMPARE(var->accessPolicy(), Declaration::Public);
     QCOMPARE(var->isStatic(), false);
     QVERIFY(var->type<IntegralType>());
     QVERIFY(var->type<IntegralType>()->dataType() == IntegralType::TypeInt);
 }
 
 void TestDUChain::returnTypeClass()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} function foo() { return new A(); } function bar() { $i = new A(); return $i; }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 5);
     QCOMPARE(top->localDeclarations().count(), 3);
 
     Declaration* dec = top->localDeclarations().at(1);
     QCOMPARE(dec->qualifiedIdentifier(), QualifiedIdentifier("foo"));
     FunctionType::Ptr functionType = dec->type<FunctionType>();
     QVERIFY(functionType);
     StructureType::Ptr retType = StructureType::Ptr::dynamicCast(functionType->returnType());
     QVERIFY(retType);
     QCOMPARE(retType->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     dec = top->localDeclarations().at(2);
     QCOMPARE(dec->qualifiedIdentifier(), QualifiedIdentifier("bar"));
     functionType = dec->type<FunctionType>();
     QVERIFY(functionType);
     retType = StructureType::Ptr::dynamicCast(functionType->returnType());
     QVERIFY(retType);
     QCOMPARE(retType->qualifiedIdentifier(), QualifiedIdentifier("a"));
 }
 
 void TestDUChain::declarationReturnType()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} function foo() { return new A(); } $i = foo(); ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 3);
     QCOMPARE(top->localDeclarations().count(), 3);
 
     Declaration* dec = top->localDeclarations().at(1);
     FunctionType::Ptr fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     dec = top->localDeclarations().at(2);
     QCOMPARE(dec->identifier(), Identifier("i"));
     StructureType::Ptr type = dec->type<StructureType>();
     QVERIFY(type);
     QCOMPARE(type->qualifiedIdentifier(), QualifiedIdentifier("a"));
 }
 
 void TestDUChain::declarationReturnTypeInRecursingFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} /** @return A **/ function foo() { $i = foo(); } ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList< Declaration* > decs = top->childContexts().last()->findDeclarations(Identifier(QStringLiteral("i")));
     QCOMPARE(decs.size(), 1);
     Declaration* dec = decs.first();
     StructureType::Ptr type = dec->type<StructureType>();
     QVERIFY(type);
     QCOMPARE(type->qualifiedIdentifier(), QualifiedIdentifier("a"));
 }
 
 void TestDUChain::declarationMultipleReturnTypes()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} function foo() { return null; return new A(); return null; }\n"
                       "function bar() { return 1; return 2; }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fType = top->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fType);
     qDebug() << fType->toString();
     TypePtr<UnsureType> ut = UnsureType::Ptr::dynamicCast(fType->returnType());
     QVERIFY(ut);
     QCOMPARE(2u, ut->typesSize());
 
     ///TODO: why are the types not in the correct order, i.e. null, A
     QVERIFY(ut->types()[0].type<StructureType>());
     QVERIFY(ut->types()[0].type<StructureType>()->declaration(top));
     QCOMPARE(ut->types()[0].type<StructureType>()->declaration(top)->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     QVERIFY(ut->types()[1].type<IntegralType>());
     QVERIFY(ut->types()[1].type<IntegralType>()->dataType() == IntegralType::TypeNull);
 
     fType = top->localDeclarations().at(2)->type<FunctionType>();
     QVERIFY(fType);
     qDebug() << fType->toString();
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType())->dataType() == IntegralType::TypeInt);
 }
 
 void TestDUChain::returnTypeViaMember()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class a { /** @return a **/ function fa() {} }\n"
                       "class b { /** @var a **/ static $astatic; /** @var a **/ var $anormal;\n"
                       "  function fb1($param) { $i = self::$astatic->fa($param); }\n"
                       "  function fb2($param) { $i = $this->anormal->fa($param); } }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVector<Declaration*> decs = top->localDeclarations();
     QCOMPARE(decs.size(), 2);
 
     ClassDeclaration* aDec = dynamic_cast<ClassDeclaration*>(decs.first());
     QVERIFY(aDec);
 
     ClassDeclaration* bDec = dynamic_cast<ClassDeclaration*>(decs.last());
     QVERIFY(bDec);
     QCOMPARE(bDec->logicalInternalContext(top)->localDeclarations().size(), 4);
 
     typedef QPair<QString, QString> idPair;
     foreach ( const idPair & pair, QList< idPair >()
                                         << qMakePair(QString("fb1"), QString("astatic"))
                                         << qMakePair(QString("fb2"), QString("anormal")) )
     {
         qDebug() << pair.first << pair.second;
         ClassMethodDeclaration* fDec = dynamic_cast<ClassMethodDeclaration*>(
             bDec->logicalInternalContext(top)->findDeclarations(Identifier(pair.first)).first()
         );
         QVERIFY(fDec);
 
         ClassMemberDeclaration* mDec = dynamic_cast<ClassMemberDeclaration*>(
             bDec->logicalInternalContext(top)->findDeclarations(Identifier(pair.second)).first()
         );
         QVERIFY(mDec);
         QVERIFY(mDec->type<StructureType>());
         QCOMPARE(mDec->type<StructureType>()->declaration(top), aDec);
 
         QCOMPARE(fDec->logicalInternalContext(top)->localDeclarations().size(), 1);
         Declaration* iDec = fDec->logicalInternalContext(top)->localDeclarations().first();
         QCOMPARE(iDec->identifier().toString(), QString("i"));
         QVERIFY(iDec->type<StructureType>());
         QCOMPARE(iDec->type<StructureType>()->declaration(top), aDec);
     }
 }
 
 void TestDUChain::declarationReturnTypeDocBlock()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { /** @return A **/ function bar() {} } "
                       "   class B {} "
                       "/** @return A **/ function foo() { return new B(); } "
                       "/** @return object **/ function bar() {}");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     //function bar
     Declaration* dec = top->childContexts().at(0)->localDeclarations().at(0);
     FunctionType::Ptr fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     //function foo
     dec = top->localDeclarations().at(2);
     fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     //function bar
     dec = top->localDeclarations().at(3);
     fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("stdclass"));
 
     //test hint in internal functions file of a type that is added later on
     // function
     QList<Declaration*> decs = top->findDeclarations(Identifier(QStringLiteral("should_return_exception")));
     QCOMPARE(decs.size(), 1);
     dec = decs.first();
     fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("exception"));
     // method
     decs = top->findDeclarations(Identifier(QStringLiteral("internal_test_class")));
     QCOMPARE(decs.size(), 1);
     ClassDeclaration* cdec = dynamic_cast<ClassDeclaration*>(decs.first());
     QVERIFY(cdec);
     decs = cdec->logicalInternalContext(top)->findDeclarations(Identifier(QStringLiteral("should_return_exception")));
     QCOMPARE(decs.size(), 1);
     dec = decs.first();
     fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("exception"));
 }
 
 void TestDUChain::declarationReturnTypeDocBlockIntegral()
 {
     QByteArray method("<? /** @return string **/ function foo() {} /** @return mixed **/ function bar() {} class A { /** @return int **/ function aaa() {} }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     //function foo
     FunctionType::Ptr fType = top->localDeclarations().at(0)->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType())->dataType() == IntegralType::TypeString);
 
     //function bar
     fType = top->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType())->dataType() == IntegralType::TypeMixed);
 
     //function aaa
     fType = top->childContexts().at(4)->localDeclarations().first()->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType())->dataType() == IntegralType::TypeInt);
 }
 
 void TestDUChain::declarationReturnTypeClassChain()
 {
     QByteArray method("<? class A { /** @return this **/ function a() {} /** @return self **/ function b() {} }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     // class a
     DUContext* ctx = top->childContexts().first();
     QCOMPARE(ctx->type(), DUContext::Class);
     QVERIFY(ctx->owner());
     QVERIFY(StructureType::Ptr::dynamicCast(ctx->owner()->abstractType()));
 
     //function a
     // FIXME
     QEXPECT_FAIL("", "This test fails after porting the plugin to KF5.", Abort);
     QVERIFY(/* func a (this) */ ctx->localDeclarations().at(0)->type<FunctionType>().data() == ctx->owner()->abstractType().data());
     QVERIFY(/* func b (self) */ ctx->localDeclarations().at(1)->type<FunctionType>().data() == ctx->owner()->abstractType().data());
 }
 
 void TestDUChain::declareTypehintFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} function foo(A $i) { return $i; } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 3);
     QCOMPARE(top->localDeclarations().count(), 2);
 
     Declaration* dec = top->localDeclarations().at(0);
     QCOMPARE(dec->internalContext(), top->childContexts().at(0));
     QCOMPARE(dec->uses().count(), 1);
     QCOMPARE(dec->uses().begin()->count(), 1);
 
     QCOMPARE(top->childContexts().at(0)->localScopeIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(top->childContexts().at(0)->childContexts().count(), 0);
 
     DUContext* contextFunctionFoo = top->childContexts().at(1);
     QCOMPARE(contextFunctionFoo->localScopeIdentifier(), QualifiedIdentifier("foo"));
 
     DUContext* contextFunctionBodyFoo = top->childContexts().at(2);
     QCOMPARE(contextFunctionBodyFoo->localScopeIdentifier(), QualifiedIdentifier("foo"));
     QCOMPARE(contextFunctionBodyFoo->importedParentContexts().count(), 1);
     QCOMPARE(contextFunctionBodyFoo->childContexts().count(), 0);
 
     QVERIFY(contextFunctionBodyFoo->importedParentContexts().first().context(top) ==
             contextFunctionFoo);
 
     QVERIFY(top->childContexts().at(1)->localDeclarations().first()->type<StructureType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().first()->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     FunctionType::Ptr fType = top->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(StructureType::Ptr::dynamicCast(fType->returnType()));
     QCOMPARE(StructureType::Ptr::dynamicCast(fType->returnType())->qualifiedIdentifier(), QualifiedIdentifier("a"));
 }
 
 void TestDUChain::declareTypehintArrayFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo(array $i) { } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fun = top->localDeclarations().first()->type<FunctionType>();
     QVERIFY(fun);
     QCOMPARE(fun->arguments().count(), 1);
     QVERIFY(IntegralType::Ptr::dynamicCast(fun->arguments().first()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fun->arguments().first())->dataType() == IntegralType::TypeArray);
 
     IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
     QVERIFY(type);
     QVERIFY(type->dataType() == IntegralType::TypeArray);
 }
 
 void TestDUChain::declareTypehintCallableFunction()
 {
     //                 0         1         2         3
     //                 0123456789012345678901234567890123
     QByteArray method("<? function foo(callable $i) { } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fun = top->localDeclarations().first()->type<FunctionType>();
     QVERIFY(fun);
     QCOMPARE(fun->arguments().count(), 1);
     QVERIFY(IntegralType::Ptr::dynamicCast(fun->arguments().first()));
     QVERIFY(IntegralType::Ptr::dynamicCast(fun->arguments().first())->dataType() == IntegralType::TypeMixed);
 
     IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
     QVERIFY(type);
     QVERIFY(type->dataType() == IntegralType::TypeMixed);
 }
 
 void TestDUChain::classImplementsInterface()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? interface I { } class A implements I { }");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->localDeclarations().count(), 2);
 
     //interface I
     Declaration* dec = top->localDeclarations().at(0);
     QVERIFY(dec->isDefinition());
     QCOMPARE(dec->identifier(), Identifier("i"));
     QCOMPARE(dec->toString(), QString("interface I"));
     StructureType::Ptr typeI = dec->type<StructureType>();
     QCOMPARE(typeI->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QVERIFY(typeI->declaration(top) == dec);
     ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(dec);
     QVERIFY(classDec);
     QCOMPARE(classDec->classType(), ClassDeclarationData::Interface);
 
     QCOMPARE(dec->internalContext(), top->childContexts().at(0));
     QCOMPARE(dec->internalContext()->childContexts().count(), 0);
     QCOMPARE(dec->internalContext()->importedParentContexts().count(), 0);
     QCOMPARE(dec->internalContext()->localScopeIdentifier(), QualifiedIdentifier("i"));
 
     QCOMPARE(dec->uses().count(), 1);
     QCOMPARE(dec->uses().begin()->count(), 1);
 
     IndexedType indexedTypeI = classDec->indexedType();
 
     //class A
     dec = top->localDeclarations().at(1);
     QVERIFY(dec->isDefinition());
     QCOMPARE(dec->identifier(), Identifier("a"));
     StructureType::Ptr typeA = dec->type<StructureType>();
     QCOMPARE(typeA->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QVERIFY(typeA->declaration(top) == dec);
     classDec = dynamic_cast<ClassDeclaration*>(dec);
     QVERIFY(classDec);
     QCOMPARE(classDec->classType(), ClassDeclarationData::Class);
 
     QCOMPARE(dec->internalContext(), top->childContexts().at(1));
     QCOMPARE(dec->internalContext()->childContexts().count(), 0);
     QCOMPARE(dec->internalContext()->localScopeIdentifier(), QualifiedIdentifier("a"));
     //class A imports interface I context
     QCOMPARE(dec->internalContext()->importedParentContexts().count(), 1);
     QVERIFY(dec->internalContext()->importedParentContexts().at(0).context(top) == top->childContexts().at(0));
 
     QCOMPARE(classDec->baseClassesSize(), 1u);
     QCOMPARE(classDec->baseClasses()[0].baseClass, indexedTypeI);
 
     QCOMPARE(dec->uses().count(), 0);
 }
 
 void TestDUChain::classExtends()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { } class B extends A { } ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->localDeclarations().count(), 2);
 
     //class A
     Declaration* dec = top->localDeclarations().at(0);
     QVERIFY(dec->isDefinition());
     QCOMPARE(dec->identifier(), Identifier("a"));
     StructureType::Ptr typeA = dec->type<StructureType>();
     QCOMPARE(typeA->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QVERIFY(typeA->declaration(top) == dec);
     ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(dec);
     QVERIFY(classDec);
     QCOMPARE(classDec->classType(), ClassDeclarationData::Class);
 
     QCOMPARE(dec->internalContext(), top->childContexts().at(0));
     QCOMPARE(dec->internalContext()->childContexts().count(), 0);
     QCOMPARE(dec->internalContext()->importedParentContexts().count(), 0);
     QCOMPARE(dec->internalContext()->localScopeIdentifier(), QualifiedIdentifier("a"));
 
     QCOMPARE(dec->uses().count(), 1);
     QCOMPARE(dec->uses().begin()->count(), 1);
 
     IndexedType indexedTypeA = classDec->indexedType();
 
     //class B
     dec = top->localDeclarations().at(1);
     QVERIFY(dec->isDefinition());
     QCOMPARE(dec->identifier(), Identifier("b"));
     StructureType::Ptr typeB = dec->type<StructureType>();
     QCOMPARE(typeB->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(typeB->declaration(top) == dec);
     classDec = dynamic_cast<ClassDeclaration*>(dec);
     QVERIFY(classDec);
     QCOMPARE(classDec->classType(), ClassDeclarationData::Class);
 
     QCOMPARE(dec->internalContext(), top->childContexts().at(1));
     QCOMPARE(dec->internalContext()->childContexts().count(), 0);
     QCOMPARE(dec->internalContext()->localScopeIdentifier(), QualifiedIdentifier("b"));
     //class B imports class A context
     QCOMPARE(dec->internalContext()->importedParentContexts().count(), 1);
     QVERIFY(dec->internalContext()->importedParentContexts().at(0).context(top) == top->childContexts().at(0));
 
     QCOMPARE(classDec->baseClassesSize(), 1u);
     QCOMPARE(classDec->baseClasses()[0].baseClass, indexedTypeA);
 
     QCOMPARE(dec->uses().count(), 0);
 }
 
 
 void TestDUChain::staticMethod()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { static function foo() { return new B(); } } $i = A::foo();");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     StructureType::Ptr type = top->localDeclarations().at(2)->type<StructureType>();
     QVERIFY(type);
     QCOMPARE(type->qualifiedIdentifier(), QualifiedIdentifier("b"));
 }
 
 void TestDUChain::ownStaticMethod()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { static function foo() { return new B(); } function bar() { $i = self::foo(); $j = A::foo(); } } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->childContexts().at(1));
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(0));
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(0)->type<FunctionType>());
     AbstractType::Ptr ret = top->childContexts().at(1)->localDeclarations().at(0)
                             ->type<FunctionType>()->returnType();
 
     QVERIFY(StructureType::Ptr::dynamicCast(ret));
     QCOMPARE(StructureType::Ptr::dynamicCast(ret)->declaration(top), top->localDeclarations().at(0));
 
     QVERIFY(top->childContexts().at(1)->childContexts().at(1 + 2));
     QVERIFY(top->childContexts().at(1)->childContexts().at(1 + 2)->localDeclarations().at(0));
     QVERIFY(top->childContexts().at(1)->childContexts().at(1 + 2)->localDeclarations().at(0)->type<StructureType>());
     QCOMPARE(top->childContexts().at(1)->childContexts().at(1 + 2)->localDeclarations().at(0)
              ->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QCOMPARE(top->childContexts().at(1)->childContexts().at(1 + 2)->localDeclarations().at(1)
              ->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
 }
 void TestDUChain::thisVar()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { function x() { return $this; } function y() { return $this->x(); } } ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fn = top->childContexts().at(0)->localDeclarations().at(0)->type<FunctionType>();
     QVERIFY(fn);
     StructureType::Ptr cls = StructureType::Ptr::dynamicCast(fn->returnType());
     QVERIFY(cls);
     QCOMPARE(cls->qualifiedIdentifier(), QualifiedIdentifier("a"));
 
     fn = top->childContexts().at(0)->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fn);
     cls = StructureType::Ptr::dynamicCast(fn->returnType());
     QVERIFY(cls);
     QCOMPARE(cls->qualifiedIdentifier(), QualifiedIdentifier("a"));
 }
 
 void TestDUChain::objectFunctionCall()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { function x() { return new B(); } function y() { $a = new A(); return $a->x(); } } ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fn = top->childContexts().at(1)->localDeclarations().at(0)->type<FunctionType>();
     QVERIFY(fn);
     StructureType::Ptr cls = StructureType::Ptr::dynamicCast(fn->returnType());
     QVERIFY(cls);
     QCOMPARE(cls->qualifiedIdentifier(), QualifiedIdentifier("b"));
 
     fn = top->childContexts().at(1)->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fn);
     cls = StructureType::Ptr::dynamicCast(fn->returnType());
     QVERIFY(cls);
     QCOMPARE(cls->qualifiedIdentifier(), QualifiedIdentifier("b"));
 }
 
 void TestDUChain::objectFunctionCall2()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class C {} class B { function c() { return new C(); } } class A { function x() { return new B(); } function y() { $a = new A(); return $a->x()->c(); } } ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fn = top->childContexts().at(2)->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fn);
     StructureType::Ptr cls = StructureType::Ptr::dynamicCast(fn->returnType());
     QVERIFY(cls);
     QCOMPARE(cls->qualifiedIdentifier(), QualifiedIdentifier("c"));
 }
 
 void TestDUChain::objectFunctionCall3()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { function b() { return new B(); } } $i = new A(); $j = $i->b();");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().at(2)->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QCOMPARE(top->localDeclarations().at(2)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("a"));;
     QCOMPARE(top->localDeclarations().at(3)->qualifiedIdentifier(), QualifiedIdentifier("j"));
     QCOMPARE(top->localDeclarations().at(3)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));;
 }
 
 void TestDUChain::objectVariable()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { /** @var B **/ public $foo; } $a = new A(); $i = $a->foo;");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().at(3)->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QCOMPARE(top->localDeclarations().at(3)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));;
 }
 
 void TestDUChain::staticMemberVariable()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { /** @var B **/ public static $foo; } $i = A::$foo;");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().at(2)->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QCOMPARE(top->localDeclarations().at(2)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));;
 }
 void TestDUChain::ownStaticMemberVariable()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class B {} class A { /** @var B **/ public static $foo; function bar() { $i = self::$foo; $j = A::$foo; }} ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     DUContext* barContext = top->childContexts().at(1)->childContexts().at(1);
     QCOMPARE(barContext->localDeclarations().at(0)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QCOMPARE(barContext->localDeclarations().at(1)->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
 }
 
 void TestDUChain::classConst_data()
 {
     QTest::addColumn<QString>("classBody");
     QTest::addColumn<int>("problems");
 
     QTest::newRow("int") << "const C = 1;" << 0;
     QTest::newRow("string") << "const C = 'asdf';" << 0;
     QTest::newRow("float") << "const C = 0.5;" << 0;
     QTest::newRow("bool") << "const C = true;" << 0;
     QTest::newRow("selfConst") << "const C2 = 1; const C = self::C2;" << 0;
     QTest::newRow("parentConst") << "const C = parent::P;" << 0;
     QTest::newRow("null") << "const C = null;" << 0;
 
     QTest::newRow("array") << "const C = array();" << 1;
 }
 
 void TestDUChain::classConst()
 {
     QFETCH(QString, classBody);
     QFETCH(int, problems);
 
     QString fullClass("<? class B { const P = 1; } class A extends B { " + classBody + " } ");
 
     TopDUContext* top = parse(fullClass.toUtf8(), DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->problems().count(), problems);
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("a::C")).count(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("a::C")).first()->context(), top->childContexts().last());
 }
 
 void TestDUChain::fileConst_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("problems");
     QTest::addColumn<uint>("dataType");
 
     QTest::newRow("int") << "const C = 1;" << 0 << (uint) IntegralType::TypeInt;
     QTest::newRow("string") << "const C = 'asdf';" << 0 << (uint) IntegralType::TypeString;
     QTest::newRow("float") << "const C = 0.5;" << 0 << (uint) IntegralType::TypeFloat;
     QTest::newRow("bool") << "const C = true;" << 0 << (uint) IntegralType::TypeBoolean;
 
     QTest::newRow("array") << "const C = array();" << 1 << (uint) IntegralType::TypeArray;
 }
 
 void TestDUChain::fileConst()
 {
     QFETCH(QString, code);
     QFETCH(int, problems);
     QFETCH(uint, dataType);
 
     code.prepend("<?php ");
 
     TopDUContext* top = parse(code.toUtf8(), DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->problems().count(), problems);
 
     QList< Declaration* > decs = top->findDeclarations(QualifiedIdentifier(QStringLiteral("C")));
     QCOMPARE(decs.count(), 1);
     IntegralType::Ptr type = decs.first()->abstractType().cast<IntegralType>();
     QVERIFY(type);
     QCOMPARE(type->dataType(), dataType);
     QVERIFY(type->modifiers() & AbstractType::ConstModifier);
 }
 
 void TestDUChain::define()
 {
     // the last define tests that we don't crash under that circumstance
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? define('FOO', 'foo'); function x() { define('BAR', 'bar'); } define(); ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("FOO")).count(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("BAR")).count(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("FOO")).first()->context(), top);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("BAR")).first()->context(), top);
 
     QVERIFY(top->findDeclarations(QualifiedIdentifier("FOO")).first()->abstractType()->modifiers() & AbstractType::ConstModifier);
     QVERIFY(top->findDeclarations(QualifiedIdentifier("BAR")).first()->abstractType()->modifiers() & AbstractType::ConstModifier);
 }
 void TestDUChain::defaultFunctionParam()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo($a, $b = false, $c = null) {} ");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     AbstractFunctionDeclaration* fun = dynamic_cast<AbstractFunctionDeclaration*>(top->localDeclarations().first());
     QVERIFY(fun);
 
     QCOMPARE(fun->defaultParametersSize(), 2u);
     QCOMPARE(fun->defaultParameters()[0].str(), QString("false"));
     QCOMPARE(fun->defaultParameters()[1].str(), QString("null"));
 }
 
 void TestDUChain::globalFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? substr(); ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->importedParentContexts().count(), 1);
     QVERIFY(DUChain::self()->chainForDocument(internalFunctionFile()));
     QCOMPARE(DUChain::self()->chainForDocument(internalFunctionFile()), top->importedParentContexts().first().context(top));
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("substr")).count(), 1);
 }
 
 void TestDUChain::globalVariableFromInternalFunctions()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? substr(); ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->importedParentContexts().count(), 1);
     QVERIFY(DUChain::self()->chainForDocument(internalFunctionFile()));
     QCOMPARE(DUChain::self()->chainForDocument(internalFunctionFile()), top->importedParentContexts().first().context(top));
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("_GET")).count(), 1);
 }
 
 void TestDUChain::newObjectFromOtherFile()
 {
 
     TopDUContext* addTop = parseAdditionalFile(IndexedString("/duchaintest/foo.php"), "<?php class Foo { } ");
     DUChainReleaser releaseAddTop(addTop);
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $a = new Foo(); ");
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(hasImportedParentContext(top, addTop));
 
     QCOMPARE(top->localDeclarations().first()->type<StructureType>()->declaration(top),
              addTop->localDeclarations().first());
 }
 
 void TestDUChain::unknownReturnType()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo() {} $a = foo();");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     //function bar
     Declaration* dec = top->localDeclarations().at(0);
     FunctionType::Ptr fType = dec->type<FunctionType>();
     QVERIFY(fType);
     QVERIFY(IntegralType::Ptr::dynamicCast(fType->returnType()));
     QVERIFY(IntegralType::Ptr::staticCast(fType->returnType())->dataType() == IntegralType::TypeVoid);
 }
 
 void TestDUChain::staticFunctionCallFromOtherFile()
 {
 
     TopDUContext* addTop = parseAdditionalFile(IndexedString("/duchaintest/foo2.php"), "<?php class Foo { public static function a() {} } ");
     DUChainReleaser releaseAddTop(addTop);
     TopDUContext* top = parse("<? Foo::a(); ", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(hasImportedParentContext(top, addTop));
 }
 
 void TestDUChain::classConstantFromOtherFile()
 {
 
     TopDUContext* addTop = parseAdditionalFile(IndexedString("/duchaintest/foo2.php"), "<?php class Foo { const BAR = 0; } ");
     DUChainReleaser releaseAddTop(addTop);
     TopDUContext* top = parse("<? Foo::BAR; ", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(hasImportedParentContext(top, addTop));
 }
 
 void TestDUChain::globalFunctionCallFromOtherFile()
 {
 
     TopDUContext* addTop = parseAdditionalFile(IndexedString("/duchaintest/foo3.php"), "<?php function a() {} ");
     DUChainReleaser releaseAddTop(addTop);
     TopDUContext* top = parse("<? a(); ", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(hasImportedParentContext(top, addTop));
 }
 
 void TestDUChain::constantFromOtherFile()
 {
 
     TopDUContext* addTop = parseAdditionalFile(IndexedString("/duchaintest/foo3.php"), "<?php define('A', 0); ");
     DUChainReleaser releaseAddTop(addTop);
     TopDUContext* top = parse("<? define('B', 0); A; ", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(hasImportedParentContext(top, addTop));
 }
 
 void TestDUChain::singleton()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { public static function self() { static $i; if(!$i) $i = new self(); return $i; }}");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fun = top->childContexts().first()->localDeclarations().first()->type<FunctionType>();
     QVERIFY(fun);
     StructureType::Ptr ret = StructureType::Ptr::dynamicCast(fun->returnType());
     qDebug() << fun->returnType()->toString();
     QVERIFY(ret);
     QCOMPARE(ret->declaration(top), top->localDeclarations().first());
 }
 
 void TestDUChain::internalFunctions()
 {
     return; //disabled because it is too slow
     QString fileName = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevphpsupport/phpfunctions.php"));
     QFile file(fileName);
     file.open(QIODevice::ReadOnly | QIODevice::Text);
     TopDUContext* top = parse(file.readAll(), DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 }
 
 void TestDUChain::trueFalse()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $a = true; $b = false; ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->localDeclarations().at(0)->type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     QVERIFY(top->localDeclarations().at(1)->type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
 }
 
 void TestDUChain::null()
 {
     QByteArray method("<? $a = null; ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->localDeclarations().at(0)->type<IntegralType>()->dataType() == IntegralType::TypeNull);
 }
 
 void TestDUChain::array()
 {
     QByteArray method("<? $a = array(); $b = array(1, 2, 3); $b[] = 'test';");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->localDeclarations().at(0)->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     QVERIFY(top->localDeclarations().at(1)->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     // $b[] = 'test'; is not a redeclaration of b! Esp. it's type should not change.
     QCOMPARE(top->findDeclarations(Identifier("b")).count(), 1);
 }
 
 void TestDUChain::functionDocBlock()
 {
     {
         TopDUContext* top = parse("<? /**\n *Foo\n **/\nfunction foo() {} ", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo"));
     }
 
     {
         TopDUContext* top = parse("<? /**\n *Bar\n **/\nclass A { /**\n *Foo\n **/\nfunction foo() {} }", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Bar"));
         QCOMPARE(top->childContexts().first()->localDeclarations().first()->comment(), QByteArray("Foo"));
     }
 
     {
         TopDUContext* top = parse("<? /**\n *Foo\n **/\ninterface A { }", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo"));
     }
 
     {
         TopDUContext* top = parse("<? class A { /**\n *Foo\n **/\npublic $foo; }", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->childContexts().first()->localDeclarations().first()->comment(), QByteArray("Foo"));
     }
 
     {
         TopDUContext* top = parse("<? class A { /**\n *Foo\n **/\nconst FOO=0; }", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->childContexts().first()->localDeclarations().first()->comment(), QByteArray("Foo"));
     }
 
     {
         TopDUContext* top = parse("<?\n/// Foo\n/// Bar\nfunction foo() {} ", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo\n Bar"));
     }
 
     {
         // same as above but with indendation
         TopDUContext* top = parse("<?\n  /// Foo\n  /// Bar\n  function foo() {} ", DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo\n Bar"));
     }
 }
 
 void TestDUChain::variableDocBlock()
 {
     {
         TopDUContext* top = parse("<? /**\n *Foo\n **/\n$a = 0; /**\n *Foo\n **/\nstatic $b;", DumpAll);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo"));
         QCOMPARE(top->localDeclarations().at(1)->comment(), QByteArray("Foo"));
     }
     {
         TopDUContext* top = parse("<? /// Foo\n$a = 0; /// Foo\nstatic $b;", DumpAll);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
         QCOMPARE(top->localDeclarations().first()->comment(), QByteArray("Foo"));
         QCOMPARE(top->localDeclarations().at(1)->comment(), QByteArray("Foo"));
     }
 }
 
 void TestDUChain::functionDocBlockParams()
 {
     TopDUContext* top = parse("<? class A {} /**\n * @param\tint\n *\t@param A\n *  @param   mixed **/\nfunction foo($a, $b, $c, $d) {} ", DumpNone);
     {
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
 
         QCOMPARE(top->localDeclarations().at(1)->type<FunctionType>()->arguments().count(), 4);
 
         AbstractType::Ptr arg = top->localDeclarations().at(1)->type<FunctionType>()->arguments().at(0);
         QVERIFY(IntegralType::Ptr::dynamicCast(arg));
         QVERIFY(IntegralType::Ptr::dynamicCast(arg)->dataType() == IntegralType::TypeInt);
         QVERIFY(top->childContexts().at(1)->localDeclarations().at(0)->type<IntegralType>());
         QVERIFY(top->childContexts().at(1)->localDeclarations().at(0)->type<IntegralType>()->dataType() == IntegralType::TypeInt);
 
         arg = top->localDeclarations().at(1)->type<FunctionType>()->arguments().at(1);
         QVERIFY(StructureType::Ptr::dynamicCast(arg));
         QCOMPARE(StructureType::Ptr::dynamicCast(arg)->declaration(top), top->localDeclarations().at(0));
         QCOMPARE(top->childContexts().at(1)->localDeclarations().at(1)->type<StructureType>()->declaration(top), top->localDeclarations().at(0));
 
         arg = top->localDeclarations().at(1)->type<FunctionType>()->arguments().at(2);
         QVERIFY(IntegralType::Ptr::dynamicCast(arg));
         QVERIFY(IntegralType::Ptr::dynamicCast(arg)->dataType() == IntegralType::TypeMixed);
 
         arg = top->localDeclarations().at(1)->type<FunctionType>()->arguments().at(3);
         QVERIFY(IntegralType::Ptr::dynamicCast(arg));
         QVERIFY(IntegralType::Ptr::dynamicCast(arg)->dataType() == IntegralType::TypeMixed);
     }
 }
 
 void TestDUChain::memberFunctionDocBlockParams()
 {
     TopDUContext* top = parse("<? class A { /**\n * @param bool\n * @param A\n * @param array\n **/\nfunction foo($a, $b, $c) {} }", DumpNone);
     {
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
 
         QCOMPARE(top->childContexts().first()->localDeclarations().first()->type<FunctionType>()->arguments().count(), 3);
 
         AbstractType::Ptr arg = top->childContexts().first()->localDeclarations().first()->type<FunctionType>()->arguments().at(0);
         QVERIFY(IntegralType::Ptr::dynamicCast(arg));
         QVERIFY(IntegralType::Ptr::dynamicCast(arg)->dataType() == IntegralType::TypeBoolean);
 
         arg = top->childContexts().first()->localDeclarations().first()->type<FunctionType>()->arguments().at(1);
         QVERIFY(StructureType::Ptr::dynamicCast(arg));
         QCOMPARE(StructureType::Ptr::dynamicCast(arg)->declaration(top), top->localDeclarations().at(0));
 
         arg = top->childContexts().first()->localDeclarations().first()->type<FunctionType>()->arguments().at(2);
         QVERIFY(IntegralType::Ptr::dynamicCast(arg));
         QVERIFY(IntegralType::Ptr::dynamicCast(arg)->dataType() == IntegralType::TypeArray);
     }
 }
 
 void TestDUChain::foreachLoop()
 {
     {
     TopDUContext* top = parse("<? $a = array(1); foreach($a as $k=>$i) { $i; }", DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().count(), 3);
     QCOMPARE(top->localDeclarations().at(1)->qualifiedIdentifier(), QualifiedIdentifier("k"));
     QVERIFY(top->localDeclarations().at(1)->abstractType().cast<IntegralType>());
     QCOMPARE(top->localDeclarations().at(1)->abstractType().cast<IntegralType>()->dataType(), static_cast<uint>(IntegralType::TypeMixed));
     QCOMPARE(top->localDeclarations().at(2)->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QVERIFY(top->localDeclarations().at(2)->abstractType().cast<IntegralType>());
     QCOMPARE(top->localDeclarations().at(2)->abstractType().cast<IntegralType>()->dataType(), static_cast<uint>(IntegralType::TypeMixed));
     }
     {
     // bug: https://bugs.kde.org/show_bug.cgi?id=237110
     TopDUContext* top = parse("<? $a = array(1); foreach($a as $b) { $c = new stdclass; }", DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().count(), 3);
     QCOMPARE(top->localDeclarations().at(1)->qualifiedIdentifier(), QualifiedIdentifier("b"));
     qDebug() << top->localDeclarations().at(1)->toString();
     QVERIFY(top->localDeclarations().at(1)->abstractType().cast<IntegralType>());
     QCOMPARE(top->localDeclarations().at(1)->abstractType().cast<IntegralType>()->dataType(), static_cast<uint>(IntegralType::TypeMixed));
     QCOMPARE(top->localDeclarations().at(2)->qualifiedIdentifier(), QualifiedIdentifier("c"));
     QVERIFY(top->localDeclarations().at(2)->abstractType().cast<StructureType>());
     QCOMPARE(top->localDeclarations().at(2)->abstractType().cast<StructureType>()->qualifiedIdentifier().toString(), QString("stdclass"));
     }
 }
 
 void TestDUChain::php4StyleConstructor()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class Aa { function Aa() { $this->bb(); } } ");
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->childContexts().first()->localDeclarations().at(0);
     QVERIFY(dec);
     QCOMPARE(dec->qualifiedIdentifier(), QualifiedIdentifier("aa::aa"));
     ClassFunctionDeclaration* classFuncDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(classFuncDec);
     QVERIFY(classFuncDec->isConstructor());
 }
 
 void TestDUChain::constructor()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     {
         QByteArray method("<? class foobar { function __construct() {} } ");
         TopDUContext* top = parse(method, DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
 
         Declaration* dec = top->childContexts().first()->localDeclarations().at(0);
         QVERIFY(dec);
         ClassFunctionDeclaration* classFuncDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
         QVERIFY(classFuncDec);
         QVERIFY(!classFuncDec->isDestructor());
         QVERIFY(classFuncDec->isConstructor());
     }
     {
         QByteArray method("<? class foobar { function foobar() {} } ");
         TopDUContext* top = parse(method, DumpNone);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
 
         Declaration* dec = top->childContexts().first()->localDeclarations().at(0);
         QVERIFY(dec);
         ClassFunctionDeclaration* classFuncDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
         QVERIFY(classFuncDec);
         QVERIFY(!classFuncDec->isDestructor());
         QVERIFY(classFuncDec->isConstructor());
     }
 }
 
 void TestDUChain::destructor()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class foobar { function __destruct() {} } ");
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->childContexts().first()->localDeclarations().at(0);
     QVERIFY(dec);
     ClassFunctionDeclaration* classFuncDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(classFuncDec);
     QVERIFY(classFuncDec->isDestructor());
     QVERIFY(!classFuncDec->isConstructor());
 }
 
 void TestDUChain::functionInFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function aaa() { function bbb() { } }");
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().at(0)->qualifiedIdentifier(), QualifiedIdentifier("aaa"));
 }
 
 void TestDUChain::objectWithClassName()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class setupPage {} $setupPage = new setupPage; $setupPage->foo();");
     TopDUContext* top = parse(method, DumpNone, QUrl(QStringLiteral("file:///internal/testObjectWithClassName.php")));
     DUChainReleaser releaseTop(top);
 
     // update top (the pointer will be the same)
     QByteArray method2("<? $setupPage = new setupPage; $setupPage->foo();");
     TopDUContext* top2 = parse(method2, DumpNone, QUrl(QStringLiteral("file:///internal/testObjectWithClassName.php")));
     QVERIFY(top2 == top);
 }
 
 void TestDUChain::largeNumberOfDeclarations()
 {
     TopDUContext* top = new TopDUContext(IndexedString(QUrl(QStringLiteral("file:///internal/testurl"))), RangeInRevision(0, 0, 6000, 0), nullptr);
     DUChain::self()->addDocumentChain(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     for (int i = 0; i < 6000; ++i) {
         RangeInRevision newRange(i, 0, i, 1);
         Declaration* dec = new Declaration(newRange, top);
         dec->setIdentifier(Identifier(QStringLiteral("dec%0").arg(i)));
         dec->setAbstractType(AbstractType::Ptr(nullptr));
     }
 }
 
 void TestDUChain::staticVariable()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? define('AA', 0); function aaa() { static $foo; static $bar=0; static $baz='a'; static $bam=array(); static $woid=+'1'; static $a=AA; }");
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->childContexts().at(1)->localDeclarations().count(), 6);
 
     QCOMPARE(top->childContexts().at(1)->localDeclarations().first()->qualifiedIdentifier(), QualifiedIdentifier("aaa::foo"));
     QVERIFY(top->childContexts().at(1)->localDeclarations().first()->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().first()->type<IntegralType>()->dataType(), (uint)IntegralType::TypeMixed);
 
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(1)->qualifiedIdentifier(), QualifiedIdentifier("aaa::bar"));
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(1)->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(1)->type<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
 
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(2)->qualifiedIdentifier(), QualifiedIdentifier("aaa::baz"));
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(2)->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(2)->type<IntegralType>()->dataType(), (uint)IntegralType::TypeString);
 
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(3)->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(3)->type<IntegralType>()->dataType(), (uint)IntegralType::TypeArray);
 
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(4)->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(4)->type<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
 
     QVERIFY(top->childContexts().at(1)->localDeclarations().at(5)->type<IntegralType>());
     QCOMPARE(top->childContexts().at(1)->localDeclarations().at(5)->type<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
 }
 
 void TestDUChain::returnTypeTwoDeclarations()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo() { $i='a'; $i=0; return $i; } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().at(0);
     FunctionType::Ptr functionType = dec->type<FunctionType>();
     QVERIFY(functionType);
     UnsureType::Ptr retType = UnsureType::Ptr::dynamicCast(functionType->returnType());
     QVERIFY(retType);
     QCOMPARE(retType->typesSize(), 2u);
     QVERIFY(retType->types()[0].abstractType().cast<IntegralType>());
     QCOMPARE(retType->types()[0].abstractType().cast<IntegralType>()->dataType(), (uint)IntegralType::TypeString);
     QVERIFY(retType->types()[1].abstractType().cast<IntegralType>());
     QCOMPARE(retType->types()[1].abstractType().cast<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
 }
 
 void TestDUChain::globalVariableNotVisibleInFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $a = 0; function foo() { $a; }");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("a")).first()->uses().count(), 0);
 }
 
 void TestDUChain::globalVariableInFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $a = 0; function foo() { global $a; $a; }");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("a")).first()->uses().count(), 1);
 }
 
 void TestDUChain::nonGlobalVariableInFunction()
 {
     // bug: https://bugs.kde.org/show_bug.cgi?id=240920
 
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $a = 0; function foo() { $a = 1; }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->findLocalDeclarations(Identifier("a")).count(), 1);
     QCOMPARE(top->findLocalDeclarations(Identifier("a")).first()->uses().count(), 0);
 
     QCOMPARE(top->childContexts().count(), 2);
     QCOMPARE(top->childContexts().last()->findLocalDeclarations(Identifier("a")).count(), 1);
     QCOMPARE(top->childContexts().last()->findLocalDeclarations(Identifier("a")).first()->uses().count(), 0);
 }
 
 void TestDUChain::superglobalInFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? $_GET; function foo() { $_GET; }");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("_GET")).count(), 1);
     Declaration* dec = top->findDeclarations(QualifiedIdentifier(QStringLiteral("_GET"))).first();
     QVERIFY(dynamic_cast<VariableDeclaration*>(dec));
     QVERIFY(static_cast<VariableDeclaration*>(dec)->isSuperglobal());
     QCOMPARE(dec->uses().keys().count(), 1);
     QCOMPARE(dec->uses().values().count(), 1);
     QCOMPARE(dec->uses().values().first().count(), 2);
     QCOMPARE(dec->uses().values().first().first(), RangeInRevision(0, 3, 0, 8));
     QCOMPARE(dec->uses().values().first().at(1), RangeInRevision(0, 27, 0, 32));
 }
 
 void TestDUChain::returnWithoutFunction()
 {
     //yes, this is possible in php, you then have $a as return value of an include call
     QByteArray method("<? $a = 0; return $a; ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 }
 
 void TestDUChain::circularInheritance()
 {
     //circular inheritance is not allowed in PHP and should not crash kdevelop
     QByteArray method("<? class a extends b {} class b extends c {} class c extends a {}");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->localDeclarations().at(2)->internalContext()->importedParentContexts().empty());
     QCOMPARE(top->localDeclarations().at(1)->internalContext()->importedParentContexts().count(), 1);
     QCOMPARE(top->localDeclarations().at(1)->internalContext()->importedParentContexts().first().context(top),
              top->localDeclarations().at(2)->internalContext());
     QCOMPARE(top->localDeclarations().at(0)->internalContext()->importedParentContexts().count(), 1);
     QCOMPARE(top->localDeclarations().at(0)->internalContext()->importedParentContexts().first().context(top),
              top->localDeclarations().at(1)->internalContext());
 }
 
 void TestDUChain::findDeclarations()
 {
     DUChainWriteLocker lock(DUChain::lock());
 
     TopDUContext* top1 = new TopDUContext(IndexedString(QUrl(QStringLiteral("file:///internal/testfile1"))), RangeInRevision(0, 0, 0, 10), nullptr);
     DUChainReleaser releaseTop1(top1);
     DUChain::self()->addDocumentChain(top1);
     TopDUContext* top2 = new TopDUContext(IndexedString(QUrl(QStringLiteral("file:///internal/testfile2"))), RangeInRevision(0, 0, 0, 10), nullptr);
     DUChainReleaser releaseTop2(top2);
     DUChain::self()->addDocumentChain(top2);
 
     Declaration* declaration = new Declaration(RangeInRevision(0, 0, 0, 3), top1);
     declaration->setIdentifier(Identifier(QStringLiteral("foo")));
 
     QVERIFY(!top1->usingImportsCache());
     QVERIFY(!top2->usingImportsCache());
 
     QCOMPARE(1, top1->findDeclarations(Identifier("foo")).count());
     QCOMPARE(0, top2->findDeclarations(Identifier("foo")).count());
     top2->addImportedParentContext(top1);
 
     QVERIFY(!top1->usingImportsCache());
     QVERIFY(!top2->usingImportsCache());
 
     QCOMPARE(1, top2->findDeclarations(Identifier("foo")).count());
     top2->clearImportedParentContexts();
     QCOMPARE(top2->importedParentContexts().size(), 0);
 
     QVERIFY(!top1->usingImportsCache());
     QVERIFY(!top2->usingImportsCache());
 
     QCOMPARE(0, top2->findDeclarations(Identifier("foo")).count());
     top2->addImportedParentContext(top1);
     QCOMPARE(1, top2->findDeclarations(Identifier("foo")).count());
 }
 
 void TestDUChain::memberTypeAfterMethod()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { function foo(){} public $bar; }");
 
     TopDUContext* top = parse(method, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     DUContext* contextClassA = top->childContexts().first();
 
     // function foo
     {
         ClassMemberDeclaration* var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().first());
         QVERIFY(var);
         QCOMPARE(var->identifier(), Identifier("foo"));
         QCOMPARE(var->accessPolicy(), Declaration::Public);
         QCOMPARE(var->isStatic(), false);
         QVERIFY(var->type<FunctionType>());
         IntegralType::Ptr ret = var->type<FunctionType>()->returnType().cast<IntegralType>();
         QVERIFY(ret);
         QVERIFY(ret->dataType() == IntegralType::TypeVoid);
     }
 
     // public $bar
     {
         ClassMemberDeclaration* var = dynamic_cast<ClassMemberDeclaration*>(contextClassA->localDeclarations().at(1));
         QVERIFY(var);
         QCOMPARE(var->identifier(), Identifier("bar"));
         QCOMPARE(var->accessPolicy(), Declaration::Public);
         QCOMPARE(var->isStatic(), false);
         QVERIFY(var->type<IntegralType>());
         QVERIFY(var->type<IntegralType>()->dataType() == IntegralType::TypeMixed);
     }
 }
 
 
 void TestDUChain::catchDeclaration()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? try {} catch (Exception $e) {}");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     VariableDeclaration* ex = dynamic_cast<VariableDeclaration*>(top->localDeclarations().first());
     QVERIFY(ex);
     QCOMPARE(ex->identifier(), Identifier("e"));
     QVERIFY(ex->type<StructureType>());
     QCOMPARE(QualifiedIdentifier("exception"), ex->type<StructureType>()->declaration(top)->qualifiedIdentifier());
 }
 
 void TestDUChain::resourceType()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? /**\n * @return resource\n**/\nfunction test() {}");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionDeclaration* fun = dynamic_cast<FunctionDeclaration*>(top->localDeclarations().first());
     QVERIFY(fun);
     FunctionType::Ptr ftype = FunctionType::Ptr::dynamicCast(fun->abstractType());
     QVERIFY(ftype);
     IntegralType::Ptr rtype = IntegralType::Ptr::dynamicCast(ftype->returnType());
     QVERIFY(rtype);
     QCOMPARE(rtype->toString(), QString("resource"));
     QVERIFY(rtype->dataType() == IntegralTypeExtended::TypeResource);
 }
 
 void TestDUChain::foreachIterator()
 {
     QByteArray code;
     code.append("<? class B {} class A implements Iterator {");
     code.append("public function rewind() {} ");
     code.append("/**\n * @return B\n */public function current() {} ");
     code.append("public function key() {} ");
     code.append("public function next() {} ");
     code.append("public function valid() {} ");
     code.append("} ");
     code.append("$a = new A();");
     code.append("foreach($a as $i) { $i; }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* iDec = top->localDeclarations().at(3);
     QCOMPARE(iDec->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QVERIFY(iDec->type<StructureType>());
     QCOMPARE(iDec->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(top->localDeclarations().first() == iDec->type<StructureType>()->declaration(top));
 }
 
 void TestDUChain::foreachIterator2()
 {
     QByteArray code;
     code.append("<? class B {} class A implements Iterator {");
     code.append("public function rewind() {} ");
     code.append("/**\n * @return B\n */public function current() {} ");
     code.append("public function key() {} ");
     code.append("public function next() {} ");
     code.append("public function valid() {} ");
     code.append("} ");
     code.append("foreach(new A() as $i) { $i; }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->localDeclarations().size(), 3);
     Declaration* iDec = top->localDeclarations().at(2);
     QCOMPARE(iDec->qualifiedIdentifier(), QualifiedIdentifier("i"));
     qDebug() << iDec->abstractType()->toString();
     QVERIFY(iDec->type<StructureType>());
     QCOMPARE(iDec->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(top->localDeclarations().first() == iDec->type<StructureType>()->declaration(top));
 }
 
 void TestDUChain::foreachIterator3()
 {
     QByteArray code;
     code.append("<? class B {} class A implements Iterator {");
     code.append("public function rewind() {} ");
     code.append("/**\n * @return B\n */public function current() {} ");
     code.append("public function key() {} ");
     code.append("public function next() {} ");
     code.append("public function valid() {} ");
     code.append("} ");
     code.append("class C extends A { }");
     code.append("foreach(new C() as $i) { $i; }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* iDec = top->localDeclarations().at(3);
     QCOMPARE(iDec->qualifiedIdentifier(), QualifiedIdentifier("i"));
     QVERIFY(iDec->type<StructureType>());
     QCOMPARE(iDec->type<StructureType>()->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QVERIFY(top->localDeclarations().first() == iDec->type<StructureType>()->declaration(top));
 }
 
 void TestDUChain::foreachIterator4()
 {
     // see also: https://bugs.kde.org/show_bug.cgi?id=276603
     QByteArray code = "<?\n"
                       "class A {\n"
                       "  public static $s;\n"
                       "  function foo() {\n"
                       "    foreach(array(1,2) as $this->i){}\n"
                       "    foreach(array(1,2) as $this->k => $this->v){}\n"
                       "    foreach(array(1,2) as A::$s){}\n"
                       "  }\n"
                       "}\n";
 
     TopDUContext* top = parse(code, DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
 
     Declaration* aDec = top->localDeclarations().first();
 
     DUContext* fooCtx = top->childContexts().first()->childContexts().last();
     QVERIFY(fooCtx->owner());
 
     QCOMPARE(aDec->uses().size(), 1);
     QCOMPARE(aDec->uses().begin()->size(), 4);
 }
 
 void TestDUChain::returnThis()
 {
     QByteArray code("<? class A { \n/**\n * @return $this\n */\npublic function x() {} } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->childContexts().first()->localDeclarations().first();
     QVERIFY(dec->type<FunctionType>());
     AbstractType::Ptr t = dec->type<FunctionType>()->returnType();
     qDebug() << t->toString();
     QVERIFY(StructureType::Ptr::dynamicCast(t));
     QVERIFY(StructureType::Ptr::dynamicCast(t)->declaration(top) == top->localDeclarations().first());
 }
 
 void TestDUChain::unsureReturnType()
 {
     QByteArray code("<? /**\n * @return bool|int\n */\nfunction x() {} ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().first();
     QVERIFY(dec->type<FunctionType>());
     TypePtr<UnsureType> ut = dec->type<FunctionType>()->returnType().cast<UnsureType>();
     QVERIFY(ut);
     QCOMPARE((uint)2, ut->typesSize());
     QVERIFY(ut->types()[0].type<IntegralType>());
     QVERIFY(ut->types()[0].type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     QVERIFY(ut->types()[1].type<IntegralType>());
     QVERIFY(ut->types()[1].type<IntegralType>()->dataType() == IntegralType::TypeInt);
 }
 
 
 void TestDUChain::unsureReturnType2()
 {
     QByteArray code("<? class A {} class B {}\n/**\n * @return A|B\n */\nfunction x() {} ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().at(2);
     QVERIFY(dec->type<FunctionType>());
     TypePtr<UnsureType> ut = dec->type<FunctionType>()->returnType().cast<UnsureType>();
     QVERIFY(ut);
     QCOMPARE((uint)2, ut->typesSize());
     QVERIFY(ut->types()[0].type<StructureType>());
     QCOMPARE(ut->types()[0].type<StructureType>()->toString(), QString("A"));
     QVERIFY(ut->types()[1].type<StructureType>());
     QCOMPARE(ut->types()[1].type<StructureType>()->toString(), QString("B"));
 }
 
 void TestDUChain::unsureReturnType3()
 {
     QByteArray code("<? function x() { if(rand(0,1)) return false; else return 1; return \"a\"; } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().at(0);
     QVERIFY(dec->type<FunctionType>());
     qDebug() << dec->type<FunctionType>()->returnType()->toString();
     TypePtr<UnsureType> ut = dec->type<FunctionType>()->returnType().cast<UnsureType>();
     QVERIFY(ut);
     QCOMPARE((uint)3, ut->typesSize());
     QVERIFY(ut->types()[0].type<IntegralType>());
     QVERIFY(ut->types()[0].type<IntegralType>()->dataType() == IntegralType::TypeInt);
     QVERIFY(ut->types()[1].type<IntegralType>());
     QVERIFY(ut->types()[1].type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     QVERIFY(ut->types()[2].type<IntegralType>());
     QVERIFY(ut->types()[2].type<IntegralType>()->dataType() == IntegralType::TypeString);
 }
 
 void TestDUChain::unsureReturnType4()
 {
     QByteArray code("<? \n/**\n * @param bool|int\n */\nfunction x($a) { return $a; } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().first();
     QVERIFY(dec->type<FunctionType>());
     TypePtr<UnsureType> ut = dec->type<FunctionType>()->returnType().cast<UnsureType>();
     QVERIFY(ut);
     QCOMPARE((uint)2, ut->typesSize());
     QVERIFY(ut->types()[0].type<IntegralType>());
     QVERIFY(ut->types()[0].type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     QVERIFY(ut->types()[1].type<IntegralType>());
     QVERIFY(ut->types()[1].type<IntegralType>()->dataType() == IntegralType::TypeInt);
 }
 
 void TestDUChain::referencedArgument()
 {
     // php does not return references
     QByteArray code("<? \nfunction x(&$a) { $a = 1; return $a; } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().first();
     QVERIFY(dec->type<FunctionType>());
     qDebug() << dec->abstractType()->toString();
     IntegralType::Ptr aType = dec->type<FunctionType>()->returnType().cast<IntegralType>();
     QVERIFY(aType);
     QCOMPARE(aType->dataType(), (uint)IntegralType::TypeInt);
     QCOMPARE(top->childContexts().first()->type(), DUContext::Function);
     ReferenceType::Ptr rType = top->childContexts().first()->localDeclarations().first()->abstractType().cast<ReferenceType>();
     QVERIFY(rType);
     QVERIFY(rType->baseType()->equals(aType.data()));
 }
 
 void TestDUChain::unsureReferencedArgument()
 {
     // php does not return references
     QByteArray code("<? \nfunction x(&$a) { $a = 1; $a = 'asdf'; return $a; } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->localDeclarations().first();
     QVERIFY(dec->type<FunctionType>());
     qDebug() << dec->abstractType()->toString();
     UnsureType::Ptr aType = dec->type<FunctionType>()->returnType().cast<UnsureType>();
     QVERIFY(aType);
     QCOMPARE(aType->typesSize(), 2u);
     QCOMPARE(aType->types()[0].abstractType().cast<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
     QCOMPARE(aType->types()[1].abstractType().cast<IntegralType>()->dataType(), (uint)IntegralType::TypeString);
     QCOMPARE(top->childContexts().first()->type(), DUContext::Function);
     ReferenceType::Ptr rType = top->childContexts().first()->localDeclarations().first()->abstractType().cast<ReferenceType>();
     QVERIFY(rType);
     QVERIFY(rType->baseType()->equals(aType.data()));
 }
 
 void TestDUChain::defaultArgument()
 {
     // php does not return references
     QByteArray code("<? \nfunction x($a = 1) {} ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     Declaration* dec = top->childContexts().first()->localDeclarations().first();
     QVERIFY(dec->type<IntegralType>());
     QCOMPARE(dec->type<IntegralType>()->dataType(), (uint)IntegralType::TypeInt);
 }
 
 void TestDUChain::declareMemberOutOfClass()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? class foo{ protected $prot; private $priv; }\n"
                     // allowed, should only declare asdf once
                     "$bar = new foo; $bar->asdf = true; $bar->asdf = false;\n"
                     // not allowed:
                     "$bar->prot = 1;\n"
                     // not allowed:
                     "$bar->priv = 1;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     { // $bar is only declared once
         QList<Declaration*> decs = top->findLocalDeclarations(Identifier(QStringLiteral("bar")));
         QCOMPARE(decs.size(), 1);
         Declaration *dec = decs.first();
         QVERIFY(dec->type<StructureType>());
         QVERIFY(dec->type<StructureType>()->declaration(top)->identifier().nameEquals(Identifier("foo")));
 
         // while we are at it, compare uses
         QCOMPARE(dec->uses().keys().count(), 1);
         QCOMPARE(dec->uses().values().count(), 1);
         QCOMPARE(dec->uses().values().first().count(), 4);
         qDebug() << dec->uses().values().first().at(0).castToSimpleRange();
         QCOMPARE(dec->uses().values().first().at(0), RangeInRevision(1, 16, 1, 20));
         qDebug() << dec->uses().values().first().at(1).castToSimpleRange();
         QCOMPARE(dec->uses().values().first().at(1), RangeInRevision(1, 35, 1, 39));
         qDebug() << dec->uses().values().first().at(2).castToSimpleRange();
         QCOMPARE(dec->uses().values().first().at(2), RangeInRevision(2, 0, 2, 4));
         qDebug() << dec->uses().values().first().at(3).castToSimpleRange();
         QCOMPARE(dec->uses().values().first().at(3), RangeInRevision(3, 0, 3, 4));
     }
 
     { // check if asdf got declared
         QList<Declaration*> decs = top->childContexts().first()->findDeclarations(Identifier(QStringLiteral("asdf")));
         // the type of both assignments to $bar->asdf are the same, hence it should only be declared once
         QCOMPARE(decs.size(), 1);
         ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
         QVERIFY(cmdec);
         QVERIFY(cmdec->accessPolicy() == Declaration::Public);
         QVERIFY(!cmdec->isStatic());
         QVERIFY(cmdec->type<IntegralType>());
         QVERIFY(cmdec->type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     }
 
     // check that prot and priv don't get redeclared
     QCOMPARE(top->problems().count(), 2);
     QCOMPARE(top->problems().at(0)->finalLocation().start().line(), 2);
     QCOMPARE(top->problems().at(1)->finalLocation().start().line(), 3);
 }
 
 void TestDUChain::declareMemberOutOfClass2()
 {
     // see also: https://bugs.kde.org/show_bug.cgi?id=283356
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? $a = new A();\n"
                     // allowed, should re-use existing declaration
                     "$a->x = 1;\n"
                     "class A { var $x = 1; }");
     TopDUContext* top = parse(code, DumpAST);
     QVERIFY(top);
     // update
     top = parse(code, DumpNone, top->url().toUrl(), ReferencedTopDUContext(top));
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QVERIFY(top->problems().isEmpty());
 
     QList<Declaration*> decs = top->findLocalDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 2);
     {
         Declaration *dec = decs.first();
         QVERIFY(dynamic_cast<VariableDeclaration*>(dec));
         QVERIFY(dec->type<StructureType>());
         QVERIFY(dec->type<StructureType>()->declaration(top)->identifier().nameEquals(Identifier("a")));
     }
     {
         Declaration *dec = decs.last();
         QVERIFY(dynamic_cast<ClassDeclaration*>(dec));
         QVERIFY(dec->type<StructureType>());
         QVERIFY(dec->type<StructureType>()->declaration(top)->identifier().nameEquals(Identifier("a")));
     }
 
     { // check if x got declared
         QList<Declaration*> decs = top->childContexts().first()->findDeclarations(Identifier(QStringLiteral("x")));
         // the type of both assignments to $bar->asdf are the same, hence it should only be declared once
         QCOMPARE(decs.size(), 1);
         ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
         QVERIFY(cmdec);
         QVERIFY(cmdec->accessPolicy() == Declaration::Public);
         QVERIFY(!cmdec->isStatic());
         QVERIFY(cmdec->type<IntegralType>());
         QCOMPARE(cmdec->type<IntegralType>()->dataType(), (uint) IntegralType::TypeInt);
     }
 }
 
 void TestDUChain::declareMemberInClassMethod()
 {
     QByteArray code("<? class foo { private $priv = 0; protected $prot = 0; } class bar extends foo {\n"
                     // should declare member variable asdf (once!) as public
                     " function test() { $this->asdf = true; $this->asdf = false; }\n"
                     // should only declare bar once as private
                     " private $xyz = 0; function test2() { $this->xyz = 42; }\n"
                     // should not create any local declarations, and issue an error for trying to
                     // assign something to a private member variable of a parent class
                     " function test3() { $this->prot = 42;\n$this->priv = 42; }\n"
                     " }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     { // asdf
         QList<Declaration*> decs = top->childContexts().last()->findLocalDeclarations(Identifier(QStringLiteral("asdf")));
         QCOMPARE(decs.size(), 1);
         ClassMemberDeclaration *dec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
         QVERIFY(dec);
         QVERIFY(dec->accessPolicy() == Declaration::Public);
         QVERIFY(!dec->isStatic());
         QVERIFY(dec->type<IntegralType>());
         QVERIFY(dec->type<IntegralType>()->dataType() == IntegralType::TypeBoolean);
     }
 
     { // xyz
         QList<Declaration*> decs = top->childContexts().last()->findLocalDeclarations(Identifier(QStringLiteral("xyz")));
         QCOMPARE(decs.size(), 1);
         ClassMemberDeclaration *dec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
         QVERIFY(dec);
         QVERIFY(dec->accessPolicy() == Declaration::Private);
         QVERIFY(!dec->isStatic());
         QVERIFY(dec->type<IntegralType>());
         QVERIFY(dec->type<IntegralType>()->dataType() == IntegralType::TypeInt);
     }
 
     { // prot and priv
         QVERIFY(top->childContexts().last()->findLocalDeclarations(Identifier("prot")).isEmpty());
         QVERIFY(top->childContexts().last()->findLocalDeclarations(Identifier("priv")).isEmpty());
     }
 
     // only one problem: error trying to assign to a private member of a parent class
     QCOMPARE(top->problems().count(), 1);
     QCOMPARE(top->problems().first()->finalLocation().start().line(), 4);
 }
 
 void TestDUChain::thisRedeclaration()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? class foo{ function foo(){ $this->test = true; $this = false;} }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     // only $this = false is a problem, $this->test = true is perfectly valid
     QCOMPARE(top->problems().count(), 1);
     qDebug() << top->problems().first()->finalLocation();
     QVERIFY(top->problems().first()->finalLocation() == KDevelop::DocumentRange(top->url(), KTextEditor::Range(0, 50, 0, 55)));
 }
 
 void TestDUChain::implicitArrayDeclaration()
 {
     ///TODO: adapt to unsure type once it's supported
     {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? $a[1] = true;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList<Declaration*> decs = top->findDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     VariableDeclaration* vdec = dynamic_cast<VariableDeclaration*>(decs.first());
     QVERIFY(vdec);
     QVERIFY(vdec->type<IntegralType>());
     QVERIFY(vdec->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     }
 
     {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? $b = 1; $a[$b] = true;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList<Declaration*> decs = top->findDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     VariableDeclaration* vdec = dynamic_cast<VariableDeclaration*>(decs.first());
     QVERIFY(vdec);
     QVERIFY(vdec->type<IntegralType>());
     QVERIFY(vdec->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     }
 
     {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? class foo{} $bar = new foo; $bar->a[1] = true;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList<Declaration*> decs = top->childContexts().first()->findDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
     QVERIFY(cmdec);
     QVERIFY(cmdec->type<IntegralType>());
     QVERIFY(cmdec->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     }
 
     {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? class foo{} $bar = new foo; $b = 1; $bar->a[$b] = true;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList<Declaration*> decs = top->childContexts().first()->findDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
     QVERIFY(cmdec);
     QVERIFY(cmdec->type<IntegralType>());
     QVERIFY(cmdec->type<IntegralType>()->dataType() == IntegralType::TypeArray);
     }
 }
 
 void TestDUChain::implicitReferenceDeclaration()
 {
     {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? function asdf(&$foo) {} asdf($bar);");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QList<Declaration*> decs = top->findDeclarations(Identifier(QStringLiteral("bar")));
     QCOMPARE(decs.size(), 1);
     QVERIFY(dynamic_cast<VariableDeclaration*>(decs.first()));
     QVERIFY(decs.first()->type<IntegralType>());
     qDebug() << decs.first()->type<IntegralType>()->dataType() << decs.first()->toString();
     QVERIFY(decs.first()->type<IntegralType>()->dataType() == IntegralType::TypeNull);
     }
 
     {
     // a user reported a crash with the code example below
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<? function test(&$p) {} class foo{ private $a; function test() {test($this->a);}  }");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY( top->childContexts().last()->localScopeIdentifier() == QualifiedIdentifier("foo"));
 
     // a is already declared
     QList<Declaration*> decs = top->childContexts().last()->findDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
     QVERIFY(cmdec);
     QVERIFY(cmdec->type<IntegralType>());
 
     qDebug() << cmdec->type<IntegralType>()->dataType() << cmdec->toString();
     QVERIFY(cmdec->type<IntegralType>()->dataType() == IntegralType::TypeMixed);
     }
 }
 
 void TestDUChain::classContextRange()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<?php class A { } $a = new A; ?> <?php $b = 1; $a->foobar = 1; $a->barFoo= 0;");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->childContexts().first()->range(), KDevelop::RangeInRevision(0, 6, 0, 17));
     QCOMPARE(top->childContexts().first()->localDeclarations().count(), 2);
 }
 
 void TestDUChain::lateClassMembers()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray code("<?php class A { function f() { $this->val = 'b'; } private $val = 'a'; } ");
     TopDUContext* top = parse(code, DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     ClassDeclaration* cdec = dynamic_cast<ClassDeclaration*>(top->localDeclarations().first());
     QVERIFY(cdec);
     QList<Declaration*> decs = cdec->logicalInternalContext(top)->findDeclarations(Identifier(QStringLiteral("val")));
     QCOMPARE(decs.count(), 1);
     ClassMemberDeclaration* cmdec = dynamic_cast<ClassMemberDeclaration*>(decs.first());
     QVERIFY(cmdec);
     QCOMPARE(cmdec->accessPolicy(), Declaration::Private);
 }
 
 void TestDUChain::list()
 {
     foreach ( const QString& code, QStringList() << "<?php list($i, $j, $k) = array(1,2,3);"
                                                  << "<?php $a = array(1,2,3); list($i,$j,$k) = $a;"
                                                  << "<?php function t() { return array(1,2,3); } list($i,$j,$k) = t();" )
     {
         //               0         1         2         3         4         5         6         7
         //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
         TopDUContext* top = parse(code.toUtf8(), DumpAST);
         DUChainReleaser releaseTop(top);
         DUChainWriteLocker lock(DUChain::lock());
 
         foreach ( const QString& identifier, QStringList() << "i" << "j" << "k" ) {
             qDebug() << "searching for declaration of " << identifier;
             QList<Declaration*> decs = top->findDeclarations(Identifier(identifier));
             QCOMPARE(decs.size(), 1);
             Declaration *dec = decs.first();
             QVERIFY(dec->type<IntegralType>());
             QCOMPARE(dec->type<IntegralType>()->dataType(), (uint) IntegralType::TypeMixed);
             ///TODO: support arrays better and compare to actual type
         }
     }
 }
 
 void TestDUChain::alternateDocCommentTypeHints()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php class test {\n/// @var test\nprivate static $test;\n}", DumpAST);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     ClassDeclaration* cdec = dynamic_cast<ClassDeclaration*>(top->localDeclarations().first());
     QVERIFY(cdec);
     QVERIFY(cdec->type<StructureType>());
     QVector<Declaration*> decs = cdec->logicalInternalContext(top)->localDeclarations();
     QCOMPARE(decs.size(), 1);
     Declaration *dec = decs.first();
     QVERIFY(dec->type<StructureType>());
     QCOMPARE(dec->type<StructureType>()->declaration(top), cdec);
 }
 
 void TestDUChain::findFunctionArgs()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php function foo($bar, $asdf) {}", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionDeclaration* funcDec = dynamic_cast<FunctionDeclaration*>(top->localDeclarations().first());
     QVERIFY(funcDec);
     QVERIFY(funcDec->internalContext());
     QVERIFY(funcDec->internalFunctionContext());
     QVERIFY(funcDec->internalContext()->imports(funcDec->internalFunctionContext()));
 
     QList<Declaration*> decs;
     foreach ( Declaration* arg, funcDec->internalFunctionContext()->localDeclarations() ) {
         decs = funcDec->internalContext()->findDeclarations(arg->identifier());
         QCOMPARE(decs.size(), 1);
         decs = funcDec->internalContext()->findDeclarations(arg->qualifiedIdentifier());
         qDebug() << arg->qualifiedIdentifier().toString();
         QEXPECT_FAIL("", "strangely the arg dec is only found with its identifier, not by its qualifiedidentifier...", Continue);
         QCOMPARE(decs.size(), 1);
     }
 }
 
 void TestDUChain::undeclaredPropertyInString()
 {
     // testcase for bug 209814
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php class foo { var $foo; function bar() { \"$this->baz\"; } }", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QCOMPARE(top->childContexts().size(), 1);
     DUContext* classCtx = top->childContexts().first();
     QVERIFY(classCtx->type() == DUContext::Class);
     QCOMPARE(classCtx->localDeclarations().size(), 2);
     QCOMPARE(classCtx->findDeclarations(Identifier("foo")).size(), 1);
     QCOMPARE(classCtx->findDeclarations(Identifier("bar")).size(), 1);
 }
 
 void TestDUChain::undeclaredVarPropertyInString()
 {
     // testcase for bug 210043
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php \"$a->baz\";", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     // just don't crash
 }
 
 void TestDUChain::upcommingClassInString()
 {
     // testcase for bug 232687
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                                 "class A {\n"
                                 "    function A () {\n"
                                 "        $b = new B();\n"
                                 "        echo \"$b->blah\";\n"
                                 "    }\n"
                                 "}\n"
                                 "class B {\n"
                                 "  var $blah;\n"
                                 "}\n", DumpNone);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     // just don't crash
 }
 
 void TestDUChain::namespaces()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "namespace asdf{\n"
                               "function a(){}\n"
                               "define('b', 0);\n"
                               "class c {}\n"
                               "}\n"
                               "namespace NS1\\NS2 {\n"
                               "function a(){}\n"
                               "define('b', 0);\n"
                               "class c {}\n"
                               "}\n"
                               "namespace {\n"
                               "function a(){}\n"
                               "}\n"
                               , DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->problems().count(), 0);
 
     QCOMPARE(top->childContexts().size(), 4);
     QCOMPARE(top->childContexts().at(0)->localScopeIdentifier().toString(), QString("asdf"));
     QCOMPARE(top->childContexts().at(1)->localScopeIdentifier().toString(), QString("ns1"));
 
     QCOMPARE(top->childContexts().at(2)->type(), DUContext::Function);
     QCOMPARE(top->childContexts().at(3)->localScopeIdentifier().toString(), QString("a"));
 
     QCOMPARE(top->localDeclarations().size(), 3);
     QCOMPARE(top->localDeclarations().at(0)->kind(), Declaration::Namespace);
     QCOMPARE(top->localDeclarations().at(1)->kind(), Declaration::Namespace);
     QCOMPARE(top->localDeclarations().at(2)->kind(), Declaration::Type);
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("asdf")).size(), 1);
     QCOMPARE(top->childContexts().at(0)->localDeclarations().size(), 3);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("asdf::a")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("asdf::b")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("asdf::c")).size(), 1);
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1")).size(), 1);
     QCOMPARE(top->childContexts().at(1)->localDeclarations().size(), 1);
     QCOMPARE(top->childContexts().at(1)->localDeclarations().first()->kind(), Declaration::Namespace);
     ///TODO: support \ as separator
     QCOMPARE(top->childContexts().at(1)->localDeclarations().first()->qualifiedIdentifier().toString(), QString("ns1::ns2"));
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2")).first()->logicalInternalContext(top)->localDeclarations().size(), 3);
     QCOMPARE(top->childContexts().at(1)->childContexts().size(), 1);
     QCOMPARE(top->childContexts().at(1)->childContexts().first()->localDeclarations().size(), 3);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2")).first()->logicalInternalContext(top)->localDeclarations().first()->qualifiedIdentifier().toString(),
              QString("ns1::ns2::a"));
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2::a")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2::b")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("ns1::ns2::c")).size(), 1);
 
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("a")).size(), 1);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("b")).size(), 0);
     QCOMPARE(top->findDeclarations(QualifiedIdentifier("c")).size(), 0);
 
     ///TODO: prevent redeclarations of namespaces
 }
 
 void TestDUChain::namespacesNoCurly()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "namespace asdf;\n"
                               "function a(){}\n"
                               "define('b', 0);\n"
                               "class c {}\n"
                               "\n"
                               "namespace NS1\\NS2;\n"
                               "function a(){}\n"
                               "define('b', 0);\n"
                               "class c {}\n"
                               "\n"
                               , DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->problems().count(), 0);
     foreach(ProblemPointer p, top->problems()) {
         qDebug() << p->description() << p->explanation() << p->finalLocation();
     }
     QCOMPARE(top->childContexts().size(), 2);
     QCOMPARE(top->childContexts().at(0)->localScopeIdentifier().toString(), QString("asdf"));
     QCOMPARE(top->childContexts().at(1)->localScopeIdentifier().toString(), QString("ns1"));
 
     QCOMPARE(top->localDeclarations().size(), 2);
     QCOMPARE(top->localDeclarations().at(0)->kind(), Declaration::Namespace);
     QCOMPARE(top->localDeclarations().at(1)->kind(), Declaration::Namespace);
 }
 
 void TestDUChain::useNamespace()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "namespace ns1\\ns2 {\n"
                               "function a(){}\n"
                               "const b = 0;\n"
                               "class c {}\n"
                               "}\n"
                               "namespace ns3\\ns4 {\n"
                               "function a(){}\n"
                               "const b = 0;\n"
                               "class c {}\n"
                               "}\n"
                               "namespace {\n"
                               "use ns1\\ns2, ns3\\ns4 as ns5;\n"
                               "use \\ns3\\ns4 as ns6;\n"
                               "}\n"
                               , DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QCOMPARE(top->localDeclarations().count(), 5);
 
     Declaration* dec = top->localDeclarations().at(2);
     QCOMPARE(dec->qualifiedIdentifier().toString(), QString("ns2"));
     QVERIFY(dynamic_cast<NamespaceAliasDeclaration*>(dec));
 
     dec = top->localDeclarations().at(3);
     QCOMPARE(dec->qualifiedIdentifier().toString(), QString("ns5"));
     QVERIFY(dynamic_cast<NamespaceAliasDeclaration*>(dec));
 
     dec = top->localDeclarations().at(4);
     QCOMPARE(dec->qualifiedIdentifier().toString(), QString("ns6"));
     QVERIFY(dynamic_cast<NamespaceAliasDeclaration*>(dec));
     ///TODO: find out why this is explictly required
     QVERIFY(!dynamic_cast<NamespaceAliasDeclaration*>(dec)->importIdentifier().explicitlyGlobal());
 }
 
 void TestDUChain::namespaceStaticVar()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "namespace ns {\n"
                               "class c{ static public $foo; }\n"
                               "}\n"
                               "namespace {\n"
                               "\\ns\\c::$foo;\n"
                               "}\n"
                               , DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QVERIFY(top->problems().isEmpty());
     Declaration* fooDec = top->findDeclarations(QualifiedIdentifier(QStringLiteral("ns::c::foo"))).first();
     QVERIFY(fooDec);
 
     QVERIFY(!fooDec->uses().isEmpty());
     QVERIFY(!fooDec->uses().begin()->isEmpty());
     QCOMPARE(fooDec->uses().begin()->begin()->start.line, 5);
 }
 
 void TestDUChain::namespacedCatch()
 {
     // see also: https://bugs.kde.org/show_bug.cgi?id=281451
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "namespace ns {\n"
                               "class e{}\n"
                               "}\n"
                               "namespace {\n"
                               "try { /* ... */ }\n"
                               "catch(\\ns\\e $exeption) { /* ... */ }"
                               "}\n"
                               , DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     QVERIFY(top->problems().isEmpty());
     Declaration* eDec = top->findDeclarations(QualifiedIdentifier(QStringLiteral("ns::e"))).first();
     QVERIFY(eDec);
 
     QVERIFY(!eDec->uses().isEmpty());
     QVERIFY(!eDec->uses().begin()->isEmpty());
     QCOMPARE(eDec->uses().begin()->begin()->start.line, 6);
 }
 
 struct TestUse {
     TestUse(const QString& _id, Declaration::Kind _kind, int _uses)
         : id(_id), kind(_kind), uses(_uses)
     {}
     TestUse()
     {}
     QualifiedIdentifier id;
     Declaration::Kind kind;
     int uses;
 };
 
 Q_DECLARE_METATYPE ( TestUse )
 Q_DECLARE_METATYPE ( QList<TestUse> )
 
 void TestDUChain::errorRecovery_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::addColumn< QList<TestUse> >("usesMap");
 
     QTest::newRow("conditional") << QStringLiteral("<?php $a = 1; if ( false ) { in va lid } $a = 2; ")
                                  << (QList<TestUse>()
                                     << TestUse(QStringLiteral("a"), Declaration::Instance, 1));
 
     QTest::newRow("namespace") << QStringLiteral("<?php namespace foo { const a = 1; } namespace y { -a sdflyxjcv 91348 } namespace { foo\\a; }")
                                  << (QList<TestUse>()
                                     << TestUse(QStringLiteral("foo"), Declaration::Namespace, 1)
                                     << TestUse(QStringLiteral("y"), Declaration::Namespace, 0)
                                     << TestUse(QStringLiteral("foo::a"), Declaration::Instance, 1));
 
     QTest::newRow("class") << QStringLiteral("<?php class foo { const bar = 1; invalid static function func() {} } foo::bar; foo::func;")
                                  << (QList<TestUse>()
                                     << TestUse(QStringLiteral("foo"), Declaration::Type, 0)
                                     << TestUse(QStringLiteral("foo::bar"), Declaration::Instance, 1)
                                     << TestUse(QStringLiteral("foo::func"), Declaration::Type, 1)
                                     );
 }
 
 void TestDUChain::errorRecovery()
 {
     QFETCH(QString, code);
     QFETCH(QList<TestUse>, usesMap);
 
     TopDUContext* top = parse(code.toLocal8Bit(), DumpAll);
 
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
 
     foreach ( const TestUse& use, usesMap ) {
         QList< Declaration* > decs = top->findDeclarations(use.id);
         QCOMPARE(decs.count(), 1);
         Declaration* dec = decs.first();
         QCOMPARE(dec->kind(), use.kind);
         if (use.uses) {
             QCOMPARE(dec->uses().count(), 1);
             QCOMPARE(dec->uses().begin()->count(), use.uses);
         }
     }
 }
 
 void TestDUChain::varStatic()
 {
     //bug: https://bugs.kde.org/244076
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "class c { static a = 1; static function foo() {} }\n"
                               "$o = 'c';\n"
                               "$o::a;\n"
                               "$o::foo();\n"
                               , DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 
     // we cannot support anything though :(
 }
 
 void TestDUChain::staticNowdoc()
 {
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "class c {\n"
                               "public $bar = <<<'FOO'\nbar\nFOO;\n"
                               "public const C = <<<'FOO'\nbar\nFOO;\n"
                               "}\n"
                               , DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 
     QCOMPARE(top->childContexts().first()->localDeclarations().count(), 2);
     QCOMPARE(top->childContexts().first()->localDeclarations().first()->type<IntegralType>()->dataType(),
              static_cast<uint>(IntegralType::TypeString));
     QCOMPARE(top->childContexts().first()->localDeclarations().last()->type<IntegralType>()->dataType(),
              static_cast<uint>(IntegralType::TypeString));
 }
 
 void TestDUChain::curlyVarAfterObj()
 {
     // bug: https://bugs.kde.org/show_bug.cgi?id=241645
 
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse("<?php\n"
                               "class c {\n"
                               "public $bar = 'foo';\n"
                               "public $asdf = 'bar';\n"
                               "public function foo(){}\n"
                               "}\n"
                               "$a = new c;\n"
                               "$a->{$a->bar}();\n"
                               "$a->{$a->asdf};\n"
                               , DumpNone);
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 }
 
 void TestDUChain::embeddedHTML_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::newRow("if") << QStringLiteral("<?php if ( true ) : ?>\n<?php endif; ?>");
     QTest::newRow("elseif") << QStringLiteral("<?php if ( true ) : ?>\n<?php elseif ( false ) : ?>\n<?php endif; ?>");
     QTest::newRow("foreach") << QStringLiteral("<?php foreach ( array(1,2) as $i ) : ?>\n<?php endforeach; ?>\n");
     QTest::newRow("switch") << QStringLiteral("<?php switch ( 1 ) : case 1: ?>\n<?php break; endswitch; ?>\n");
     QTest::newRow("for") << QStringLiteral("<?php for ( ;; ) : ?>\n<?php endfor; ?>\n");
     QTest::newRow("while") << QStringLiteral("<?php while ( true ) : ?>\n<?php endwhile; ?>\n");
     QTest::newRow("else") << QStringLiteral("<?php if (true):\n echo 'ok1';\n else:\n echo 'ok2';\n endif; ?>");
 
 }
 
 void TestDUChain::embeddedHTML()
 {
     QFETCH(QString, code);
 
     TopDUContext* top = parse(code.toLocal8Bit(), DumpNone);
 
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 }
 
 void TestDUChain::cases()
 {
     // testcase for bug https://bugs.kde.org/show_bug.cgi?id=245832
     TopDUContext* top = parse("<?php switch(1) { case 1:\n case 2:\n break; default: break; }", DumpNone);
 
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 }
 
 void TestDUChain::closureParser()
 {
     // testcase for the parser after closures where introduced,
     // to make sure nothing brakes and all parser conflicts are resolved
     TopDUContext* top = parse("<?php\n"
                               "$lambda1 = function() {return 0;};\n"
                               "$lambda2 = function() use ($lambda1) {return 0;};\n"
                               "$lambda3 = function & () use (&$lambda2, $lambda1) {return 0;};\n"
                               "$lambda4 = function & ($a, &$b, stdClass $c) use (&$lambda2, $lambda1) {return 0;};\n"
                               "\n"
                               "class a {\n"
                               "  function foo() {}\n"
                               "  function & bar() {}\n"
                               "}\n"
                               "function foo() {}\n"
                               "function & bar() {}\n", DumpNone);
 
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 }
 
 void TestDUChain::closures()
 {
     TopDUContext* top = parse("<?php $l = function($a, stdClass $b) { return 0; };\n", DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
 
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* l = top->localDeclarations().first();
     QCOMPARE(l->identifier().toString(), QString("l"));
     Declaration* closure = top->localDeclarations().last();
     QVERIFY(closure->identifier().isEmpty());
 
     FunctionType::Ptr funcType = closure->type<FunctionType>();
     QVERIFY(funcType);
 
     QCOMPARE(funcType->arguments().count(), 2);
     QVERIFY(funcType->arguments().at(0).cast<IntegralType>());
     QCOMPARE(funcType->arguments().at(0).cast<IntegralType>()->dataType(), static_cast<uint>(IntegralType::TypeMixed));
     QVERIFY(funcType->arguments().at(1).cast<StructureType>());
     QCOMPARE(funcType->arguments().at(1).cast<StructureType>()->qualifiedIdentifier().toString(), QString("stdclass"));
 
     QVERIFY(funcType->returnType().cast<IntegralType>());
     QCOMPARE(funcType->returnType().cast<IntegralType>()->dataType(), static_cast<uint>(IntegralType::TypeInt));
 
     QVERIFY(l->abstractType()->equals(closure->abstractType().constData()));
 }
 
 void TestDUChain::closureEmptyUse()
 {
     // test case for: https://bugs.kde.org/show_bug.cgi?id=267105
     // don't crash but report parse error
     TopDUContext* top = parse("<?php $c = function ($v) use () { return $v > 2; };\n", DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QCOMPARE(top->problems().size(), 1);
 }
 
 void TestDUChain::iifeParser()
 {
     // testcase for bug https://bugs.kde.org/show_bug.cgi?id=370515
     TopDUContext* top = parse("<?php\n"
                               "$lambda1 = (function() {return 5;})();\n"
                               "$lambda2 = (function($a) {return $a;})(50);\n"
                               "$lambda3 = (function($a){ return function($b) use ($a){echo $a + $b;};})(50); \n"
                               "$lambda4 = (function ($a){echo $a;})(10) + (function ($a){echo $a ;})(20);"
                               , DumpNone);
 
     QVERIFY(top);
 
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().empty());
 }
 
 void TestDUChain::iife()
 {
     TopDUContext* top = parse("<?php $l = (function($a){ return function($b) use ($a){echo $a + $b;};})(50); \n", DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* l = top->localDeclarations().first();
     QCOMPARE(l->identifier().toString(), QString("l"));
     Declaration* iife = top->localDeclarations().last();
     QVERIFY(iife->identifier().isEmpty());
 }
 
 void TestDUChain::gotoTest()
 {
     TopDUContext* top = parse("<?php goto dest; dest: \n", DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
 
     ///TODO: create declaration for destination label
     ///TODO: create use for goto label
     ///TODO: report error when trying to jump into loop or switch statement
 }
 
 void TestDUChain::ternary()
 {
     TopDUContext* top = parse("<?php $a = true ? 1 : 2; $b = false ?: 3; \n", DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
 }
 
 void TestDUChain::bug296709()
 {
     // see also: https://bugs.kde.org/show_bug.cgi?id=296709
     //               0         1         2         3         4         5         6         7
     //               01234567890123456789012345678901234567890123456789012345678901234567890123456789
     TopDUContext* top = parse(
                     "<?php\n"
                     "foreach(array() as $a) {\n"
                     "  $a[0] = 1;\n"
                     "}\n", DumpAll);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock;
     QVERIFY(top->problems().isEmpty());
     QList< Declaration* > decs = top->findLocalDeclarations(Identifier(QStringLiteral("a")));
     QCOMPARE(decs.size(), 1);
     QCOMPARE(decs.at(0)->range(), RangeInRevision(1, 19, 1, 21));
     QCOMPARE(decs.at(0)->uses().count(), 1);
     QCOMPARE(decs.at(0)->uses().begin()->count(), 1);
     QCOMPARE(decs.at(0)->uses().begin()->first(), RangeInRevision(2, 2, 2, 4));
 }
 
 
 void TestDUChain::declareFinalMethod()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A { public final function foo() {} }");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(!top->parentContext());
     QCOMPARE(top->childContexts().count(), 1);
 
     DUContext* contextClassA = top->childContexts().first();
 
     Declaration* dec = contextClassA->localDeclarations().at(0);
     ClassFunctionDeclaration* funDec = dynamic_cast<ClassFunctionDeclaration*>(dec);
     QVERIFY(funDec);
     QCOMPARE(funDec->qualifiedIdentifier(), QualifiedIdentifier("a::foo"));
     QVERIFY(funDec->isFinal());
 }
 
 void Php::TestDUChain::testTodoExtractor()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<?\n"
                       "/* TODO: bla */\n"
                       "/// FIXME blub");
 
     QVERIFY(KDevelop::ICore::self()->languageController()->completionSettings()->todoMarkerWords().contains("TODO"));
     QVERIFY(KDevelop::ICore::self()->languageController()->completionSettings()->todoMarkerWords().contains("FIXME"));
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top);
     QCOMPARE(top->problems().size(), 2);
     QCOMPARE(top->problems().at(0)->description(), QString("TODO: bla"));
     QCOMPARE(top->problems().at(0)->range(), RangeInRevision(1, 3, 1, 12));
     QCOMPARE(top->problems().at(1)->description(), QString("FIXME blub"));
     QCOMPARE(top->problems().at(1)->range(), RangeInRevision(2, 4, 2, 14));
 }
 
 void TestDUChain::useThisAsArray()
 {
     QByteArray method("<?php\n"
                       "  interface ArrayAccess{} "
                       "  class A implements \\ArrayAccess\n"
                       "  {\n"
                       "      $values = [];\n"
                       "      function offsetGet($offset) { return $this->values[$offset]; }\n"
                       "      function offsetSet($offset, $value) { $this->values[$offset] = $value; }\n"
                       "      function offsetExists($offset) { return array_key_exists($offset, $this->values); }\n"
                       "      function offsetUnset($offset) { unset($this->values[$offset]); }\n"
                       "      function setTest() { $this['test'] = 'test'; }  \n"
                       "  }\n");
     
     TopDUContext* top = parse(method);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     
     QCOMPARE(top->importedParentContexts().count(), 1);
     QVERIFY(DUChain::self()->chainForDocument(internalFunctionFile()));
     QCOMPARE(DUChain::self()->chainForDocument(internalFunctionFile()), top->importedParentContexts().first().context(top));
     
     QVERIFY(top->problems().isEmpty());
 }
 
 void TestDUChain::wrongUseOfThisAsArray()
 {
     // missing functions from \ArrayAccess and not declared abstract
     QByteArray method("<?php\n"
                       "  interface ArrayAccess{} "
                       "  class A implements \\ArrayAccess\n"
                       "  {\n"
                       "      public function setTest() { $this['test'] = 'test'; }  \n"
                       "  }\n");
 
     TopDUContext* top = parse(method);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
     
     QCOMPARE(top->problems().size(),1);
 }
 
 void TestDUChain::staticFunctionClassPhp54()
 {
     QByteArray method("<?php\n"
                       "  class A\n"
                       "  {\n"
                       "      public static function func() {}  \n"
                       "  }\n"
                       " A::{'func'}();  \n");
 
     TopDUContext* top = parse(method);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->problems().isEmpty());
     QCOMPARE(top->localDeclarations().count(),1);
 
     Declaration* dec = top->localDeclarations().at(0);
     ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(dec);
     QCOMPARE(classDec->uses().count(),1);
 }
diff --git a/duchain/types/structuretype.h b/duchain/types/structuretype.h
index 62b9ec9..2bc90ff 100644
--- a/duchain/types/structuretype.h
+++ b/duchain/types/structuretype.h
@@ -1,103 +1,105 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2009 Milian Wolff <mail@milianw.de>                         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #ifndef PHP_STRUCTURETYPE_H
 #define PHP_STRUCTURETYPE_H
 
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/typesystemdata.h>
+#include <serialization/indexedstring.h>
+
 #include "phpduchainexport.h"
 
 namespace Php
 {
 
 class KDEVPHPDUCHAIN_EXPORT StructureTypeData : public KDevelop::StructureTypeData
 {
 public:
     /// Constructor
     StructureTypeData()
         : KDevelop::StructureTypeData()
     {
     }
     /// Copy constructor. \param rhs data to copy
     StructureTypeData( const StructureTypeData& rhs )
         : KDevelop::StructureTypeData(rhs), prettyName(rhs.prettyName)
     {
     }
 
     KDevelop::IndexedString prettyName;
 };
 
 /**
  * Drop-In replacement for the StructureType in KDevplatform which
  * makes it possible to store the type as lower case but
  * keeping the "pretty" name intact.
  */
 class KDEVPHPDUCHAIN_EXPORT StructureType: public KDevelop::StructureType
 {
 public:
     typedef KDevelop::TypePtr<StructureType> Ptr;
 
     /// Default constructor
     StructureType();
     /// Copy constructor. \param rhs type to copy
     StructureType(const StructureType& rhs);
     /// Constructor using raw data. \param data internal data.
     StructureType(StructureTypeData& data);
 
     void setPrettyName(const KDevelop::IndexedString& name);
     KDevelop::IndexedString prettyName() const;
 
     QString toString() const override;
 
     KDevelop::AbstractType* clone() const override;
 
     uint hash() const override;
 
     enum {
         ///TODO: is that value OK?
         Identity = 51
     };
 
   typedef StructureTypeData Data;
   typedef KDevelop::StructureType BaseType;
 
 protected:
     TYPE_DECLARE_DATA(StructureType);
 };
 
 }
 
 namespace KDevelop
 {
 
 template<>
 inline Php::StructureType* fastCast<Php::StructureType*>(AbstractType* from) {
     if ( !from || from->whichType() != AbstractType::TypeStructure ) {
         return nullptr;
     } else {
         return dynamic_cast<Php::StructureType*>(from);
     }
 }
 
 }
 
 #endif // PHP_STRUCTURETYPE_H
 
diff --git a/parser/parsesession.cpp b/parser/parsesession.cpp
index dbaac8e..faad259 100644
--- a/parser/parsesession.cpp
+++ b/parser/parsesession.cpp
@@ -1,178 +1,179 @@
 /*****************************************************************************
  * Copyright (c) 2007 Piyush verma <piyush.verma@gmail.com>                  *
  * Copyright (c) 2008 Niko Sams <niko.sams@gmail.com>                        *
  *                                                                           *
  * This program is free software; you can redistribute it and/or modify      *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation; either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * This program 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 General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************/
 
 #include "parsesession.h"
 
 #include "phpast.h"
 
 #include "kdev-pg-memory-pool.h"
 #include "kdev-pg-token-stream.h"
 #include "parserdebug.h"
 
 #include <QFile>
 #include <QTextCodec>
 
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
+#include <language/editor/documentrange.h>
 
 namespace Php
 {
 
 ParseSession::ParseSession()
         :   m_debug(false),
         m_pool(new KDevPG::MemoryPool()),
         m_tokenStream(new TokenStream())
 {
 }
 ParseSession::~ParseSession()
 {
     delete m_pool;
     delete m_tokenStream;
 }
 
 QString ParseSession::contents() const
 {
     return m_contents;
 }
 
 void ParseSession::setContents(const QString& contents)
 {
     m_contents = contents;
 }
 
 void ParseSession::setCurrentDocument(const KDevelop::IndexedString& filename)
 {
     m_currentDocument = filename;
 }
 
 KDevelop::IndexedString ParseSession::currentDocument() const
 {
     return m_currentDocument;
 }
 
 bool ParseSession::readFile(const QString& filename, const char* codec)
 {
     m_currentDocument = KDevelop::IndexedString(filename);
 
     QFile f(filename);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         KDevelop::ProblemPointer p(new KDevelop::Problem());
         p->setSource(KDevelop::IProblem::Disk);
         p->setDescription(i18n("Could not open file '%1'", filename));
         switch (f.error()) {
         case QFile::ReadError:
             p->setExplanation(i18n("File could not be read from."));
             break;
         case QFile::OpenError:
             p->setExplanation(i18n("File could not be opened."));
             break;
         case QFile::PermissionsError:
             p->setExplanation(i18n("File permissions prevent opening for read."));
             break;
         default:
             break;
         }
         p->setFinalLocation(KDevelop::DocumentRange(m_currentDocument, KTextEditor::Range()));
         m_problems << p;
         qCWarning(PARSER) << "Could not open file" << filename;
         return false;
     }
     QTextStream s(&f);
     if (codec)
         s.setCodec(QTextCodec::codecForName(codec));
     m_contents = s.readAll();
     return true;
 }
 
 void ParseSession::setDebug(bool debug)
 {
     m_debug = debug;
 }
 
 TokenStream* ParseSession::tokenStream() const
 {
     return m_tokenStream;
 }
 
 Parser* ParseSession::createParser(int initialState)
 {
     Parser* parser = new Parser;
     parser->setTokenStream(m_tokenStream);
     parser->setMemoryPool(m_pool);
     parser->setDebug(m_debug);
     parser->setCurrentDocument(m_currentDocument);
     parser->setTodoMarkers(KDevelop::ICore::self()->languageController()->completionSettings()->todoMarkerWords());
 
     parser->tokenize(m_contents, initialState);
     return parser;
 }
 
 bool ParseSession::parse(Php::StartAst** ast)
 {
     Parser* parser = createParser();
     StartAst* phpAst;
     bool matched = parser->parseStart(&phpAst);
     if (matched) {
         qCDebug(PARSER) << "Successfully parsed";
         *ast = phpAst;
     } else {
         *ast = nullptr;
         parser->expectedSymbol(AstNode::StartKind, QStringLiteral("start"));
         qCDebug(PARSER) << "Couldn't parse content";
     }
     m_problems << parser->problems();
     delete parser;
     return matched;
 }
 
 KDevelop::CursorInRevision ParseSession::positionAt(qint64 offset) const
 {
     qint64 line, column;
     m_tokenStream->locationTable()->positionAt(offset, &line, &column);
     return KDevelop::CursorInRevision(line, column);
 }
 
 QString ParseSession::symbol(qint64 token) const
 {
     const TokenStream::Token& tok = m_tokenStream->at(token);
     return m_contents.mid(tok.begin, tok.end - tok.begin + 1);
 }
 
 QString ParseSession::symbol(AstNode* node) const
 {
     const TokenStream::Token& startTok = m_tokenStream->at(node->startToken);
     const TokenStream::Token& endTok = m_tokenStream->at(node->endToken);
     return m_contents.mid(startTok.begin, endTok.end - startTok.begin + 1);
 }
 
 QString ParseSession::docComment(qint64 token) const
 {
     const TokenStream::Token& tok = m_tokenStream->at(token);
     if (!tok.docCommentEnd) return QString();
     return m_contents.mid(tok.docCommentBegin, tok.docCommentEnd - tok.docCommentBegin + 1);
 }
 
 QList<KDevelop::ProblemPointer> ParseSession::problems()
 {
     return m_problems;
 }
 
 }
diff --git a/parser/php.g b/parser/php.g
index 7074302..33f2af1 100644
--- a/parser/php.g
+++ b/parser/php.g
@@ -1,1207 +1,1207 @@
 -------------------------------------------------------------------------------
 -- Copyright (c) 2008 Niko Sams <niko.sams@gmail.com>
 --
 -- This grammar is free software; you can redistribute it and/or
 -- modify it under the terms of the GNU Library General Public
 -- License as published by the Free Software Foundation; either
 -- version 2 of the License, or (at your option) any later version.
 --
 -- This grammar 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
 -- Lesser 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.
 -----------------------------------------------------------
 
 
 -----------------------------------------------------------
 -- Grammar for PHP 5.2
 -- Modelled after the Zend Grammar shipped with PHP5.2
 -- source, the PHP Language Reference documentation,
 -- and parts taken from KDevelop Java Grammar
 -----------------------------------------------------------
 
 -- 4 first/first conflicts:
 --  - var_expression: variable vs. varExpressionNormal
 --    no problem because of ifs that allow always just one rule
 --  - classNameReference: STRING vs. staticMember (foo vs. foo::$bar)
 --    resolved by LA()
 --  - encapsVar: STRING_VARNAME LBRACKET vs. expr (expr allows STRING_VARNAME too - but not LBRACKET)
 --    resolved by LA()
 --  - constantOrClassConst: constant vs. class constant (FOO v.s Cls::FOO)
 --    resolved by LA() (could be avoided, but the Ast is much cleaner that way)
 -- 1 first/follow conflicts:
 --  - elseifList: dangling-else conflict - should be ok
 
 -- TODO: (post 1.0.0 release)
 --  1) decrease memory consumption
 --    1.1) use quint32 instead of qint64 for end/start tokens
 --    1.2) investigate whether using a map/hash for the ducontext member of all
 --         ast nodes gives a significant memory decrease while not hampering performance
 --    1.3) investigate how unions could be used for exclusive AST node members
 --    1.4) see whether we can always use the expression lists instead of both
 --         single member pointer and list of members, esp. in expressions
 --  2) better cope with invalid code, have at least a partial AST
 --  3) investigate whether expanding the visitor lookup to a
 --     (albeit huge) switch() in KDev-PG-Qt gives a significant performance gain
 --     I have the gut feeling that the current lookup takes unnecessary much time
 --
 
 ------------------------------------------------------------
 -- Forward declaration in phpast.h
 ------------------------------------------------------------
 
 [:
 
 #include <QtCore/QRegularExpression>
 
 namespace KDevelop
 {
     class DUContext;
 }
 
 :]
 
 ------------------------------------------------------------
 -- Additional includes for the parser
 ------------------------------------------------------------
 
 %parser_declaration_header "tokenstream.h"
 %parser_declaration_header "QtCore/QString"
 %parser_declaration_header "language/duchain/problem.h"
 %parser_declaration_header "phplexer.h"
 
 %parser_bits_header "parserdebug.h"
 
 ------------------------------------------------------------
 -- Export macro to use the parser in a shared lib
 ------------------------------------------------------------
 %export_macro "KDEVPHPPARSER_EXPORT"
 %export_macro_header "parserexport.h"
 
 
 ------------------------------------------------------------
 -- Enumeration types for additional AST members,
 -- in the global "Php" namespace
 ------------------------------------------------------------
 %namespace
 [:
     class Lexer;
 
     enum ModifierFlags {
         ModifierPrivate      = 1,
         ModifierPublic       = 1 << 1,
         ModifierProtected    = 1 << 2,
         ModifierStatic       = 1 << 3,
         ModifierFinal        = 1 << 4,
         ModifierAbstract     = 1 << 5
     };
 
     enum ClassModifier {
         NormalClass,
         AbstractClass,
         FinalClass
     };
 
     enum ScalarTypes {
         ScalarTypeInt,
         ScalarTypeFloat,
         ScalarTypeString
     };
 
     enum CastType {
         CastInt,
         CastDouble,
         CastString,
         CastArray,
         CastObject,
         CastBool,
         CastUnset
     };
 
     enum OperationType {
         OperationPlus = 1,
         OperationMinus,
         OperationConcat,
         OperationMul,
         OperationDiv,
         OperationExp,
         OperationMod,
         OperationAnd,
         OperationOr,
         OperationXor,
         OperationSl,
         OperationSr
     };
 :]
 
 ------------------------------------------------------------
 -- Ast Node class members
 ------------------------------------------------------------
 %ast_extra_members
 [:
   KDevelop::DUContext* ducontext;
 :]
 
 ------------------------------------------------------------
 -- Parser class members
 ------------------------------------------------------------
 
 %parserclass (public declaration)
 [:
   /**
    * Transform the raw input into tokens.
    * When this method returns, the parser's token stream has been filled
    * and any parse*() method can be called.
    */
   void tokenize(const QString& contents, int initialState = Lexer::HtmlState);
 
   enum ProblemType {
       Error,
       Warning,
       Info,
       Todo
   };
   KDevelop::ProblemPointer reportProblem( Parser::ProblemType type, const QString& message, int tokenOffset = -1 );
   QList<KDevelop::ProblemPointer> problems() {
       return m_problems;
   }
   QString tokenText(qint64 begin, qint64 end);
   void setDebug(bool debug);
   void setCurrentDocument(KDevelop::IndexedString url);
   void setTodoMarkers(const QStringList& markers);
   void extractTodosFromComment(const QString& comment, qint64 offset);
 
     enum InitialLexerState {
         HtmlState = 0,
         DefaultState = 1
     };
 
 :]
 
 %parserclass (private declaration)
 [:
     enum VarExpressionState {
         Normal,
         OnlyVariable,
         OnlyNewObject
     };
     QString m_contents;
     bool m_debug;
     KDevelop::IndexedString m_currentDocument;
     QList<KDevelop::ProblemPointer> m_problems;
 
     struct ParserState {
         VarExpressionState varExpressionState;
         bool varExpressionIsVariable;
     };
     ParserState m_state;
 
     QRegularExpression m_todoMarkers;
 :]
 
 %parserclass (constructor)
 [:
     m_state.varExpressionState = Normal;
     m_state.varExpressionIsVariable = false;
 :]
 
 
 %token_stream TokenStream ;;
 
 -----------------------------------------------------------
 -- List of defined tokens
 -----------------------------------------------------------
 
 -- keywords:
 %token ABSTRACT ("abstract"), BREAK ("break"), CASE ("case"), CATCH ("catch"),
        CLASS ("class"), CONST ("const"), CONTINUE ("continue"),
        DEFAULT ("default"), DO ("do"), ELSE ("else"), EXTENDS ("extends"),
        FINAL ("final"), FOR ("for"), IF ("if"),
        IMPLEMENTS ("implements"), INSTANCEOF ("instanceof"), INTERFACE ("interface"),
        NEW ("new"), PRIVATE ("private"), PROTECTED ("protected"), PUBLIC ("public"),
        RETURN ("return"), STATIC ("static"), SWITCH ("switch"), THROW ("throw"),
        TRY ("try"), WHILE ("while"), ECHO ("echo"), PRINT ("print"), FINALLY ("finally"),
        CLONE ("clone"), EXIT ("exit"), ELSEIF ("elseif"), ENDIF ("endif"),
        ENDWHILE ("endwhile"), ENDFOR ("endfor"), FOREACH ("foreach"), ENDFOREACH ("endforeach"),
        DECLARE ("declare"), ENDDECLARE ("enddeclare"), AS ("as"), ENDSWITCH ("endswitch"),
        FUNCTION ("function"), USE ("use"), GLOBAL ("global"), VAR ("var "), UNSET ("unset"),
        ISSET ("isset"), EMPTY ("empty"), HALT_COMPILER ("halt compiler"),
        DOUBLE_ARROW ("=>"), LIST ("list"), ARRAY ("array"), CLASS_C ("__CLASS__"),
        METHOD_C ("__METHOD__"), FUNC_C ("__FUNCTION__"), LINE ("__LINE__"),
        FILE ("__FILE__"), COMMENT ("comment"), DOC_COMMENT ("doc comment"),  PAAMAYIM_NEKUDOTAYIM ("::"),
        INCLUDE ("include"), INCLUDE_ONCE ("include_once"), EVAL ("eval"), REQUIRE ("require"),
        REQUIRE_ONCE ("require_once"), NAMESPACE ("namespace"), NAMESPACE_C("__NAMESPACE__"), USE("use"),
        GOTO ("goto"), TRAIT ("trait"), INSTEADOF ("insteadof"), CALLABLE ("callable") ;;
 
 -- casts:
 %token INT_CAST ("int cast"), DOUBLE_CAST ("double cast"), STRING_CAST ("string cast"),
        ARRAY_CAST ("array cast"), OBJECT_CAST ("object cast"), BOOL_CAST ("bool cast"),
        UNSET_CAST ("unset cast") ;;
 
 -- seperators:
 %token SEMICOLON (";"), DOUBLE_QUOTE ("\""), LBRACKET ("["),
        RBRACKET ("]"),
        LPAREN ("("), RPAREN (")"), LBRACE ("{"), RBRACE ("}"),
        COMMA (","), AT ("@"),
        CURLY_OPEN ("curly open"), -- { in "{$foo}"; not the same as LBRACE
        DOLLAR_OPEN_CURLY_BRACES ("${"),
        START_HEREDOC ("start heredoc"), END_HEREDOC ("end heredoc"),
        BACKTICK ("`"), BACKSLASH ("\\"),
        START_NOWDOC("start nowdoc"), END_NOWDOC("end nowdoc") ;;
 
 -- operators:
 %token IS_EQUAL ("=="), IS_NOT_EQUAL ("!="), IS_IDENTICAL ("==="),
        IS_NOT_IDENTICAL ("!=="), IS_SMALLER ("<"), IS_GREATER (">"),
        IS_SMALLER_OR_EQUAL ("<="), IS_GREATER_OR_EQUAL (">="),
        BOOLEAN_OR ("||"), BOOLEAN_AND ("&&"), ASSIGN ("="), EXP_ASSIGN("**="),
        PLUS_ASSIGN ("+="), MINUS_ASSIGN ("-="), MUL_ASSIGN ("*="), DIV_ASSIGN ("/="),
        CONCAT_ASSIGN (".="), MOD_ASSIGN ("%="), AND_ASSIGN ("&="), OR_ASSIGN ("|="),
        XOR_ASSIGN ("^="), SL_ASSIGN ("<<="), SR_ASSIGN (">>="), OBJECT_OPERATOR ("->"),
        PLUS ("+"), MINUS("-"), CONCAT("."),
        INC ("++"), DEC ("--"), BANG ("!"), QUESTION ("?"), COLON (":"),
        BIT_AND ("&"), BIT_OR("|"), BIT_XOR ("^"),
        SL ("<<"), SR (">>"), MUL("*"), DIV("/"), MOD ("%"),
        TILDE ("~"), DOLLAR ("$"), EXP ("**"),
        LOGICAL_OR ("logical or"), LOGICAL_AND ("logical and"), LOGICAL_XOR ("logical xor") ;;
 
 -- literals and identifiers:
 %token INLINE_HTML ("inline html"), WHITESPACE ("whitespace"),
        CONSTANT_ENCAPSED_STRING ("constant encapsed string"),
        VARIABLE ("variable"), ENCAPSED_AND_WHITESPACE ("encapsed and whitespace"),
        DNUMBER ("double number"), LNUMBER ("long number"),
        NUM_STRING ("num string"), STRING ("string"),
        STRING_VARNAME ("string varname") ;; -- when in "${varname}"
 
 -- open/close tags
 %token OPEN_TAG ("<?"), CLOSE_TAG ("?>"), OPEN_TAG_WITH_ECHO ("<?=");;
 
 -- token that makes the parser fail in any case:
 %token INVALID ("invalid token") ;;
 
 
 
 -- The actual grammar starts here.
 
 #statements=outerTopStatement*
 -> start ;;
 
   namespaceDeclaration=namespaceDeclarationStatement
   | statement=topStatement
 -> outerTopStatement ;;
 
 -- first/first conflict for FUNCTION
    (?[: (LA(1).kind == Token_FUNCTION && ((LA(2).kind == Token_BIT_AND && LA(3).kind == Token_LPAREN)
             || LA(2).kind == Token_LPAREN))
         || LA(1).kind != Token_FUNCTION :]
     statement=statement )
   | functionDeclaration=functionDeclarationStatement
   | classDeclaration=classDeclarationStatement
   | traitDeclaration=traitDeclarationStatement
   | interfaceDeclaration=interfaceDeclarationStatement
   | HALT_COMPILER LPAREN RPAREN SEMICOLON -- Lexer stops allready
 -> topStatement ;;
 
 [: bool reported = false; while ( true ) { :]
     try/recover(#statements=topStatement)*
 [: if (yytoken != Token_RBRACE && yytoken != Token_EOF && yytoken != Token_CLOSE_TAG
        && yytoken != Token_ELSEIF && yytoken != Token_ELSE
        && yytoken != Token_ENDIF && yytoken != Token_ENDFOREACH && yytoken != Token_ENDFOR
        && yytoken != Token_ENDWHILE && yytoken != Token_ENDSWITCH && yytoken != Token_ENDDECLARE
        && yytoken != Token_CASE && yytoken != Token_DEFAULT) {
         if (!reported) {
             qint64 index = tokenStream->index() - 1;
             Token &token = tokenStream->at(index);
             QString tokenValue = token.kind != 0 ? tokenText(token.begin, token.end) : QStringLiteral("EOF");
             reportProblem(Error, QStringLiteral("Unexpected token \"%1\".").arg(tokenValue));
             reported = true;
         }
         yylex();
    } else {
         break;
    }
 } :]
 -> innerStatementList ;;
 
 --Operator Precedence, from PHP Manual
 --left    or
 --left    xor
 --left    and
 --right   print
 --right   = += -= *= /= .= %= &= |= ^= <<= >>=    assignment
 --left    ? : ternary
 --left    ||  logical
 --left    &&  logical
 --left    |   bitwise
 --left    ^   bitwise
 --left    &   bitwise and references
 --non-associative == != === !==   comparison
 --non-associative < <= > >=   comparison
 --left    << >>   bitwise
 --left    + - .   arithmetic and string
 --left    * / %   arithmetic
 --non-associative ! ~ - (int) (float) (string) (array) (object) @ types
 --non-associative ++ --   increment/decrement
 --left    [   array()
 --non-associative new new
 
   expression=logicalOrExpression
 -> expr ;;
 
    #expression=logicalXorExpression @ LOGICAL_OR
 -> logicalOrExpression ;;
 
    #expression=logicalAndExpression @ LOGICAL_XOR
 -> logicalXorExpression ;;
 
    #expression=printExpression @ LOGICAL_AND
 -> logicalAndExpression ;;
 
   (print=PRINT*) expression=assignmentExpression
 -> printExpression ;;
 
 -- leftside must me a variable, we check afterwards if it was a variable and
 -- if not we report an error
 0 --needed for line below
 [: m_state.varExpressionIsVariable = false; :] --reset flag
 expression=conditionalExpression
 (
   assignmentExpressionEqual=assignmentExpressionEqual | (
      (
         PLUS_ASSIGN   [: (*yynode)->operation = OperationPlus; :]
       | MINUS_ASSIGN  [: (*yynode)->operation = OperationMinus; :]
       | MUL_ASSIGN    [: (*yynode)->operation = OperationMul; :]
       | EXP_ASSIGN    [: (*yynode)->operation = OperationExp; :]
       | DIV_ASSIGN    [: (*yynode)->operation = OperationDiv; :]
       | CONCAT_ASSIGN [: (*yynode)->operation = OperationConcat; :]
       | MOD_ASSIGN    [: (*yynode)->operation = OperationMod; :]
       | AND_ASSIGN    [: (*yynode)->operation = OperationAnd; :]
       | OR_ASSIGN     [: (*yynode)->operation = OperationOr; :]
       | XOR_ASSIGN    [: (*yynode)->operation = OperationXor; :]
       | SL_ASSIGN     [: (*yynode)->operation = OperationSl; :]
       | SR_ASSIGN     [: (*yynode)->operation = OperationSr; :]
      )
      assignmentExpressionCheckIfVariable
      assignmentExpression=assignmentExpression)
    | 0)
 -> assignmentExpression [
      member variable operation: OperationType;
 ];;
 
 --=& is special:
   -- $foo =& $var; is allowed but not $foo =& 'static';
   -- $foo =& new bar(); is allowed too but deprecated and reports a warning
   --we set a flag (varExpressionState) with that var_expression accepts only valid parts
   --this is done in such a strage way because we need the full expression to allow
   --things like $foo =& $bar || e();
 ASSIGN
     assignmentExpressionCheckIfVariable --as in assignmentExpression
     (BIT_AND [: if (yytoken == Token_NEW) {
                 reportProblem(Warning, QStringLiteral("=& new foo() is deprecated"), -2);
                 m_state.varExpressionState = OnlyNewObject;
               } else {
                 m_state.varExpressionState = OnlyVariable;
               }:]
      | 0) assignmentExpression=assignmentExpression [: m_state.varExpressionState = Normal; :]
 -> assignmentExpressionEqual ;;
 
 
 -- check if var_expression was a variable, if not report an error
 -- varExpressionIsVariable is set in var_expression
 0 --to allow cpp-code
 [:
     if (!m_state.varExpressionIsVariable) {
         reportProblem(Error, QStringLiteral("Left side is not a variable"));
         return false;
     }
 :]
 -> assignmentExpressionCheckIfVariable ;;
 
 expression=booleanOrExpression
    (  QUESTION (ifExpression=expr|0)
       COLON    elseExpression=conditionalExpression
     | 0
    )
 -> conditionalExpression ;;
 
   #expression=booleanAndExpression @ BOOLEAN_OR
 -> booleanOrExpression ;;
 
    #expression=bitOrExpression @ BOOLEAN_AND
 -> booleanAndExpression ;;
 
    #expression=bitXorExpression @ BIT_OR
 -> bitOrExpression ;;
 
    #expression=bitAndExpression @ BIT_XOR
 -> bitXorExpression ;;
 
    #expression=equalityExpression @ BIT_AND
 -> bitAndExpression ;;
 
    expression=relationalExpression
    (#additionalExpression=equalityExpressionRest)*
 -> equalityExpression ;;
 
    (  IS_EQUAL | IS_NOT_EQUAL | IS_IDENTICAL | IS_NOT_IDENTICAL )
    expression=relationalExpression
 -> equalityExpressionRest ;;
 
 
    expression=shiftExpression
    (  (#additionalExpression=relationalExpressionRest)+
       --instanceof as in java.g (correct??)
     | INSTANCEOF instanceofType=classNameReference
     | 0
    )
 -> relationalExpression ;;
 
    ( IS_SMALLER | IS_GREATER | IS_SMALLER_OR_EQUAL | IS_GREATER_OR_EQUAL )
    expression=shiftExpression
 -> relationalExpressionRest ;;
 
 
    expression=additiveExpression
    (#additionalExpression=shiftExpressionRest)*
 -> shiftExpression ;;
 
    ( SL | SR )
    expression=additiveExpression
 -> shiftExpressionRest ;;
 
 
    expression=multiplicativeExpression
    (#additionalExpression=additiveExpressionRest)*
 -> additiveExpression ;;
 
    (
        PLUS   [: (*yynode)->operation = OperationPlus; :]
      | MINUS  [: (*yynode)->operation = OperationMinus; :]
      | CONCAT [: (*yynode)->operation = OperationConcat; :]
    )
    expression=multiplicativeExpression
 -> additiveExpressionRest [
      member variable operation: OperationType;
 ];;
 
 
    expression=unaryExpression
    (#additionalExpression=multiplicativeExpressionRest)*
 -> multiplicativeExpression ;;
 
    (
        MUL [: (*yynode)->operation = OperationMul; :]
      | DIV [: (*yynode)->operation = OperationDiv; :]
      | EXP [: (*yynode)->operation = OperationExp; :]
      | MOD [: (*yynode)->operation = OperationMod; :]
    )
    expression=unaryExpression
 -> multiplicativeExpressionRest [
      member variable operation: OperationType;
 ];;
 
  (
     MINUS unaryExpression=unaryExpression
   | PLUS  unaryExpression=unaryExpression
   | BANG unaryExpression=unaryExpression
   | TILDE unaryExpression=unaryExpression
   | INT_CAST unaryExpression=unaryExpression    [: (*yynode)->castType = CastInt; :]
   | DOUBLE_CAST unaryExpression=unaryExpression [: (*yynode)->castType = CastDouble; :]
   | STRING_CAST unaryExpression=unaryExpression [: (*yynode)->castType = CastString; :]
   | ARRAY_CAST unaryExpression=unaryExpression  [: (*yynode)->castType = CastArray; :]
   | OBJECT_CAST unaryExpression=unaryExpression [: (*yynode)->castType = CastObject; :]
   | BOOL_CAST unaryExpression=unaryExpression   [: (*yynode)->castType = CastBool; :]
   | UNSET_CAST unaryExpression=unaryExpression  [: (*yynode)->castType = CastUnset; :]
   | AT unaryExpression=unaryExpression
   | LIST LPAREN assignmentList=assignmentList RPAREN ASSIGN unaryExpression=unaryExpression
   | EXIT (LPAREN (expression=expr | 0) RPAREN | 0)
   | EVAL LPAREN expression=expr RPAREN
   | INCLUDE includeExpression=unaryExpression
   | INCLUDE_ONCE includeExpression=unaryExpression
   | REQUIRE includeExpression=unaryExpression
   | REQUIRE_ONCE includeExpression=unaryExpression
 
   | unaryExpressionNotPlusminus=unaryExpressionNotPlusminus
  )
 -> unaryExpression [
      member variable castType: CastType;
 ];;
 
     (#prefixOperator=postprefixOperator)*
     varExpression=varExpression
     (#postfixOperator=postprefixOperator)*
 -> unaryExpressionNotPlusminus ;;
 
    op=INC | op=DEC
 -> postprefixOperator ;;
 
 --first/first conflict - no problem because of ifs
     ?[: m_state.varExpressionState == OnlyVariable :] 0 [: m_state.varExpressionState = Normal; :] variable=variable
   | ?[: m_state.varExpressionState == OnlyNewObject :] 0 [: m_state.varExpressionState = Normal; :] newObject=varExpressionNewObject
   | varExpressionNormal=varExpressionNormal
   | varExpressionArray=varExpressionArray arrayIndex=arrayIndexSpecifier*
 -> varExpression ;;
 
     (?[: LA(1).kind == Token_LPAREN && LA(2).kind == Token_FUNCTION && LA(3).kind == Token_LPAREN :] iife=iifeSyntax )
   | LPAREN try/rollback (newObject=varExpressionNewObject RPAREN (#variableProperties=instantiationAccess*))
     catch (expression=expr RPAREN)
   | BACKTICK encapsList=encapsList BACKTICK
   --try/rollback resolves conflict scalar vs. staticMember (foo::bar vs. foo::$bar)
   --varExpressionIsVariable flag is needed for assignmentExpression
   | try/rollback (variable=variable [: m_state.varExpressionIsVariable = true; :])
     catch (scalar=scalar)
   | ISSET LPAREN (#issetVariable=variable @ COMMA) RPAREN
   | EMPTY LPAREN emptyVarialbe=variable RPAREN
   | newObject=varExpressionNewObject
   | CLONE cloneCar=varExpressionNormal
   | closure=closure
 -> varExpressionNormal ;;
 
     ARRAY LPAREN
         (#arrayValues=arrayPairValue
              -- break because array(1,) is allowed (solves FIRST/FOLLOW conflict)
           @ (COMMA [: if (yytoken == Token_RPAREN) { break; } :] ) | 0)
     RPAREN
   | LBRACKET
         (#arrayValues=arrayPairValue
              -- break because [1,] is allowed (solves FIRST/FOLLOW conflict)
           @ (COMMA [: if (yytoken == Token_RBRACKET) { break; } :] ) | 0)
     RBRACKET
 -> varExpressionArray ;;
 
 -- http://wiki.php.net/rfc/closures
     FUNCTION (isRef=BIT_AND|0) LPAREN parameters=parameterList RPAREN
         ( USE LPAREN lexicalVars=lexicalVarList RPAREN | 0)
         LBRACE try/recover(functionBody=innerStatementList) RBRACE
 -> closure ;;
 
     LPAREN try/rollback (closure=closure RPAREN LPAREN parameterList=functionCallParameterList RPAREN)
     catch (expression=expr RPAREN)
 -> iifeSyntax ;;
 
   (#lexicalVars=lexicalVar @ COMMA) | 0 [: reportProblem(Error, QStringLiteral("Use list of closure must not be empty.")); :]
 -> lexicalVarList ;;
 
   (isRef=BIT_AND | 0) variable=variableIdentifier
 -> lexicalVar ;;
 
     NEW className=classNameReference ctor=ctorArguments
 -> varExpressionNewObject ;;
 
     LPAREN parameterList=functionCallParameterList RPAREN
   | 0
 -> ctorArguments ;;
 
     #parameters=functionCallParameterListElement @ COMMA | 0
 -> functionCallParameterList ;;
 
     (BIT_AND variable=variable) | expr=expr
 -> functionCallParameterListElement ;;
 
     #element=assignmentListElement @COMMA
 -> assignmentList ;;
 
     variable=variable
   | LIST LPAREN assignmentList=assignmentList RPAREN
   | 0
 -> assignmentListElement ;;
 
     expr=expr (DOUBLE_ARROW (exprValue=expr | BIT_AND varValue=variable) | 0)
   | BIT_AND variable=variable
 -> arrayPairValue ;;
 
    var=baseVariableWithFunctionCalls (#variableProperties=variableObjectProperty*)
 -> variable ;;
 
     OBJECT_OPERATOR
   | PAAMAYIM_NEKUDOTAYIM
 -> objectOperator ;;
 
     ( ?[: LA(1).kind == Token_DOLLAR:] LBRACE variable=variable RBRACE | objectProperty=objectProperty )
     (isFunctionCall=LPAREN parameterList=functionCallParameterList RPAREN arrayIndex=arrayIndexSpecifier* | 0)
 -> variableProperty ;;
 
    objectOperator variableProperty=variableProperty
 -> variableObjectProperty ;;
 
    OBJECT_OPERATOR variableProperty=variableProperty
 -> instantiationAccess ;;
 
    --Conflict
    --   foo::$bar[0] (=baseVariable-staticMember)
    --vs.foo::$bar[0](); (=static function call)
    try/rollback (functionCall=functionCall arrayIndex=arrayIndexSpecifier*)
    catch (baseVariable=baseVariable)
 -> baseVariableWithFunctionCalls ;;
 
    LBRACKET (expr=expr | 0) RBRACKET
 -> arrayIndexSpecifier ;;
 
    LBRACKET (expr=expr) RBRACKET
 -> stringIndexSpecifier ;;
 
     stringFunctionNameOrClass=namespacedIdentifier (
         LPAREN stringParameterList=functionCallParameterList RPAREN
       | PAAMAYIM_NEKUDOTAYIM
         (
             stringFunctionName=identifier LPAREN stringParameterList=functionCallParameterList RPAREN
             | varFunctionName=variableWithoutObjects LPAREN stringParameterList=functionCallParameterList RPAREN
             | LBRACE (expr=expr) RBRACE LPAREN stringParameterList=functionCallParameterList RPAREN
         )
     )
   | varFunctionName=variableWithoutObjects LPAREN varParameterList=functionCallParameterList RPAREN
 -> functionCall ;;
 
     var=compoundVariableWithSimpleIndirectReference #offsetItems=dimListItem*
   | staticMember=staticMember
 -> baseVariable ;;
 
     variable=variableIdentifier
   | DOLLAR LBRACE expr=expr RBRACE
 -> compoundVariable ;;
 
   ( DOLLAR ( DOLLAR+ | 0 ) ( indirectVariable=variableIdentifier | LBRACE expr=expr RBRACE ) | variable=variableIdentifier )
 -> compoundVariableWithSimpleIndirectReference ;;
 
     className=namespacedIdentifier PAAMAYIM_NEKUDOTAYIM variable=variableWithoutObjects
 -> staticMember ;;
 
     LBRACE try/recover(statements=innerStatementList) RBRACE
   | IF LPAREN ifExpr=expr RPAREN
       (   COLON statements=innerStatementList newElseifList newElseSingle ENDIF semicolonOrCloseTag
         | ifStatement=statement elseifList=elseifList elseSingle=elseSingle
       )
   | WHILE LPAREN whileExpr=expr RPAREN whileStatement=whileStatement
   | FOR LPAREN forExpr1=forExpr SEMICOLON forExpr2=forExpr
     SEMICOLON forExpr3=forExpr RPAREN forStatement=forStatement
   | SWITCH LPAREN swtichExpr=expr RPAREN switchCaseList=switchCaseList
 
   | FOREACH LPAREN (
             -- allow $var as &$i and not expr() as &$i
         try/rollback(foreachVar=variable AS foreachVarAsVar=foreachVariable)
         catch(foreachExpr=expr AS foreachExprAsVar=variable))
         (DOUBLE_ARROW foreachVariable=foreachVariable | 0) RPAREN
         foreachStatement=foreachStatement
   | DECLARE LPAREN declareItem=declareItem @ COMMA RPAREN declareStatement
   | SEMICOLON     -- empty statement
   | TRY  LBRACE try/recover(statements=innerStatementList) RBRACE
     #catches=catchItem*
     (FINALLY LBRACE finallyBody=innerStatementList RBRACE | 0)
   | UNSET LPAREN #unsetVariables=variable @ COMMA RPAREN semicolonOrCloseTag
   -- fix first/follow with goto target
   | ( ?[: LA(1).kind != Token_STRING || LA(2).kind != Token_COLON :] expr=expr semicolonOrCloseTag )
   | DO doStatement=statement WHILE LPAREN whileExpr=expr RPAREN semicolonOrCloseTag
   | BREAK (breakExpr=expr | 0) semicolonOrCloseTag
   | CONTINUE (continueExpr=expr | 0) semicolonOrCloseTag
   | RETURN (returnExpr=expr | 0) semicolonOrCloseTag
   | GLOBAL #globalVars=globalVar @ COMMA semicolonOrCloseTag
   | STATIC #staticVars=staticVar @ COMMA semicolonOrCloseTag
   | ECHO #echoExprs=expr @ COMMA semicolonOrCloseTag
   | THROW throwExpr=expr semicolonOrCloseTag
   -- throws error in zend parser, so ignored | USE use_filename  semicolonOrCloseTag
 
   | CLOSE_TAG
   | OPEN_TAG
   | OPEN_TAG_WITH_ECHO expr=expr semicolonOrCloseTag
   | INLINE_HTML
   | CONST #consts=constantDeclaration @ COMMA SEMICOLON
   | USE #useNamespace=useNamespace @ COMMA SEMICOLON
   | GOTO gotoLabel=STRING SEMICOLON
   | gotoTarget=STRING COLON
 -> statement ;;
 
     identifier=namespacedIdentifier (AS aliasIdentifier=identifier | 0)
 -> useNamespace ;;
 
     identifier=identifier ASSIGN scalar=staticScalar
 -> constantDeclaration ;;
 
    SEMICOLON | CLOSE_TAG
 -> semicolonOrCloseTag ;;
 
     LBRACE (SEMICOLON | 0) try/recover(caseList=caseList) RBRACE
   | COLON (SEMICOLON | 0) caseList=caseList ENDSWITCH semicolonOrCloseTag
 -> switchCaseList ;;
 
     #caseItems=case_item*
 -> caseList ;;
 
     CASE expr=expr (COLON | SEMICOLON) statements=innerStatementList
   | def=DEFAULT (COLON | SEMICOLON) statements=innerStatementList
 -> case_item ;;
 
     CATCH LPAREN catchClass=namespacedIdentifier var=variableIdentifier RPAREN
     LBRACE try/recover(statements=innerStatementList) RBRACE
 -> catchItem ;;
 
     statement=statement
   | COLON statements=innerStatementList ENDDECLARE semicolonOrCloseTag
 -> declareStatement ;;
 
     STRING ASSIGN scalar=staticScalar
 -> declareItem ;;
 
     (BIT_AND | 0) variable=variable
 -> foreachVariable ;;
 
     statement=statement
   | COLON statements=innerStatementList ENDFOREACH semicolonOrCloseTag
 -> foreachStatement ;;
 
   var=variableIdentifier (ASSIGN value=staticScalar | 0)
 -> staticVar ;;
 
     var=variableIdentifier
   | DOLLAR (dollarVar=variable | LBRACE expr=expr RBRACE)
 -> globalVar ;;
 
     #exprs=expr @ COMMA | 0
 -> forExpr ;;
 
     statement=statement
   | COLON statements=innerStatementList ENDFOR semicolonOrCloseTag
 -> forStatement ;;
 
     statement=statement
   | COLON statements=innerStatementList ENDWHILE semicolonOrCloseTag
 -> whileStatement ;;
 
     --first/follow conflict; todo check if this is a problem
     #elseifListItem=elseifListItem*
 -> elseifList ;;
 
     ELSEIF LPAREN expr=expr RPAREN statement=statement
 -> elseifListItem ;;
 
     ELSE statement=statement | 0
 -> elseSingle ;;
 
     #newElseifListItem=newelseifListItem*
 -> newElseifList ;;
 
     ELSEIF LPAREN expr=expr RPAREN COLON statements=innerStatementList
 -> newelseifListItem ;;
 
     ELSE COLON statements=innerStatementList | 0
 -> newElseSingle ;;
 
 --TODO     --resolve STRING vs. staticMember conflict
 --     ?[: LA(2).kind != Token_PAAMAYIM_NEKUDOTAYIM :]
     identifier=namespacedIdentifier
   | staticIdentifier = STATIC
   | dynamicClassNameReference=dynamicClassNameReference
 -> classNameReference ;;
 
     baseVariable=baseVariable (OBJECT_OPERATOR objectProperty=objectProperty
                           properties=dynamicClassNameVariableProperties | 0)
 -> dynamicClassNameReference ;;
 
     #properties=dynamicClassNameVariableProperty*
 -> dynamicClassNameVariableProperties ;;
 
     OBJECT_OPERATOR property=objectProperty
 -> dynamicClassNameVariableProperty ;;
 
     objectDimList=objectDimList
   | variableWithoutObjects=variableWithoutObjects
 -> objectProperty ;;
 
     variableName=variableName #offsetItems=dimListItem*
 -> objectDimList ;;
 
   variable=compoundVariableWithSimpleIndirectReference #offsetItems=dimListItem*
 -> variableWithoutObjects ;;
 
 arrayIndex=arrayIndexSpecifier | LBRACE expr=expr RBRACE
 -> dimListItem ;;
 
     name=identifier
   | LBRACE expr=expr RBRACE
 -> variableName ;;
 
     commonScalar=commonScalar
   | constantOrClassConst=constantOrClassConst
   | varname=STRING_VARNAME
   | DOUBLE_QUOTE encapsList=encapsList DOUBLE_QUOTE stringIndex=stringIndexSpecifier*
   | START_HEREDOC encapsList=encapsList END_HEREDOC
 -> scalar ;;
 
   constant=namespacedIdentifier
   ( PAAMAYIM_NEKUDOTAYIM classConstant=classConstant | 0 )
 -> constantOrClassConst ;;
 
     CLASS
   | identifier
 -> classConstant ;;
 
     #encaps=encaps*
 -> encapsList ;;
 
     var=encapsVar | value=ENCAPSED_AND_WHITESPACE
 -> encaps ;;
 
      -- first/first conflict resolved by LA(2)
      --(expr allows STRING_VARNAME too - but without [expr])
     DOLLAR_OPEN_CURLY_BRACES ( ?[: LA(2).kind == Token_LBRACKET:] STRING_VARNAME arrayIndex=arrayIndexSpecifier RBRACE
       | expr=expr RBRACE )
   | variable=variableIdentifier (OBJECT_OPERATOR propertyIdentifier=identifier | LBRACKET offset=encapsVarOffset RBRACKET | 0)
   | CURLY_OPEN expr=expr RBRACE
 -> encapsVar ;;
 
     STRING
   | NUM_STRING
   | variableIdentifier
 -> encapsVarOffset ;;
 
 
     LNUMBER                  [: (*yynode)->scalarType = ScalarTypeInt; :]
   | DNUMBER                  [: (*yynode)->scalarType = ScalarTypeFloat; :]
   | string=CONSTANT_ENCAPSED_STRING [: (*yynode)->scalarType = ScalarTypeString; :] stringIndex=stringIndexSpecifier*
   | LINE                     [: (*yynode)->scalarType = ScalarTypeInt; :]
   | FILE                     [: (*yynode)->scalarType = ScalarTypeString; :]
   | CLASS_C                  [: (*yynode)->scalarType = ScalarTypeString; :]
   | METHOD_C                 [: (*yynode)->scalarType = ScalarTypeString; :]
   | FUNC_C                   [: (*yynode)->scalarType = ScalarTypeString; :]
   | NAMESPACE_C              [: (*yynode)->scalarType = ScalarTypeString; :]
   | START_NOWDOC STRING END_NOWDOC [: (*yynode)->scalarType = ScalarTypeString; :]
 -> commonScalar [
      member variable scalarType: ScalarTypes;
 ] ;;
 
     FUNCTION (BIT_AND | 0) functionName=identifier
     LPAREN parameters=parameterList RPAREN LBRACE try/recover(functionBody=innerStatementList) RBRACE
 -> functionDeclarationStatement ;;
 
     (#parameters=parameter @ COMMA) | 0
 -> parameterList ;;
 
 (parameterType=namespacedIdentifier | arrayType=ARRAY | callableType=CALLABLE | 0) (isRef=BIT_AND | 0)
     variable=variableIdentifier (ASSIGN defaultValue=staticScalar | 0)
 -> parameter ;;
 
     value=commonScalar
   | constantOrClassConst=constantOrClassConst
   | PLUS plusValue=staticScalar
   | MINUS minusValue=staticScalar
   | array=ARRAY LPAREN
         (#arrayValues=staticArrayPairValue
              -- break because array(1,) is allowed
           @ (COMMA [: if (yytoken == Token_RPAREN) { break; } :] ) | 0)
     RPAREN
   | array=LBRACKET
         (#arrayValues=staticArrayPairValue
              -- break because [1,] is allowed
           @ (COMMA [: if (yytoken == Token_RBRACKET) { break; } :] ) | 0)
     RBRACKET
 -> staticScalar ;;
 
     #val1=staticScalar (DOUBLE_ARROW #val2=staticScalar | 0)
 -> staticArrayPairValue ;;
 
    (isGlobal=BACKSLASH | 0)
    #namespaceName=identifier+ @ BACKSLASH
 -> namespacedIdentifier ;;
 
      string=STRING
 -> identifier ;;
 
      variable=VARIABLE
 -> variableIdentifier ;;
 
     NAMESPACE #namespaceName=identifier* @ BACKSLASH
     (
         -- the semicolon case needs at least one namespace identifier, the {...} case not...
         SEMICOLON [: if (!(*yynode)->namespaceNameSequence) { reportProblem(Error, QStringLiteral("Missing namespace identifier."), -2); } :]
     | LBRACE try/recover(body=innerStatementList) RBRACE )
 -> namespaceDeclarationStatement ;;
 
     INTERFACE interfaceName=identifier (EXTENDS extends=classImplements | 0)
     LBRACE try/recover(body=classBody) RBRACE
 -> interfaceDeclarationStatement ;;
 
     TRAIT traitName=identifier
     LBRACE body=classBody RBRACE
 -> traitDeclarationStatement ;;
 
     modifier=optionalClassModifier CLASS className=identifier
         (EXTENDS extends=classExtends | 0)
         (IMPLEMENTS implements=classImplements | 0)
     LBRACE body=classBody RBRACE
 -> classDeclarationStatement ;;
 
 identifier=namespacedIdentifier
 -> classExtends ;;
 
 #implements=namespacedIdentifier @ COMMA
 -> classImplements ;;
 
 -- error recovery, to understand it you probably have to look at the generated code ;-)
 [: bool reported = false; while ( true ) { :]
 try/recover(#classStatements=classStatement)*
 [: if (yytoken != Token_RBRACE && yytoken != Token_EOF && yytoken != Token_CLOSE_TAG) {
         if (!reported) {
             reportProblem(Error, QStringLiteral("Unexpected token in class context."));
             reported = true;
         }
         yylex();
    } else {
         break;
    }
 } :]
  RBRACE [: rewind(tokenStream->index() - 2); :]
 -> classBody ;;
 
     CONST #consts=constantDeclaration @ COMMA SEMICOLON
   | VAR variable=classVariableDeclaration SEMICOLON
   | modifiers=optionalModifiers
     ( variable=classVariableDeclaration SEMICOLON
       | FUNCTION (BIT_AND | 0) methodName=identifier LPAREN parameters=parameterList RPAREN
         methodBody=methodBody
     )
   | USE #traits=namespacedIdentifier @ COMMA (imports=traitAliasDeclaration|SEMICOLON)
 -> classStatement ;;
 
     LBRACE #statements=traitAliasStatement
         @ (SEMICOLON [: if (yytoken == Token_RBRACE) { break; } :]) RBRACE
 -> traitAliasDeclaration ;;
 
     importIdentifier=traitAliasIdentifier (AS (modifiers=optionalModifiers | 0) aliasIdentifier=identifier|INSTEADOF #conflictIdentifier=namespacedIdentifier @ COMMA)
 -> traitAliasStatement ;;
 
     identifier=namespacedIdentifier PAAMAYIM_NEKUDOTAYIM methodIdentifier=identifier
 -> traitAliasIdentifier ;;
 
     SEMICOLON -- abstract method
  |  LBRACE try/recover(statements=innerStatementList) RBRACE
 -> methodBody ;;
 
 #vars=classVariable @ COMMA
 -> classVariableDeclaration ;;
 
     variable=variableIdentifier (ASSIGN value=staticScalar | 0)
 -> classVariable ;;
 
   (
     PUBLIC     [: (*yynode)->modifiers |= ModifierPublic;      :]
   | PROTECTED  [: (*yynode)->modifiers |= ModifierProtected;      :]
   | PRIVATE    [: (*yynode)->modifiers |= ModifierPrivate;      :]
   | STATIC     [: (*yynode)->modifiers |= ModifierStatic;      :]
   | ABSTRACT   [: (*yynode)->modifiers |= ModifierAbstract;      :]
   | FINAL      [: (*yynode)->modifiers |= ModifierFinal;      :]
   | 0
   )*
 -> optionalModifiers[
      member variable modifiers: unsigned int;
 ] ;;
 
   (
     ABSTRACT   [: (*yynode)->modifier = AbstractClass; :]
   | FINAL      [: (*yynode)->modifier = FinalClass;    :]
   | 0
   )
 -> optionalClassModifier[
      member variable modifier: ClassModifier;
 ] ;;
 
 
 
 
 
 -----------------------------------------------------------------
 -- Code segments copied to the implementation (.cpp) file.
 -- If existent, kdevelop-pg's current syntax requires this block
 -- to occur at the end of the file.
 -----------------------------------------------------------------
 
 [:
 
 #include <QtCore/QDebug>
-#include <KTextEditor/Range>
+#include <language/editor/documentrange.h>
 
 namespace Php
 {
 
 void Parser::tokenize(const QString& contents, int initialState)
 {
     m_contents = contents;
     Lexer lexer(tokenStream, contents, initialState);
     int kind = Parser::Token_EOF;
     int lastDocCommentBegin;
     int lastDocCommentEnd;
 
     do
     {
         lastDocCommentBegin = 0;
         lastDocCommentEnd = 0;
         kind = lexer.nextTokenKind();
         while (kind == Parser::Token_WHITESPACE || kind == Parser::Token_COMMENT || kind == Parser::Token_DOC_COMMENT) {
             if (kind == Parser::Token_COMMENT || kind == Parser::Token_DOC_COMMENT) {
                 extractTodosFromComment(tokenText(lexer.tokenBegin(), lexer.tokenEnd()), lexer.tokenBegin());
             }
             if (kind == Parser::Token_DOC_COMMENT) {
                 lastDocCommentBegin = lexer.tokenBegin();
                 lastDocCommentEnd = lexer.tokenEnd();
             }
             kind = lexer.nextTokenKind();
         }
         if ( !kind ) // when the lexer returns 0, the end of file is reached
         {
             kind = Parser::Token_EOF;
         }
         Parser::Token &t = tokenStream->push();
         t.begin = lexer.tokenBegin();
         t.end = lexer.tokenEnd();
         t.kind = kind;
         t.docCommentBegin = lastDocCommentBegin;
         t.docCommentEnd = lastDocCommentEnd;
         //if ( m_debug ) qDebug() << kind << tokenText(t.begin,t.end) << t.begin << t.end;
     }
     while ( kind != Parser::Token_EOF );
 
     yylex(); // produce the look ahead token
 }
 
 void Parser::extractTodosFromComment(const QString& comment, qint64 startPosition)
 {
     auto i = m_todoMarkers.globalMatch(comment);
     while (i.hasNext()) {
         auto match = i.next();
         auto p = reportProblem(Todo, match.captured(1), 0);
         if (!p) {
             continue;
         }
 
         qint64 line = 0;
         qint64 column = 0;
         tokenStream->locationTable()->positionAt(startPosition, &line, &column);
 
         auto location = p->finalLocation();
         location.setStart(KTextEditor::Cursor(line, column + match.capturedStart(1)));
         location.setEnd(KTextEditor::Cursor(line, column + match.capturedEnd(1)));
         p->setFinalLocation(location);
     };
 }
 
 void Parser::setTodoMarkers(const QStringList& markers)
 {
     QString pattern = QStringLiteral("^(?:[/\\*\\s]*)(.*(?:");
     bool first = true;
     foreach(const QString& marker, markers) {
         if (!first) {
             pattern += '|';
         }
         pattern += QRegularExpression::escape(marker);
         first = false;
     }
     pattern += QStringLiteral(").*?)(?:[/\\*\\s]*)$");
     m_todoMarkers.setPatternOptions(QRegularExpression::MultilineOption);
     m_todoMarkers.setPattern(pattern);
 }
 
 QString Parser::tokenText(qint64 begin, qint64 end)
 {
     return m_contents.mid(begin,end-begin+1);
 }
 
 
 KDevelop::ProblemPointer Parser::reportProblem( Parser::ProblemType type, const QString& message, int offset )
 {
     qint64 sLine;
     qint64 sCol;
     qint64 index = tokenStream->index() + offset;
     if (index >= tokenStream->size()) {
         return {};
     }
     tokenStream->startPosition(index, &sLine, &sCol);
     qint64 eLine;
     qint64 eCol;
     tokenStream->endPosition(index, &eLine, &eCol);
     auto p = KDevelop::ProblemPointer(new KDevelop::Problem());
     p->setSource(KDevelop::IProblem::Parser);
     switch ( type ) {
         case Error:
             p->setSeverity(KDevelop::IProblem::Error);
             break;
         case Warning:
             p->setSeverity(KDevelop::IProblem::Warning);
             break;
         case Info:
             p->setSeverity(KDevelop::IProblem::Hint);
             break;
         case Todo:
             p->setSeverity(KDevelop::IProblem::Hint);
             p->setSource(KDevelop::IProblem::ToDo);
             break;
     }
     p->setDescription(message);
     KTextEditor::Range range(sLine, sCol, eLine, eCol + 1);
     p->setFinalLocation(KDevelop::DocumentRange(m_currentDocument, range));
     m_problems << p;
     return p;
 }
 
 
 // custom error recovery
 void Parser::expectedToken(int /*expected*/, qint64 /*where*/, const QString& name)
 {
     reportProblem( Parser::Error, QStringLiteral("Expected token \"%1\"").arg(name));
 }
 
 void Parser::expectedSymbol(int /*expectedSymbol*/, const QString& name)
 {
     qint64 line;
     qint64 col;
     qint64 index = tokenStream->index()-1;
     Token &token = tokenStream->at(index);
     qCDebug(PARSER) << "token starts at:" << token.begin;
     qCDebug(PARSER) << "index is:" << index;
     tokenStream->startPosition(index, &line, &col);
     QString tokenValue = tokenText(token.begin, token.end);
     qint64 eLine;
     qint64 eCol;
     tokenStream->endPosition(index, &eLine, &eCol);
     reportProblem( Parser::Error,
                    QStringLiteral("Expected symbol \"%1\" (current token: \"%2\" [%3] at %4:%5 - %6:%7)")
                   .arg(name,
                        token.kind != 0 ? tokenValue : QStringLiteral("EOF"))
                   .arg(token.kind)
                   .arg(line)
                   .arg(col)
                   .arg(eLine)
                   .arg(eCol));
 }
 
 void Parser::setDebug( bool debug )
 {
     m_debug = debug;
 }
 
 void Parser::setCurrentDocument(KDevelop::IndexedString url)
 {
     m_currentDocument = url;
 }
 
 
 Parser::ParserState *Parser::copyCurrentState()
 {
     ParserState *state = new ParserState();
     state->varExpressionState = m_state.varExpressionState;
     state->varExpressionIsVariable = m_state.varExpressionIsVariable;
     return state;
 }
 
 void Parser::restoreState( Parser::ParserState* state)
 {
     m_state.varExpressionState = state->varExpressionState;
     m_state.varExpressionIsVariable = state->varExpressionIsVariable;
 }
 
 } // end of namespace Php
 
 :]
 
 -- kate: space-indent on; indent-width 4; tab-width 4; replace-tabs on; auto-insert-doxygen on; mode KDevelop-PG[-Qt]
diff --git a/phpparsejob.cpp b/phpparsejob.cpp
index 7c21191..c980378 100644
--- a/phpparsejob.cpp
+++ b/phpparsejob.cpp
@@ -1,249 +1,250 @@
 /*****************************************************************************
  * Copyright (c) 2007 Piyush verma <piyush.verma@gmail.com>                  *
  * Copyright (c) 2008 Niko Sams <niko.sams@gmail.com>                        *
  * Copyright (c) 2010 Milian Wolff <mail@milianw.de>                         *
  *                                                                           *
  * This program is free software; you can redistribute it and/or modify      *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation; either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * This program 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 General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************/
 
 #include "phpparsejob.h"
 #include <QFile>
 #include <QReadWriteLock>
 
 #include <ktexteditor/document.h>
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/topducontext.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/backgroundparser/urlparselock.h>
+#include <language/editor/documentrange.h>
 
 #include "editorintegrator.h"
 #include "parsesession.h"
 #include "phplanguagesupport.h"
 #include "phpdebugvisitor.h"
 #include "duchain/builders/declarationbuilder.h"
 #include "duchain/builders/usebuilder.h"
 #include "duchain/helper.h"
 #include "phpducontext.h"
 #include "phpdebug.h"
 
 #include <QtCore/QReadLocker>
 #include <QtCore/QThread>
 #include <language/duchain/duchainutils.h>
 
 #include <mutex>
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 ParseJob::ParseJob(const IndexedString& url, ILanguageSupport* languageSupport)
 : KDevelop::ParseJob(url, languageSupport)
 , m_parentJob(nullptr)
 {
 }
 
 ParseJob::~ParseJob()
 {
 }
 
 LanguageSupport* ParseJob::php() const
 {
     return dynamic_cast<LanguageSupport*>(languageSupport());
 }
 
 void ParseJob::run(ThreadWeaver::JobPointer /*self*/, ThreadWeaver::Thread * /*thread*/)
 {
     if (document() != internalFunctionFile()) {
         // make sure we loaded the internal file already
         const auto &phpSupport = languageSupport();
         static std::once_flag once;
         std::call_once(once, [phpSupport] {
             qCDebug(PHP) << "Initializing internal function file" << internalFunctionFile();
             ParseJob internalJob(internalFunctionFile(), phpSupport);
             internalJob.setMinimumFeatures(TopDUContext::AllDeclarationsAndContexts);
             internalJob.run({}, nullptr);
             Q_ASSERT(internalJob.success());
         });
     }
 
     UrlParseLock urlLock(document());
 
     if (!(minimumFeatures() & Resheduled) && !isUpdateRequired(phpLanguageString())) {
         return;
     }
     qCDebug(PHP) << "parsing" << document().str();
 
     KDevelop::ProblemPointer p = readContents();
     if (p) {
         //TODO: associate problem with topducontext
         return abortJob();;
     }
 
     ParseSession session;
     //TODO: support different charsets
     session.setContents(QString::fromUtf8(contents().contents));
     session.setCurrentDocument(document());
 
     // 2) parse
     StartAst* ast = nullptr;
     bool matched = session.parse(&ast);
 
     if (abortRequested() || ICore::self()->shuttingDown()) {
         return abortJob();
     }
 
     KDevelop::ReferencedTopDUContext toUpdate;
     {
         KDevelop::DUChainReadLocker duchainlock(KDevelop::DUChain::lock());
         toUpdate = KDevelop::DUChainUtils::standardContextForUrl(document().toUrl());
     }
 
     KDevelop::TopDUContext::Features newFeatures = minimumFeatures();
     if (toUpdate)
         newFeatures = (KDevelop::TopDUContext::Features)(newFeatures | toUpdate->features());
 
     //Remove update-flags like 'Recursive' or 'ForceUpdate'
     newFeatures = static_cast<KDevelop::TopDUContext::Features>(newFeatures & KDevelop::TopDUContext::AllDeclarationsContextsUsesAndAST);
 
     if (matched) {
         if (abortRequested()) {
             return abortJob();
         }
 
         EditorIntegrator editor(&session);
 
         QReadLocker parseLock(php()->parseLock());
 
         DeclarationBuilder builder(&editor);
         KDevelop::ReferencedTopDUContext chain = builder.build(document(), ast, toUpdate);
 
         if (abortRequested()) {
             return abortJob();
         }
 
         setDuChain(chain);
 
         bool hadUnresolvedIdentifiers = builder.hadUnresolvedIdentifiers();
 
         if ( newFeatures & TopDUContext::AllDeclarationsContextsAndUses
                 && document() != internalFunctionFile() )
         {
             UseBuilder useBuilder(&editor);
             useBuilder.buildUses(ast);
 
             if (useBuilder.hadUnresolvedIdentifiers())
                 hadUnresolvedIdentifiers = true;
         }
 
         if (hadUnresolvedIdentifiers) {
             if (!(minimumFeatures() & Resheduled) && KDevelop::ICore::self()->languageController()->backgroundParser()->queuedCount()) {
                 // Need to create new parse job with lower priority
                 qCDebug(PHP) << "Reschedule file " << document().str() << "for parsing";
                 KDevelop::TopDUContext::Features feat = static_cast<KDevelop::TopDUContext::Features>(
                         minimumFeatures() | KDevelop::TopDUContext::VisibleDeclarationsAndContexts | Resheduled
                     );
                 int priority = qMin(parsePriority()+100, (int)KDevelop::BackgroundParser::WorstPriority);
                 KDevelop::ICore::self()->languageController()->backgroundParser()
                     ->addDocument(document(), feat, priority);
 
             } else {
                 // We haven't resolved all identifiers, but by now, we don't expect to
                 qCDebug(PHP) << "Builder found unresolved identifiers when they should have been resolved! (if there was no coding error)";
             }
         }
 
         if (abortRequested()) {
             return abortJob();
         }
 
         if (abortRequested()) {
             return abortJob();
         }
 
         {
             DUChainWriteLocker lock(DUChain::lock());
 
             foreach(const ProblemPointer &p, session.problems()) {
                 chain->addProblem(p);
             }
 
             chain->setFeatures(newFeatures);
             ParsingEnvironmentFilePointer file = chain->parsingEnvironmentFile();
             file->setModificationRevision(contents().modification);
             DUChain::self()->updateContextEnvironment( chain->topContext(), file.data() );
         }
 
         highlightDUChain();
     } else {
         ReferencedTopDUContext top;
         DUChainWriteLocker lock;
         {
             top = DUChain::self()->chainForDocument(document());
         }
         if (top) {
             ///NOTE: if we clear the imported parent contexts, autocompletion of built-in PHP stuff won't work!
             //top->clearImportedParentContexts();
             top->parsingEnvironmentFile()->clearModificationRevisions();
             top->clearProblems();
         } else {
             ParsingEnvironmentFile *file = new ParsingEnvironmentFile(document());
             file->setLanguage(phpLanguageString());
             top = new TopDUContext(document(), RangeInRevision(0, 0, INT_MAX, INT_MAX), file);
             DUChain::self()->addDocumentChain(top);
         }
         foreach(const ProblemPointer &p, session.problems()) {
             top->addProblem(p);
         }
         setDuChain(top);
         qCDebug(PHP) << "===Failed===" << document().str();
     }
 
     DUChain::self()->emitUpdateReady(document(), duChain());
 }
 
 void ParseJob::setParentJob(ParseJob *job)
 {
     m_parentJob = job;
 }
 
 
 bool ParseJob::hasParentDocument(const IndexedString &doc)
 {
     if (document() == doc) return true;
     if (!m_parentJob) return false;
     if (m_parentJob->document() == doc) return true;
     return m_parentJob->hasParentDocument(doc);
 }
 
 ProblemPointer ParseJob::createProblem(const QString &description, AstNode* node,
                                        EditorIntegrator * editor, IProblem::Source source,
                                        IProblem::Severity severity)
 {
     ProblemPointer p(new Problem());
     p->setSource(source);
     p->setSeverity(severity);
     p->setDescription(description);
     p->setFinalLocation(DocumentRange(document(), editor->findRange(node).castToSimpleRange()));
     qCDebug(PHP) << p->description();
     return p;
 }
 
 }
 
 // kate: space-indent on; indent-width 4; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/testprovider/phpunitprovider.h b/testprovider/phpunitprovider.h
index d1b8a70..6bb221f 100644
--- a/testprovider/phpunitprovider.h
+++ b/testprovider/phpunitprovider.h
@@ -1,52 +1,54 @@
 /***************************************************************************
  *   This file is part of KDevelop PHP support                             *
  *   Copyright 2012 Miha Čančula <miha@noughmad.eu>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #ifndef PHPUNITPROVIDER_H
 #define PHPUNITPROVIDER_H
 
 #include <interfaces/iplugin.h>
 
 #include <language/duchain/indexeddeclaration.h>
 #include <language/duchain/topducontext.h>
 
+#include <serialization/indexedstring.h>
+
 #include <QVariant>
 
 class QVariant;
 
 class PhpUnitProvider : public KDevelop::IPlugin
 {
     Q_OBJECT
 
 public:
     PhpUnitProvider(QObject* parent, const QList<QVariant>& args = QList<QVariant>());
 
 public slots:
     void updateReady(const KDevelop::IndexedString& document, const KDevelop::ReferencedTopDUContext& context);
 
 private:
     KDevelop::IndexedString m_phpUnitDeclarationsFile;
     KDevelop::IndexedDeclaration m_testCaseDeclaration;
     QList<KDevelop::ReferencedTopDUContext> m_pendingContexts;
 
     void processContext(KDevelop::ReferencedTopDUContext context);
     void processTestCaseDeclaration(KDevelop::Declaration* declaration);
 };
 
 #endif // PHPUNITPROVIDER_H
diff --git a/testprovider/phpunitrunjob.cpp b/testprovider/phpunitrunjob.cpp
index d352f41..0dff2f1 100644
--- a/testprovider/phpunitrunjob.cpp
+++ b/testprovider/phpunitrunjob.cpp
@@ -1,200 +1,201 @@
 /***************************************************************************
  *   This file is part of KDevelop PHP support                             *
  *   Copyright 2012 Miha Čančula <miha@noughmad.eu>                        *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #include "phpunitrunjob.h"
 #include "phpunittestsuite.h"
 #include "testdoxdelegate.h"
 #include "testproviderdebug.h"
 
 #include <QStandardPaths>
 
 #include <util/processlinemaker.h>
 #include <util/executecompositejob.h>
 #include <outputview/outputmodel.h>
 #include <interfaces/itestcontroller.h>
+#include <interfaces/iruncontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilauncher.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/launchconfigurationtype.h>
 #include <interfaces/ilaunchmode.h>
 
 #include <KProcess>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 PhpUnitRunJob::PhpUnitRunJob(PhpUnitTestSuite* suite, const QStringList& cases, KDevelop::OutputJob::OutputJobVerbosity verbosity, QObject* parent)
 : KJob(parent)
 , m_process(nullptr)
 , m_suite(suite)
 , m_cases(cases)
 , m_job(nullptr)
 , m_outputJob(nullptr)
 , m_verbosity(verbosity)
 {
 }
 
 KJob* createTestJob(QString launchModeId, QStringList arguments )
 {
     KDevelop::LaunchConfigurationType* type = KDevelop::ICore::self()->runController()->launchConfigurationTypeForId( QStringLiteral("Script Application") );
     KDevelop::ILaunchMode* mode = KDevelop::ICore::self()->runController()->launchModeForId( launchModeId );
 
     qCDebug(TESTPROVIDER) << "got mode and type:" << type << type->id() << mode << mode->id();
     Q_ASSERT(type && mode);
 
     KDevelop::ILauncher* launcher = nullptr;
     foreach (KDevelop::ILauncher *l, type->launchers())
     {
         //qCDebug(TESTPROVIDER) << "available launcher" << l << l->id() << l->supportedModes();
         if (l->supportedModes().contains(mode->id())) {
             launcher = l;
             break;
         }
     }
     Q_ASSERT(launcher);
 
     KDevelop::ILaunchConfiguration* ilaunch = nullptr;
     QList<KDevelop::ILaunchConfiguration*> launchConfigurations = KDevelop::ICore::self()->runController()->launchConfigurations();
     foreach (KDevelop::ILaunchConfiguration *l, launchConfigurations) {
         if (l->type() == type && l->config().readEntry("ConfiguredByPhpUnit", false)) {
             ilaunch = l;
             break;
         }
     }
     if (!ilaunch) {
         ilaunch = KDevelop::ICore::self()->runController()->createLaunchConfiguration( type,
                                                 qMakePair( mode->id(), launcher->id() ),
                                                 nullptr, //TODO add project
                                                 i18n("PHPUnit") );
         ilaunch->config().writeEntry("ConfiguredByPhpUnit", true);
         //qCDebug(TESTPROVIDER) << "created config, launching";
     } else {
         //qCDebug(TESTPROVIDER) << "reusing generated config, launching";
     }
     type->configureLaunchFromCmdLineArguments( ilaunch->config(), arguments );
     return KDevelop::ICore::self()->runController()->execute(launchModeId, ilaunch);
 }
 
 void PhpUnitRunJob::start()
 {
     m_process = new KProcess(this);
     // TODO: Arguments from test cases
 
     QStringList args;
 
     if (m_cases != m_suite->cases())
     {
         args << QStringLiteral("--filter");
         args << '"' + m_cases.join(QStringLiteral("|")) + '"';
     }
 
     args << QStringLiteral("--testdox") << m_suite->name() << m_suite->url().toLocalFile();
 
     const QString exe = QStandardPaths::findExecutable(QStringLiteral("phpunit"));
     if (exe.isEmpty()) {
         KDevelop::ITestController* tc = KDevelop::ICore::self()->testController();
         tc->notifyTestRunFinished(m_suite, m_result);
         emitResult();
         return;
     }
 
     args.prepend(exe);
     args.prepend(QStringLiteral("php"));
 
     m_job = createTestJob(QStringLiteral("execute"), args);
 
     m_outputJob = qobject_cast<KDevelop::OutputJob*>(m_job);
     if (!m_outputJob) {
         if (UnprotectedExecuteCompositeJob* cjob = qobject_cast<UnprotectedExecuteCompositeJob*>(m_job)) {
             m_outputJob = qobject_cast<KDevelop::OutputJob*>(cjob->subjobs().last());
         }
     }
     Q_ASSERT(m_outputJob);
     if (m_outputJob) {
         m_outputJob->setVerbosity(m_verbosity);
         connect(m_outputJob->model(), &QAbstractItemModel::rowsInserted, this, &PhpUnitRunJob::rowsInserted);
     }
 
     connect(m_job, &KJob::finished, this, &PhpUnitRunJob::processFinished);
 }
 
 bool PhpUnitRunJob::doKill()
 {
     if (m_job)
     {
         m_job->kill();
     }
     return true;
 }
 
 void PhpUnitRunJob::processFinished(KJob* job)
 {
     if (job->error() == 1) {
         m_result.suiteResult = KDevelop::TestResult::Failed;
     } else if (job->error() == 0) {
         m_result.suiteResult = KDevelop::TestResult::Passed;
         foreach (KDevelop::TestResult::TestCaseResult result, m_result.testCaseResults)
         {
             if (result == KDevelop::TestResult::Failed)
             {
                 m_result.suiteResult = KDevelop::TestResult::Failed;
                 break;
             }
         }
     } else {
         m_result.suiteResult = KDevelop::TestResult::Error;
     }
 
     qCDebug(TESTPROVIDER) << m_result.suiteResult << m_result.testCaseResults;
     KDevelop::ICore::self()->testController()->notifyTestRunFinished(m_suite, m_result);
     emitResult();
 }
 
 void PhpUnitRunJob::rowsInserted(const QModelIndex &parent, int startRow, int endRow)
 {
     Q_ASSERT(m_outputJob);
     static QRegExp testResultLineExp = QRegExp("\\[([x\\s])\\]");
     for (int row = startRow; row <= endRow; ++row)
     {
         QString line = m_outputJob->model()->data(m_outputJob->model()->index(row, 0, parent), Qt::DisplayRole).toString();
 
         int i = testResultLineExp.indexIn(line);
         if (i > -1)
         {
             bool passed = testResultLineExp.cap(1) == QLatin1String("x");
             QString testCase = "test" + line.mid(i+4).toLower().remove(' ');
             qCDebug(TESTPROVIDER) << "Got result in " << line << " for " << testCase;
             if (m_cases.contains(testCase, Qt::CaseInsensitive))
             {
                 foreach (const QString& realCaseName, m_cases)
                 {
                     if (QString::compare(testCase, realCaseName, Qt::CaseInsensitive) == 0)
                     {
                         m_result.testCaseResults[testCase] = (passed ? KDevelop::TestResult::Passed : KDevelop::TestResult::Failed);
                         break;
                     }
                 }
             }
         }
         else
         {
             qCDebug(TESTPROVIDER) << line << testResultLineExp.pattern() << i;
         }
     }
 }