File indexing completed on 2024-05-05 16:41:06

 /*
     SPDX-FileCopyrightText: 2008 Niko Sams <niko.sams@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "declarationbuilder.h"
 
 #include <KLocalizedString>
 
 #include <language/duchain/stringhelpers.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/unsuretype.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <util/pushvalue.h>
 
 
 #include "../declarations/variabledeclaration.h"
 #include "../declarations/classmethoddeclaration.h"
 #include "../declarations/classdeclaration.h"
 #include "../declarations/functiondeclaration.h"
 #include "../declarations/namespacedeclaration.h"
 #include "../declarations/namespacealiasdeclaration.h"
 #include "../declarations/traitmethodaliasdeclaration.h"
 #include "../declarations/traitmemberaliasdeclaration.h"
 
 #include "../parser/phpast.h"
 #include "../parser/parsesession.h"
 
 #include "../helper.h"
 #include "../expressionvisitor.h"
 
 #include "predeclarationbuilder.h"
 #include <duchaindebug.h>
 
 #define ifDebug(x)
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 DeclarationBuilder::FindVariableResults::FindVariableResults()
 : find(true)
 , isArray(false)
 , node(nullptr)
 {
 
 }
 
 void DeclarationBuilder::getVariableIdentifier(VariableAst* node,
                                                 QualifiedIdentifier &identifier,
                                                 QualifiedIdentifier &parent,
                                                 AstNode* &targetNode,
                                                 bool &arrayAccess)
 {
     parent = QualifiedIdentifier();
     if ( node->variablePropertiesSequence ) {
         // at least one "->" in the assignment target
         // => find he parent of the target
         // => find the target (last object property)
         if ( node->variablePropertiesSequence->count() == 1 ) {
             // $parent->target
             ///TODO: $parent[0]->target = ... (we don't know the type of [0] yet, need proper array handling first)
             if ( node->var && node->var->baseVariable && node->var->baseVariable->var
                 && !node->var->baseVariable->offsetItemsSequence ) {
                 parent = identifierForNode(
                     node->var->baseVariable->var->variable
                 );
             }
         } else {
             // $var->...->parent->target
             ///TODO: $var->...->parent[0]->target = ... (we don't know the type of [0] yet, need proper array handling first)
             const KDevPG::ListNode< VariableObjectPropertyAst* >* parentNode = node->variablePropertiesSequence->at(
                 node->variablePropertiesSequence->count() - 2
             );
             if ( parentNode->element && parentNode->element->variableProperty
                 && parentNode->element->variableProperty->objectProperty
                 && parentNode->element->variableProperty->objectProperty->objectDimList
                 && parentNode->element->variableProperty->objectProperty->objectDimList->variableName
                 && !parentNode->element->variableProperty->objectProperty->objectDimList->offsetItemsSequence ) {
                 parent = identifierForNode(
                     parentNode->element->variableProperty->objectProperty->objectDimList->variableName->name
                 );
             }
         }
 
         if ( !parent.isEmpty() ) {
             const KDevPG::ListNode< VariableObjectPropertyAst* >* tNode = node->variablePropertiesSequence->at(
                 node->variablePropertiesSequence->count() - 1
             );
             if ( tNode->element && tNode->element->variableProperty
                 && tNode->element->variableProperty->objectProperty
                 && tNode->element->variableProperty->objectProperty->objectDimList
                 && tNode->element->variableProperty->objectProperty->objectDimList->variableName ) {
                 arrayAccess = (bool) tNode->element->variableProperty->objectProperty->objectDimList->offsetItemsSequence;
                 identifier = identifierForNode(
                     tNode->element->variableProperty->objectProperty->objectDimList->variableName->name
                 );
                 targetNode = tNode->element->variableProperty->objectProperty->objectDimList->variableName->name;
             }
         }
     } else {
         // simple assignment to $var
         if ( node->var && node->var->baseVariable && node->var->baseVariable->var ) {
             arrayAccess = (bool) node->var->baseVariable->offsetItemsSequence;
             identifier = identifierForNode(
                 node->var->baseVariable->var->variable
             );
             targetNode = node->var->baseVariable->var->variable;
         }
     }
 }
 
 ReferencedTopDUContext DeclarationBuilder::build(const IndexedString& url, AstNode* node,
                                                  const ReferencedTopDUContext& updateContext_)
 {
     ReferencedTopDUContext updateContext(updateContext_);
     //Run DeclarationBuilder twice, to find uses of declarations that are
     //declared after the use. ($a = new Foo; class Foo {})
     {
         PreDeclarationBuilder prebuilder(&m_types, &m_functions, &m_namespaces,
                                          &m_upcomingClassVariables, m_editor);
         updateContext = prebuilder.build(url, node, updateContext);
         m_actuallyRecompiling = prebuilder.didRecompile();
     }
 
     // now skip through some things the DeclarationBuilderBase (ContextBuilder) would do,
     // most significantly don't clear imported parent contexts
     m_isInternalFunctions = url == internalFunctionFile();
     if ( m_isInternalFunctions ) {
         m_reportErrors = false;
     } else if ( ICore::self() ) {
         m_reportErrors = ICore::self()->languageController()->completionSettings()->highlightSemanticProblems();
     }
 
     return ContextBuilderBase::build(url, node, updateContext);
 }
 
 void DeclarationBuilder::startVisiting(AstNode* node)
 {
     setRecompiling(m_actuallyRecompiling);
     setCompilingContexts(false);
     DeclarationBuilderBase::startVisiting(node);
 }
 
 void DeclarationBuilder::closeDeclaration()
 {
     if (currentDeclaration() && lastType()) {
         DUChainWriteLocker lock(DUChain::lock());
         currentDeclaration()->setType(lastType());
     }
 
     eventuallyAssignInternalContext();
 
     DeclarationBuilderBase::closeDeclaration();
 }
 
 void DeclarationBuilder::classContextOpened(DUContext* context)
 {
     DUChainWriteLocker lock(DUChain::lock());
     currentDeclaration()->setInternalContext(context);
 }
 
 void DeclarationBuilder::visitClassDeclarationStatement(ClassDeclarationStatementAst * node)
 {
     ClassDeclaration* classDec = openTypeDeclaration(node->className, ClassDeclarationData::Class);
     openType(classDec->abstractType());
     DeclarationBuilderBase::visitClassDeclarationStatement(node);
     {
         DUChainWriteLocker lock;
         classDec->updateCompletionCodeModelItem();
     }
     closeType();
     closeDeclaration();
     m_upcomingClassVariables.clear();
 
     QString className = classDec->prettyName().str();
 
     if (isReservedClassName(className)) {
         reportError(i18n("Cannot use '%1' as class name as it is reserved", className), node->className);
     }
 }
 
 void DeclarationBuilder::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node)
 {
     ClassDeclaration* interfaceDec = openTypeDeclaration(node->interfaceName, ClassDeclarationData::Interface);
     openType(interfaceDec->abstractType());
     DeclarationBuilderBase::visitInterfaceDeclarationStatement(node);
     closeType();
     closeDeclaration();
 
     QString interfaceName = interfaceDec->prettyName().str();
 
     if (isReservedClassName(interfaceName)) {
         reportError(i18n("Cannot use '%1' as class name as it is reserved", interfaceName), node->interfaceName);
     }
 }
 
 void DeclarationBuilder::visitTraitDeclarationStatement(TraitDeclarationStatementAst * node)
 {
     ClassDeclaration* traitDec = openTypeDeclaration(node->traitName, ClassDeclarationData::Trait);
     openType(traitDec->abstractType());
     DeclarationBuilderBase::visitTraitDeclarationStatement(node);
     closeType();
     closeDeclaration();
     m_upcomingClassVariables.clear();
 
     QString traitName = traitDec->prettyName().str();
 
     if (isReservedClassName(traitName)) {
         reportError(i18n("Cannot use '%1' as class name as it is reserved", traitName), node->traitName);
     }
 }
 
 ClassDeclaration* DeclarationBuilder::openTypeDeclaration(IdentifierAst* name, ClassDeclarationData::ClassType type)
 {
     ClassDeclaration* classDec = m_types.value(name->string, nullptr);
     Q_ASSERT(classDec);
     isGlobalRedeclaration(identifierForNode(name), name, ClassDeclarationType);
     Q_ASSERT(classDec->classType() == type);
     Q_UNUSED(type);
 
     // seems like we have to do that manually, else the usebuilder crashes...
     setEncountered(classDec);
     openDeclarationInternal(classDec);
 
     return classDec;
 }
 
 bool DeclarationBuilder::isBaseMethodRedeclaration(const IdentifierPair &ids, ClassDeclaration *curClass,
         ClassStatementAst *node)
 {
     DUChainWriteLocker lock(DUChain::lock());
     while (curClass->baseClassesSize() > 0) {
         StructureType::Ptr type;
         FOREACH_FUNCTION(const BaseClassInstance& base, curClass->baseClasses) {
             DUChainReadLocker lock(DUChain::lock());
             type = base.baseClass.type<StructureType>();
             if (!type) {
                 continue;
             }
             ClassDeclaration *nextClass = dynamic_cast<ClassDeclaration*>(type->declaration(currentContext()->topContext()));
             if (!nextClass || nextClass->classType() != ClassDeclarationData::Class) {
                 type.reset();
                 continue;
             }
             curClass = nextClass;
             break;
         }
         if (!type) {
             break;
         }
         {
             if (!type->internalContext(currentContext()->topContext())) {
                 continue;
             }
             foreach(Declaration * dec, type->internalContext(currentContext()->topContext())->findLocalDeclarations(ids.second.first(), startPos(node)))
             {
                 if (dec->isFunctionDeclaration()) {
                     ClassMethodDeclaration* func = dynamic_cast<ClassMethodDeclaration*>(dec);
                     if (!func || !wasEncountered(func)) {
                         continue;
                     }
                     // we cannot redeclare final classes ever
                     if (func->isFinal()) {
                         reportRedeclarationError(dec, node->methodName);
                         return true;
                     }
                     // also we may not redeclare an already abstract method, we would have to implement it
                     // TODO: original error message?
                     // -> Can't inherit abstract function class::func() (previously declared in otherclass)
                     else if (func->isAbstract() && node->modifiers->modifiers & ModifierAbstract) {
                         reportRedeclarationError(dec, node->methodName);
                         return true;
                     }
                 }
             }
         }
     }
     return false;
 }
 
 void DeclarationBuilder::visitClassStatement(ClassStatementAst *node)
 {
     setComment(formatComment(node, m_editor));
 
     ClassDeclaration *parent =  dynamic_cast<ClassDeclaration*>(currentDeclaration());
     Q_ASSERT(parent);
 
     if (node->methodName) {
         //method declaration
 
         IdentifierPair ids = identifierPairForNode(node->methodName);
         if (m_reportErrors) {   // check for redeclarations
             Q_ASSERT(currentContext()->type() == DUContext::Class);
             bool localError = false;
             {
                 DUChainWriteLocker lock(DUChain::lock());
                 foreach(Declaration * dec, currentContext()->findLocalDeclarations(ids.second.first(), startPos(node->methodName)))
                 {
                     if (wasEncountered(dec) && dec->isFunctionDeclaration() && !dynamic_cast<TraitMethodAliasDeclaration*>(dec)) {
                         reportRedeclarationError(dec, node->methodName);
                         localError = true;
                         break;
                     }
                 }
             }
 
             if (!localError) {
                 // if we have no local error, check that we don't try to overwrite a final method of a baseclass
                 isBaseMethodRedeclaration(ids, parent, node);
             }
         }
 
         {
             DUChainWriteLocker lock(DUChain::lock());
             ClassMethodDeclaration* dec = openDefinition<ClassMethodDeclaration>(ids.second, editorFindRange(node->methodName, node->methodName));
             dec->setPrettyName(ids.first);
             dec->clearDefaultParameters();
             dec->setKind(Declaration::Type);
             if (node->modifiers->modifiers & ModifierPublic) {
                 dec->setAccessPolicy(Declaration::Public);
             } else if (node->modifiers->modifiers & ModifierProtected) {
                 dec->setAccessPolicy(Declaration::Protected);
             } else if (node->modifiers->modifiers & ModifierPrivate) {
                 dec->setAccessPolicy(Declaration::Private);
             }
             if (node->modifiers->modifiers & ModifierStatic) {
                 dec->setStatic(true);
             }
             if (parent->classType() == ClassDeclarationData::Interface) {
                 if (m_reportErrors) {
                     if (node->modifiers->modifiers & ModifierFinal || node->modifiers->modifiers & ModifierAbstract) {
                         reportError(i18n("Access type for interface method %1 must be omitted.",
                                          dec->toString()), node->modifiers);
                     }
                     if (!isEmptyMethodBody(node->methodBody)) {
                         reportError(i18n("Interface function %1 cannot contain body.",
                                          dec->toString()), node->methodBody);
                     }
                 }
                 // handle interface methods like abstract methods
                 dec->setIsAbstract(true);
             } else {
                 if (node->modifiers->modifiers & ModifierAbstract) {
                     if (!m_reportErrors) {
                         dec->setIsAbstract(true);
                     } else {
                         if (parent->classModifier() != ClassDeclarationData::Abstract && parent->classType() != ClassDeclarationData::Trait) {
                             reportError(i18n("Class %1 contains abstract method %2 and must therefore be declared abstract "
                                              "or implement the method.",
                                              parent->identifier().toString(),
                                              dec->identifier().toString()),
                                         node->modifiers);
                         } else if (!isEmptyMethodBody(node->methodBody)) {
                             reportError(i18n("Abstract function %1 cannot contain body.",
                                              dec->toString()), node->methodBody);
                         } else if (node->modifiers->modifiers & ModifierFinal) {
                             reportError(i18n("Cannot use the final modifier on an abstract class member."),
                                         node->modifiers);
                         } else {
                             dec->setIsAbstract(true);
                         }
                     }
                 } else if (node->modifiers->modifiers & ModifierFinal) {
                     dec->setIsFinal(true);
                 }
                 if (m_reportErrors && !dec->isAbstract() && isEmptyMethodBody(node->methodBody)) {
                     reportError(i18n("Non-abstract method %1 must contain body.", dec->toString()), node->methodBody);
                 }
             }
         }
 
         DeclarationBuilderBase::visitClassStatement(node);
 
         closeDeclaration();
     } else if (node->traitsSequence) {
         DeclarationBuilderBase::visitClassStatement(node);
 
         importTraitMethods(node);
     } else if (node->constsSequence) {
         if (node->modifiers) {
             m_currentModifers = node->modifiers->modifiers;
             if (m_reportErrors) {
                 // have to report the errors here to get a good problem range
                 if (m_currentModifers & ModifierFinal) {
                     reportError(i18n("Cannot use 'final' as constant modifier"), node->modifiers);
                 }
                 if (m_currentModifers & ModifierStatic) {
                     reportError(i18n("Cannot use 'static' as constant modifier"), node->modifiers);
                 }
                 if (m_currentModifers & ModifierAbstract) {
                     reportError(i18n("Cannot use 'abstract' as constant modifier"), node->modifiers);
                 }
             }
         } else {
             m_currentModifers = 0;
         }
         DeclarationBuilderBase::visitClassStatement(node);
         m_currentModifers = 0;
     } else {
         if (node->modifiers) {
             m_currentModifers = node->modifiers->modifiers;
             if (m_reportErrors) {
                 // have to report the errors here to get a good problem range
                 if (m_currentModifers & ModifierFinal) {
                     reportError(i18n("Properties cannot be declared final."), node->modifiers);
                 }
                 if (m_currentModifers & ModifierAbstract) {
                     reportError(i18n("Properties cannot be declared abstract."), node->modifiers);
                 }
             }
         } else {
             m_currentModifers = 0;
         }
         DeclarationBuilderBase::visitClassStatement(node);
         m_currentModifers = 0;
     }
 }
 
 void DeclarationBuilder::importTraitMethods(ClassStatementAst *node)
 {
     // Add trait members that don't need special handling
     const KDevPG::ListNode< NamespacedIdentifierAst* >* it = node->traitsSequence->front();
     DUChainWriteLocker lock;
     forever {
         DeclarationPointer dec =  findDeclarationImport(ClassDeclarationType, identifierForNamespace(it->element, m_editor));
 
         if (!dec || !dec->internalContext()) {
             break;
         }
 
         QVector <Declaration*> declarations = dec.data()->internalContext()->localDeclarations(nullptr);
         QVector <Declaration*> localDeclarations = currentContext()->localDeclarations(nullptr);
 
         ifDebug(qCDebug(DUCHAIN) << "Importing from" << dec.data()->identifier().toString() << "to" << currentContext()->localScopeIdentifier().toString();)
 
         foreach (Declaration* import, declarations) {
             Declaration* found = nullptr;
             foreach (Declaration* local, localDeclarations) {
                 ifDebug(qCDebug(DUCHAIN) << "Comparing" << import->identifier().toString() << "with" << local->identifier().toString();)
                 if (auto trait = dynamic_cast<TraitMethodAliasDeclaration*>(local)) {
                     if (trait->aliasedDeclaration().data() == import) {
                         ifDebug(qCDebug(DUCHAIN) << "Already imported";)
                         found = local;
                         break;
                     }
                     if (local->identifier() == import->identifier()) {
                         ClassMethodDeclaration* importMethod = dynamic_cast<ClassMethodDeclaration*>(import);
                         if (trait->isOverriding(import->context()->indexedLocalScopeIdentifier())) {
                             ifDebug(qCDebug(DUCHAIN) << "Is overridden";)
                             found = local;
                             break;
                         } else if (importMethod) {
                             reportError(
                                 i18n("Trait method %1 has not been applied, because there are collisions with other trait methods on %2")
                                 .arg(importMethod->prettyName().str(),
                                      dynamic_cast<ClassDeclaration*>(currentDeclaration())->prettyName().str())
                                 , it->element, IProblem::Error
                             );
                             found = local;
                             break;
                         }
                     }
                 }
                 if (auto trait = dynamic_cast<TraitMemberAliasDeclaration*>(local)) {
                     if (trait->aliasedDeclaration().data() == import) {
                         ifDebug(qCDebug(DUCHAIN) << "Already imported";)
                         found = local;
                         break;
                     }
                 }
                 if (local->identifier() == import->identifier()) {
                     if (dynamic_cast<ClassMemberDeclaration*>(local) && dynamic_cast<ClassMemberDeclaration*>(import)) {
                         found = local;
                         break;
                     }
                 }
             }
 
             if (found) {
                 setEncountered(found);
                 continue;
             }
 
             ifDebug(qCDebug(DUCHAIN) << "Importing new declaration";)
 
             CursorInRevision cursor = m_editor->findRange(it->element).start;
 
             if (auto olddec = dynamic_cast<const ClassMethodDeclaration*>(import)) {
                 TraitMethodAliasDeclaration* newdec = openDefinition<TraitMethodAliasDeclaration>(olddec->qualifiedIdentifier(), RangeInRevision(cursor, cursor));
                 openAbstractType(olddec->abstractType());
                 newdec->setPrettyName(olddec->prettyName());
                 newdec->setAccessPolicy(olddec->accessPolicy());
                 newdec->setKind(Declaration::Type);
                 newdec->setAliasedDeclaration(IndexedDeclaration(olddec));
                 newdec->setStatic(olddec->isStatic());
                 closeType();
                 closeDeclaration();
             } else if (auto olddec = dynamic_cast<const ClassMemberDeclaration*>(import)) {
                 TraitMemberAliasDeclaration* newdec = openDefinition<TraitMemberAliasDeclaration>(olddec->qualifiedIdentifier(), RangeInRevision(cursor, cursor));
                 openAbstractType(olddec->abstractType());
                 newdec->setAccessPolicy(olddec->accessPolicy());
                 newdec->setKind(Declaration::Instance);
                 newdec->setAliasedDeclaration(IndexedDeclaration(olddec));
                 newdec->setStatic(olddec->isStatic());
                 closeType();
                 closeDeclaration();
             }
 
         }
 
         if ( it->hasNext() ) {
             it = it->next;
         } else {
             break;
         }
     }
 }
 
 void DeclarationBuilder::visitClassExtends(ClassExtendsAst *node)
 {
     addBaseType(node->identifier);
 }
 
 void DeclarationBuilder::visitClassImplements(ClassImplementsAst *node)
 {
     const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
     do {
         addBaseType(__it->element);
         __it = __it->next;
     } while (__it != __end);
     DeclarationBuilderBase::visitClassImplements(node);
 }
 
 void DeclarationBuilder::visitClassVariable(ClassVariableAst *node)
 {
     QualifiedIdentifier name = identifierForNode(node->variable);
     if (m_reportErrors) {   // check for redeclarations
         DUChainWriteLocker lock(DUChain::lock());
         Q_ASSERT(currentContext()->type() == DUContext::Class);
         foreach(Declaration * dec, currentContext()->findLocalDeclarations(name.first(), startPos(node)))
         {
             if (wasEncountered(dec) && !dec->isFunctionDeclaration() && dec->abstractType() && !(dec->abstractType()->modifiers() & AbstractType::ConstModifier)) {
                 reportRedeclarationError(dec, node);
                 break;
             }
         }
     }
     openClassMemberDeclaration(node->variable, name);
     DeclarationBuilderBase::visitClassVariable(node);
     closeDeclaration();
 }
 
 void DeclarationBuilder::openClassMemberDeclaration(AstNode* node, const QualifiedIdentifier &name)
 {
     DUChainWriteLocker lock(DUChain::lock());
 
     // dirty hack: declarations of class members outside the class context would
     //             make the class context encompass the newRange. This is not what we want.
     RangeInRevision oldRange = currentContext()->range();
 
     RangeInRevision newRange = editorFindRange(node, node);
     openDefinition<ClassMemberDeclaration>(name, newRange);
 
     ClassMemberDeclaration* dec = dynamic_cast<ClassMemberDeclaration*>(currentDeclaration());
     Q_ASSERT(dec);
     if (m_currentModifers & ModifierPublic) {
         dec->setAccessPolicy(Declaration::Public);
     } else if (m_currentModifers & ModifierProtected) {
         dec->setAccessPolicy(Declaration::Protected);
     } else if (m_currentModifers & ModifierPrivate) {
         dec->setAccessPolicy(Declaration::Private);
     }
     if (m_currentModifers & ModifierStatic) {
         dec->setStatic(true);
     }
     dec->setKind(Declaration::Instance);
 
     currentContext()->setRange(oldRange);
 }
 
 void DeclarationBuilder::declareClassMember(DUContext *parentCtx, AbstractType::Ptr type,
                                                 const QualifiedIdentifier& identifier,
                                                 AstNode* node )
 {
     if ( m_upcomingClassVariables.contains(identifier) ) {
         if (m_actuallyRecompiling) {
             DUChainWriteLocker lock;
             if (Declaration* dec = currentContext()->findDeclarationAt(startPos(node))) {
                 if (dynamic_cast<ClassMemberDeclaration*>(dec)) {
                     // invalidate declaration, it got added
                     // see also bug https://bugs.kde.org/show_bug.cgi?id=241750
                     delete dec;
                 }
             }
         }
         return;
     }
 
     DUChainWriteLocker lock(DUChain::lock());
 
     // this member should be public and non-static
     m_currentModifers = ModifierPublic;
     injectContext(parentCtx);
     openClassMemberDeclaration(node, identifier);
     m_currentModifers = 0;
     //own closeDeclaration() that doesn't use lastType()
     currentDeclaration()->setType(type);
     eventuallyAssignInternalContext();
     DeclarationBuilderBase::closeDeclaration();
     closeInjectedContext();
 }
 
 void DeclarationBuilder::visitConstantDeclaration(ConstantDeclarationAst *node)
 {
     DUChainWriteLocker lock(DUChain::lock());
     if (m_reportErrors) {
         // check for redeclarations
         foreach(Declaration * dec, currentContext()->findLocalDeclarations(identifierForNode(node->identifier).first(), startPos(node->identifier)))
         {
             if (wasEncountered(dec) && !dec->isFunctionDeclaration() && dec->abstractType() && dec->abstractType()->modifiers() & AbstractType::ConstModifier) {
                 reportRedeclarationError(dec, node->identifier);
                 break;
             }
         }
     }
     ClassMemberDeclaration* dec = openDefinition<ClassMemberDeclaration>(identifierForNode(node->identifier), m_editor->findRange(node->identifier));
     {
         DUChainWriteLocker lock(DUChain::lock());
         dec->setAccessPolicy(Declaration::Public);
         dec->setStatic(true);
         dec->setKind(Declaration::Instance);
     }
     DeclarationBuilderBase::visitConstantDeclaration(node);
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitClassConstantDeclaration(ClassConstantDeclarationAst *node)
 {
     DUChainWriteLocker lock;
     if (m_reportErrors) {
         // Check for constants in traits
         if (isMatch(currentDeclaration(), ClassDeclarationType)) {
             ClassDeclaration *parent =  dynamic_cast<ClassDeclaration*>(currentDeclaration());
             Q_ASSERT(parent);
 
             if (parent->classType() == ClassDeclarationData::Trait) {
                 reportError(i18n("Traits cannot have constants."), node);
             }
         }
 
         // check for 'class' constant
         if (identifierForNode(node->identifier).toString().toLower() == QLatin1String("class"))
         {
             reportError(i18n("A class constant must not be called 'class'; it is reserved for class name fetching"), node);
         }
 
         // check for redeclarations
         foreach(Declaration * dec, currentContext()->findLocalDeclarations(identifierForNode(node->identifier).first(), startPos(node->identifier)))
         {
             if (wasEncountered(dec) && !dec->isFunctionDeclaration() && dec->abstractType() && dec->abstractType()->modifiers() & AbstractType::ConstModifier) {
                 reportRedeclarationError(dec, node->identifier);
                 break;
             }
         }
     }
     ClassMemberDeclaration* dec = openDefinition<ClassMemberDeclaration>(identifierForNode(node->identifier), m_editor->findRange(node->identifier));
     if (m_currentModifers & ModifierProtected) {
         dec->setAccessPolicy(Declaration::Protected);
     } else if (m_currentModifers & ModifierPrivate) {
         dec->setAccessPolicy(Declaration::Private);
     } else {
         dec->setAccessPolicy(Declaration::Public);
     }
     dec->setStatic(true);
     dec->setKind(Declaration::Instance);
     lock.unlock();
 
     DeclarationBuilderBase::visitClassConstantDeclaration(node);
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitTraitAliasStatement(TraitAliasStatementAst *node)
 {
     DUChainWriteLocker lock;
 
     DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, identifierForNamespace(node->importIdentifier->identifier, m_editor));
 
     if (dec && dec.data()->internalContext()) {
         createTraitAliasDeclarations(node, dec);
     }
 
     lock.unlock();
     DeclarationBuilderBase::visitTraitAliasStatement(node);
 }
 
 void DeclarationBuilder::createTraitAliasDeclarations(TraitAliasStatementAst *node, DeclarationPointer dec)
 {
     QualifiedIdentifier original = identifierPairForNode(node->importIdentifier->methodIdentifier).second;
     QList <Declaration*> list = dec.data()->internalContext()->findLocalDeclarations(original.last(), dec.data()->internalContext()->range().start);
 
     QualifiedIdentifier alias;
     if (node->aliasIdentifier) {
         alias = identifierPairForNode(node->aliasIdentifier).second;
     } else if (node->aliasNonModifierIdentifier) {
         alias = identifierPairForNode(node->aliasNonModifierIdentifier).second;
     } else {
         alias = original;
     }
 
     if (!list.isEmpty()) {
         ClassMethodDeclaration* olddec = dynamic_cast<ClassMethodDeclaration*>(list.first());
         TraitMethodAliasDeclaration* newdec;
 
         // no existing declaration found, create one
         if (node->aliasIdentifier || node->aliasNonModifierIdentifier) {
             if (node->aliasIdentifier) {
                 newdec = openDefinition<TraitMethodAliasDeclaration>(alias, m_editor->findRange(node->aliasIdentifier));
                 newdec->setPrettyName(identifierPairForNode(node->aliasIdentifier).first);
             } else {
                 newdec = openDefinition<TraitMethodAliasDeclaration>(alias, m_editor->findRange(node->aliasNonModifierIdentifier));
                 newdec->setPrettyName(identifierPairForNode(node->aliasNonModifierIdentifier).first);
             }
             newdec->setAccessPolicy(olddec->accessPolicy());
             openAbstractType(olddec->abstractType());
             if (node->modifiers) {
                 if (node->modifiers->modifiers & ModifierPublic) {
                     newdec->setAccessPolicy(Declaration::Public);
                 } else if (node->modifiers->modifiers & ModifierProtected) {
                     newdec->setAccessPolicy(Declaration::Protected);
                 } else if (node->modifiers->modifiers & ModifierPrivate) {
                     newdec->setAccessPolicy(Declaration::Private);
                 }
 
                 if (node->modifiers->modifiers & ModifierAbstract) {
                     reportError(i18n("Cannot use 'abstract' as method modifier"), node->modifiers, IProblem::Error);
                 }
                 if (node->modifiers->modifiers & ModifierFinal) {
                     reportError(i18n("Cannot use 'final' as method modifier"), node->modifiers, IProblem::Error);
                 }
                 if (node->modifiers->modifiers & ModifierStatic) {
                     reportError(i18n("Cannot use 'static' as method modifier"), node->modifiers, IProblem::Error);
                 }
             }
         } else {
             CursorInRevision cursor = m_editor->findRange(node->importIdentifier).start;
             newdec = openDefinition<TraitMethodAliasDeclaration>(alias, RangeInRevision(cursor, cursor));
             newdec->setPrettyName(identifierPairForNode(node->importIdentifier->methodIdentifier).first);
             newdec->setAccessPolicy(olddec->accessPolicy());
             openAbstractType(olddec->abstractType());
 
             if (node->modifiers) {
                 if (node->modifiers->modifiers & ModifierPublic) {
                     newdec->setAccessPolicy(Declaration::Public);
                 } else if (node->modifiers->modifiers & ModifierProtected) {
                     newdec->setAccessPolicy(Declaration::Protected);
                 } else if (node->modifiers->modifiers & ModifierPrivate) {
                     newdec->setAccessPolicy(Declaration::Private);
                 }
 
                 if (node->modifiers->modifiers & ModifierAbstract) {
                     reportError(i18n("Cannot use 'abstract' as method modifier"), node->modifiers, IProblem::Error);
                 }
                 if (node->modifiers->modifiers & ModifierFinal) {
                     reportError(i18n("Cannot use 'final' as method modifier"), node->modifiers, IProblem::Error);
                 }
                 if (node->modifiers->modifiers & ModifierStatic) {
                     reportError(i18n("Cannot use 'static' as method modifier"), node->modifiers, IProblem::Error);
                 }
             }
         }
         newdec->setKind(Declaration::Type);
         newdec->setAliasedDeclaration(IndexedDeclaration(olddec));
         newdec->setStatic(olddec->isStatic());
 
         QVector <IndexedQualifiedIdentifier> ids;
 
         if (node->conflictIdentifierSequence) {
             const KDevPG::ListNode< NamespacedIdentifierAst* >* it = node->conflictIdentifierSequence->front();
             forever {
                 DeclarationPointer dec =  findDeclarationImport(ClassDeclarationType, identifierForNamespace(it->element, m_editor));
                 if (dec) {
                     ids.append(IndexedQualifiedIdentifier(dec.data()->qualifiedIdentifier()));
                 }
 
                 if ( it->hasNext() ) {
                     it = it->next;
                 } else {
                     break;
                 }
             }
 
             newdec->setOverrides(ids);
         }
 
         closeType();
         closeDeclaration();
     }
 }
 
 void DeclarationBuilder::visitParameterList(ParameterListAst* node)
 {
     PushValue<ParameterAst*> push(m_functionDeclarationPreviousArgument, nullptr);
 
     DeclarationBuilderBase::visitParameterList(node);
 }
 
 void DeclarationBuilder::visitParameter(ParameterAst *node)
 {
     AbstractFunctionDeclaration* funDec = dynamic_cast<AbstractFunctionDeclaration*>(currentDeclaration());
     Q_ASSERT(funDec);
 
     if (node->defaultValue) {
         QString symbol = m_editor->parseSession()->symbol(node->defaultValue);
         funDec->addDefaultParameter(IndexedString(symbol));
         if (node->isVariadic != -1) {
             reportError(i18n("Variadic parameter cannot have a default value"), node->defaultValue);
         } else if (node->parameterType && node->parameterType->typehint && hasClassTypehint(node->parameterType->typehint, m_editor) &&
                 symbol.compare(QLatin1String("null"), Qt::CaseInsensitive) != 0) {
             reportError(i18n("Default value for parameters with a class type hint can only be NULL."), node->defaultValue);
         }
     } else {
         funDec->addDefaultParameter(IndexedString{});
     }
     {
         // create variable declaration for argument
         DUChainWriteLocker lock(DUChain::lock());
         RangeInRevision newRange = editorFindRange(node->variable, node->variable);
         VariableDeclaration *dec = openDefinition<VariableDeclaration>(identifierForNode(node->variable), newRange);
         dec->setKind(Declaration::Instance);
         dec->setVariadic(node->isVariadic != -1);
     }
 
     DeclarationBuilderBase::visitParameter(node);
 
     if (m_functionDeclarationPreviousArgument && m_functionDeclarationPreviousArgument->isVariadic != -1) {
         reportError(i18n("Only the last parameter can be variadic."), m_functionDeclarationPreviousArgument);
     }
 
     closeDeclaration();
 
     m_functionDeclarationPreviousArgument = node;
 }
 
 void DeclarationBuilder::visitFunctionDeclarationStatement(FunctionDeclarationStatementAst* node)
 {
     isGlobalRedeclaration(identifierForNode(node->functionName), node->functionName, FunctionDeclarationType);
 
     FunctionDeclaration* dec = m_functions.value(node->functionName->string, nullptr);
     Q_ASSERT(dec);
     // seems like we have to set that, else the usebuilder crashes
 
     DeclarationBuilderBase::setEncountered(dec);
 
     openDeclarationInternal(dec);
     openType(dec->abstractType());
 
     DeclarationBuilderBase::visitFunctionDeclarationStatement(node);
 
     closeType();
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitGenericTypeHint(GenericTypeHintAst* node) {
     if (node->genericType && isGenericClassTypehint(node->genericType, m_editor)) {
         NamespacedIdentifierAst* typehintNode = node->genericType;
         const KDevPG::ListNode< IdentifierAst* >* it = typehintNode->namespaceNameSequence->back();
         QString className = m_editor->parseSession()->symbol(it->element);
 
         if (isReservedClassName(className)) {
             reportError(i18n("Cannot use '%1' as class name as it is reserved", className), typehintNode);
         }
     }
 }
 
 void DeclarationBuilder::visitClosure(ClosureAst* node)
 {
     setComment(formatComment(node, editor()));
     {
         DUChainWriteLocker lock;
         FunctionDeclaration *dec = openDefinition<FunctionDeclaration>(QualifiedIdentifier(),
                                                                        editor()->findRange(node->startToken));
         dec->setKind(Declaration::Type);
         dec->clearDefaultParameters();
     }
 
     DeclarationBuilderBase::visitClosure(node);
 
     closeDeclaration();
 }
 void DeclarationBuilder::visitLexicalVar(LexicalVarAst* node)
 {
     DeclarationBuilderBase::visitLexicalVar(node);
 
     QualifiedIdentifier id = identifierForNode(node->variable);
     DUChainWriteLocker lock;
     if ( recompiling() ) {
         // sadly we can't use findLocalDeclarations() here, since it un-aliases declarations
         foreach ( Declaration* dec, currentContext()->localDeclarations() ) {
             if ( dynamic_cast<AliasDeclaration*>(dec) && dec->identifier() == id.first() ) {
                 // don't redeclare but reuse the existing declaration
                 encounter(dec);
                 return;
             }
         }
     }
 
     // no existing declaration found, create one
     foreach(Declaration* aliasedDeclaration, currentContext()->findDeclarations(id)) {
         if (aliasedDeclaration->kind() == Declaration::Instance) {
             AliasDeclaration* dec = openDefinition<AliasDeclaration>(id, editor()->findRange(node->variable));
             dec->setAliasedDeclaration(aliasedDeclaration);
             closeDeclaration();
             break;
         }
     }
 }
 
 bool DeclarationBuilder::isGlobalRedeclaration(const QualifiedIdentifier &identifier, AstNode* node,
         DeclarationType type)
 {
     if (!m_reportErrors) {
         return false;
     }
     ///TODO: method redeclaration etc.
     if (type != ClassDeclarationType
             && type != FunctionDeclarationType
             && type != ConstantDeclarationType) {
         // the other types can be redeclared
         return false;
     }
 
     DUChainWriteLocker lock(DUChain::lock());
     QList<Declaration*> declarations = currentContext()->topContext()->findDeclarations( identifier, startPos(node) );
     foreach(Declaration* dec, declarations) {
         if (wasEncountered(dec) && isMatch(dec, type)) {
             reportRedeclarationError(dec, node);
             return true;
         }
     }
     return false;
 }
 
 void DeclarationBuilder::reportRedeclarationError(Declaration* declaration, AstNode* node)
 {
     if (declaration->range().contains(startPos(node))) {
         // make sure this is not a wrongly reported redeclaration error
         return;
     }
     if (declaration->context()->topContext()->url() == internalFunctionFile()) {
         reportError(i18n("Cannot redeclare PHP internal %1.", declaration->toString()), node);
     } else if (auto trait = dynamic_cast<TraitMemberAliasDeclaration*>(declaration)) {
         reportError(
             i18n("%1 and %2 define the same property (%3) in the composition of %1. This might be incompatible, to improve maintainability consider using accessor methods in traits instead.")
             .arg(dynamic_cast<ClassDeclaration*>(currentDeclaration())->prettyName().str(),
                  dynamic_cast<ClassDeclaration*>(trait->aliasedDeclaration().data()->context()->owner())->prettyName().str(),
                  dynamic_cast<ClassMemberDeclaration*>(trait)->identifier().toString()), node, IProblem::Warning
         );
     } else {
         ///TODO: try to shorten the filename by removing the leading path to the current project
         reportError(
             i18n("Cannot redeclare %1, already declared in %2 on line %3.",
                  declaration->toString(), declaration->context()->topContext()->url().str(), declaration->range().start.line + 1
                 ), node
         );
     }
 }
 void DeclarationBuilder::visitOuterTopStatement(OuterTopStatementAst* node)
 {
     //docblock of an AssignmentExpression
     setComment(formatComment(node, m_editor));
     m_lastTopStatementComment = m_editor->parseSession()->docComment(node->startToken);
 
     DeclarationBuilderBase::visitOuterTopStatement(node);
 }
 
 void DeclarationBuilder::visitAssignmentExpression(AssignmentExpressionAst* node)
 {
     if ( node->assignmentExpressionEqual ) {
         PushValue<FindVariableResults> restore(m_findVariable);
 
         DeclarationBuilderBase::visitAssignmentExpression(node);
     } else {
         DeclarationBuilderBase::visitAssignmentExpression(node);
     }
 }
 
 void DeclarationBuilder::visitVariable(VariableAst* node)
 {
     if ( m_findVariable.find ) {
         getVariableIdentifier(node, m_findVariable.identifier, m_findVariable.parentIdentifier,
                               m_findVariable.node, m_findVariable.isArray);
         m_findVariable.find = false;
     }
     DeclarationBuilderBase::visitVariable(node);
 }
 
 void DeclarationBuilder::declareVariable(DUContext* parentCtx, AbstractType::Ptr type,
                                             const QualifiedIdentifier& identifier,
                                             AstNode* node)
 {
     DUChainWriteLocker lock(DUChain::lock());
 
     // we must not re-assign $this in a class context
     /// Qualified identifier for 'this'
     static const QualifiedIdentifier thisQId(QStringLiteral("this"));
     if ( identifier == thisQId
             && currentContext()->parentContext()
             && currentContext()->parentContext()->type() == DUContext::Class ) {
 
         // checks if imports \ArrayAccess
         ClassDeclaration* currentClass = dynamic_cast<ClassDeclaration*>(currentContext()->parentContext()->owner());
         ClassDeclaration* arrayAccess = nullptr;
 
         auto imports = currentContext()->parentContext()->importedParentContexts();
         for( const DUContext::Import& ctx : imports ) {
             DUContext* import = ctx.context(topContext());
             if(import->type() == DUContext::Class) {
                 ClassDeclaration* importedClass = dynamic_cast<ClassDeclaration*>(import->owner());
                 if(importedClass) {
                     if(importedClass->prettyName().str() == "ArrayAccess" && importedClass->classType() == ClassDeclarationData::ClassType::Interface && !import->parentContext()->owner()) {
                         arrayAccess = importedClass;
                     }
                 }
             }
         }
 
         IntegralType* thisVar = static_cast<IntegralType*>(type.data());
         // check if this is used as array
         if(arrayAccess && currentClass && thisVar && thisVar->dataType() == AbstractType::TypeArray)
         {
             uint noOfFunc = 0;
             auto declarations = currentContext()->parentContext()->localDeclarations();
             // check if class implements all 4 functions
             for(auto &dec : declarations) {
                 if(dec->isFunctionDeclaration()) {
                     QualifiedIdentifier func = dec->qualifiedIdentifier();
                     QString funcname = func.last().identifier().str();
                     if(funcname == "offsetexists" || funcname == "offsetget" || funcname == "offsetset" || funcname == "offsetunset") {
                         noOfFunc++;
                     }
                 }
             }
 
             if(noOfFunc < 4) {
                 // check if class is not abstract
                 if(currentClass->classModifier() != ClassDeclarationData::ClassModifier::Abstract) {
                     reportError(i18n("Class %1 contains %2 abstract methods and must therefore be declared abstract or implement the remaining methods.",currentClass->prettyName().str(),4-noOfFunc), QList<AstNode*>() << node);
                 }
             }
 
             return;
         }
 
         reportError(i18n("Cannot re-assign $this."), QList<AstNode*>() << node);
         return;
     }
 
     const RangeInRevision newRange = editorFindRange(node, node);
 
     // check if this variable is already declared
     {
         QList< Declaration* > decs = parentCtx->findDeclarations(identifier.first(), startPos(node), nullptr, DUContext::DontSearchInParent);
         if ( !decs.isEmpty() ) {
             QList< Declaration* >::const_iterator it = decs.constEnd() - 1;
             while ( true ) {
                 // we expect that the list of declarations has the newest declaration at back
                 if ( dynamic_cast<VariableDeclaration*>( *it ) ) {
                     if (!wasEncountered(*it)) {
                         encounter(*it);
                         // force new range https://bugs.kde.org/show_bug.cgi?id=262189,
                         // might be wrong when we had syntax errors in there before
                         (*it)->setRange(newRange);
                     }
                     if ( (*it)->abstractType() && !(*it)->abstractType()->equals(type.data()) ) {
                         // if it's currently mixed and we now get something more definite, use that instead
                         if ( auto rType = (*it)->abstractType().dynamicCast<ReferenceType>() ) {
                             if ( auto integral = rType->baseType().dynamicCast<IntegralType>() ) {
                                 if ( integral->dataType() == IntegralType::TypeMixed ) {
                                     // referenced mixed to referenced @p type
                                     ReferenceType::Ptr newType(new ReferenceType());
                                     newType->setBaseType(type);
                                     (*it)->setType(newType);
                                     return;
                                 }
                             }
                         }
                         if ( auto integral = (*it)->abstractType().dynamicCast<IntegralType>() ) {
                             if ( integral->dataType() == IntegralType::TypeMixed ) {
                                 // mixed to @p type
                                 (*it)->setType(type);
                                 return;
                             }
                         }
                         // else make it unsure
                         auto unsure = (*it)->abstractType().dynamicCast<UnsureType>();
                         // maybe it's referenced?
                         auto rType = (*it)->abstractType().dynamicCast<ReferenceType>();
                         if ( !unsure && rType ) {
                             unsure = rType->baseType().dynamicCast<UnsureType>();
                         }
                         if ( !unsure ) {
                             unsure = UnsureType::Ptr(new UnsureType());
                             if ( rType ) {
                                 unsure->addType(rType->baseType()->indexed());
                             } else {
                                 unsure->addType((*it)->indexedType());
                             }
                         }
                         unsure->addType(type->indexed());
                         if ( rType ) {
                             rType->setBaseType(AbstractType::Ptr(unsure.data()));
                             (*it)->setType(rType);
                         } else {
                             (*it)->setType(unsure);
                         }
                     }
                     return;
                 }
                 if ( it == decs.constBegin() ) {
                     break;
                 }
                 --it;
             }
         }
     }
 
     VariableDeclaration *dec = openDefinition<VariableDeclaration>(identifier, newRange);
     dec->setKind(Declaration::Instance);
     if (!m_lastTopStatementComment.isEmpty()) {
         QRegExp rx("(\\*|///)\\s*@superglobal");
         if (rx.indexIn(m_lastTopStatementComment) != -1) {
             dec->setSuperglobal(true);
         }
     }
     //own closeDeclaration() that doesn't use lastType()
     dec->setType(type);
 
     // variable declarations are not namespaced in PHP
     if (currentContext()->type() == DUContext::Namespace) {
         dec->setContext(currentContext()->topContext());
     }
 
     eventuallyAssignInternalContext();
     DeclarationBuilderBase::closeDeclaration();
 }
 
 DUContext* getClassContext(const QualifiedIdentifier &identifier, DUContext* currentCtx) {
     /// Qualified identifier for 'this'
     static const QualifiedIdentifier thisQId(QStringLiteral("this"));
     if ( identifier == thisQId ) {
         if ( currentCtx->parentContext() && currentCtx->parentContext()->type() == DUContext::Class ) {
             return currentCtx->parentContext();
         }
     } else {
         DUChainReadLocker lock(DUChain::lock());
         foreach( Declaration* parent, currentCtx->topContext()->findDeclarations(identifier) ) {
             if ( StructureType::Ptr ctype = parent->type<StructureType>() ) {
                 return ctype->internalContext(currentCtx->topContext());
             }
         }
         ///TODO: if we can't find anything here we might have to use the findDeclarationImport helper
     }
     return nullptr;
 }
 
 ///TODO: we need to handle assignment to array-members properly
 ///      currently we just make sure the array is declared, but don't know
 ///      anything about its contents
 void DeclarationBuilder::visitAssignmentExpressionEqual(AssignmentExpressionEqualAst *node)
 {
     DeclarationBuilderBase::visitAssignmentExpressionEqual(node);
 
     bool alreadyDeclared = false;
 
     // check for already declared class members
     if (!m_findVariable.identifier.isEmpty() && !m_findVariable.parentIdentifier.isEmpty()) {
         DUContext* ctx = getClassContext(m_findVariable.parentIdentifier, currentContext());
         if (ctx) {
             DUChainReadLocker lock(DUChain::lock());
             ifDebug(qCDebug(DUCHAIN) << "checking if already declared: " << m_findVariable.identifier.toString();)
             QList<Declaration*> decs;
             foreach ( Declaration* dec, currentContext()->findDeclarations(m_findVariable.identifier) ) {
                 if ( dec->kind() == Declaration::Kind::Instance) {
                     if (dec->range() == editorFindRange(m_findVariable.node)) {
                         // Don't reuse previous declarations as the type might have changed.
                         continue;
                     }
 
                     ClassMemberDeclaration *classDec = dynamic_cast<ClassMemberDeclaration*>(dec);
 
                     if (classDec && classDec->accessPolicy() == Declaration::Private) {
                         if (currentContext()->parentContext() == dec->context()) {
                             decs << dec;
                             ifDebug(qCDebug(DUCHAIN) << "found class property:" << dec->toString();)
                         }
                     } else {
                         decs << dec;
                         ifDebug(qCDebug(DUCHAIN) << "found class property:" << dec->toString();)
                     }
                 }
             }
             lock.unlock();
 
             if (!decs.isEmpty()) {
                 Declaration * dec = decs.last();
 
                 if (dec) {
                     encounter(dec);
                     alreadyDeclared = true;
                     IntegralType::Ptr type = dec->type<IntegralType>();
 
                     if (type && type->dataType() == IntegralType::TypeNull) {
                         DUChainWriteLocker wlock;
                         dec->setAbstractType(currentAbstractType());
                     }
                 }
             }
 
             lock.lock();
             if (decs.isEmpty() && (!currentContext()->parentContext() || !currentContext()->parentContext()->imports(ctx))) {
                 ifDebug(qCDebug(DUCHAIN) << "nothing found in current context, look in class context of parent";)
                 QList<Declaration*> decs;
                 foreach ( Declaration* dec, ctx->findDeclarations(m_findVariable.identifier) ) {
                     if ( dec->kind() == Declaration::Kind::Instance) {
                         if (dec->range() == editorFindRange(m_findVariable.node)) {
                             // Don't reuse previous declarations as the type might have changed.
                             continue;
                         }
 
                         ifDebug(qCDebug(DUCHAIN) << "found class property:" << dec->toString();)
                         decs << dec;
                     }
                 }
                 lock.unlock();
 
                 if (!decs.isEmpty()) {
                     Declaration * dec = decs.last();
 
                     if (dec) {
                         alreadyDeclared = true;
                         IntegralType::Ptr type = dec->type<IntegralType>();
 
                         // check for redeclaration of private or protected stuff
                         DUContext *parentCtx = currentContext()->parentContext();
                         ClassMemberDeclaration *classDec = dynamic_cast<ClassMemberDeclaration*>(dec);
 
                         if (classDec && classDec->accessPolicy() == Declaration::Private && classDec->context() != parentCtx) {
                             reportError(i18n("Cannot access private property %1",
                                                 classDec->toString()), m_findVariable.node);
                         } else if (classDec && classDec->accessPolicy() == Declaration::Protected && classDec->context() != parentCtx) {
                             reportError(i18n("Cannot access protected property %1",
                                                 classDec->toString()), m_findVariable.node);
                         } else if (type && type->dataType() == IntegralType::TypeNull) {
                             DUChainWriteLocker wlock;
                             dec->setAbstractType(currentAbstractType());
                         }
                     }
                 }
             }
         }
     }
 
     if ( !alreadyDeclared && !m_findVariable.identifier.isEmpty() && currentAbstractType()) {
         ifDebug(qCDebug(DUCHAIN) << "not yet declared: " << m_findVariable.identifier.toString();)
         //create new declaration assignments to not-yet declared variables and class members
 
         AbstractType::Ptr type;
         if ( m_findVariable.isArray ) {
             // implicit array declaration
             type = AbstractType::Ptr(new IntegralType(IntegralType::TypeArray));
         } else {
             type = currentAbstractType();
         }
 
         if ( !m_findVariable.parentIdentifier.isEmpty() ) {
             // assignment to class members
 
             if ( DUContext* ctx = getClassContext(m_findVariable.parentIdentifier, currentContext()) ) {
                 declareClassMember(ctx, type, m_findVariable.identifier, m_findVariable.node);
             }
         } else {
             // assignment to other variables
             declareVariable(currentContext(), type, m_findVariable.identifier, m_findVariable.node );
         }
     }
 }
 
 void DeclarationBuilder::visitFunctionCall(FunctionCallAst* node)
 {
     QualifiedIdentifier id;
     if (!m_isInternalFunctions) {
         FunctionType::Ptr oldFunction = m_currentFunctionType;
 
         DeclarationPointer dec;
         if ( node->stringFunctionName ) {
             dec = findDeclarationImport(FunctionDeclarationType, node->stringFunctionName);
 
             if (!dec) {
                 dec = findDeclarationImport(FunctionDeclarationType, node->stringFunctionName, GlobalScope);
             }
         } else if ( node->stringFunctionNameOrClass ) {
             id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
             dec = findDeclarationImport(FunctionDeclarationType, id);
 
             if (!dec) {
                 id.setExplicitlyGlobal(true);
                 dec = findDeclarationImport(FunctionDeclarationType, id);
             }
         } else {
             ///TODO: node->varFunctionName
         }
 
         if ( dec ) {
             m_currentFunctionType = dec->type<FunctionType>();
         } else {
             m_currentFunctionType = nullptr;
         }
 
         DeclarationBuilderBase::visitFunctionCall(node);
 
         m_currentFunctionType = oldFunction;
     } else {
         // optimize for internal function file
         DeclarationBuilderBase::visitFunctionCall(node);
     }
 
     if (node->stringFunctionNameOrClass && !node->stringFunctionName && !node->varFunctionName) {
         if (id.toString(RemoveExplicitlyGlobalPrefix) == QLatin1String("define")
                 && node->stringParameterList && node->stringParameterList->parametersSequence
                 && node->stringParameterList->parametersSequence->count() > 0) {
             //constant, defined through define-function
 
             //find name of the constant (first argument of the function call)
             CommonScalarAst* scalar = findCommonScalar(node->stringParameterList->parametersSequence->at(0)->element);
             if (scalar && scalar->string != -1) {
                 QString constant = m_editor->parseSession()->symbol(scalar->string);
                 constant = constant.mid(1, constant.length() - 2);
                 RangeInRevision newRange = editorFindRange(scalar, scalar);
                 AbstractType::Ptr type;
                 if (node->stringParameterList->parametersSequence->count() > 1) {
                     type = getTypeForNode(node->stringParameterList->parametersSequence->at(1)->element);
                     Q_ASSERT(type);
                     type->setModifiers(type->modifiers() | AbstractType::ConstModifier);
                 } // TODO: else report error?
                 DUChainWriteLocker lock;
                 // find fitting context to put define in,
                 // pick first namespace or global context otherwise
                 DUContext* ctx = currentContext();
                 while (ctx->type() != DUContext::Namespace && ctx->parentContext()) {
                     ctx = ctx->parentContext();
                 }
                 injectContext(ctx); //constants are always global
                 QualifiedIdentifier identifier(constant);
                 isGlobalRedeclaration(identifier, scalar, ConstantDeclarationType);
                 Declaration* dec = openDefinition<Declaration>(identifier, newRange);
                 dec->setKind(Declaration::Instance);
                 if (type) {
                     dec->setType(type);
                     injectType(type);
                 }
                 closeDeclaration();
                 closeInjectedContext();
             }
         }
     }
 }
 
 void DeclarationBuilder::visitFunctionCallParameterList(FunctionCallParameterListAst* node)
 {
     PushValue<FunctionCallParameterListElementAst*> push(m_functionCallPreviousArgument, nullptr);
     PushValue<int> pos(m_functionCallParameterPos, 0);
 
     DeclarationBuilderBase::visitFunctionCallParameterList(node);
 }
 
 void DeclarationBuilder::visitFunctionCallParameterListElement(FunctionCallParameterListElementAst* node)
 {
     PushValue<FindVariableResults> restore(m_findVariable);
 
     DeclarationBuilderBase::visitFunctionCallParameterListElement(node);
 
     if ( m_findVariable.node && m_currentFunctionType &&
             m_currentFunctionType->arguments().count() > m_functionCallParameterPos) {
         ReferenceType::Ptr refType = m_currentFunctionType->arguments()
                                         .at(m_functionCallParameterPos).dynamicCast<ReferenceType>();
         if ( refType ) {
             // this argument is referenced, so if the node contains undeclared variables we have
             // to declare them with a NULL type, see also:
             // https://de.php.net/manual/en/language.references.whatdo.php
 
             // declare with NULL type, just like PHP does
             declareFoundVariable(AbstractType::Ptr(new IntegralType(IntegralType::TypeNull)));
         }
     }
 
     if (m_functionCallPreviousArgument && m_functionCallPreviousArgument->isVariadic != -1 && node->isVariadic == -1) {
         reportError(i18n("Cannot use positional argument after argument unpacking"), node);
     }
 
     m_functionCallPreviousArgument = node;
 
     ++m_functionCallParameterPos;
 }
 
 void DeclarationBuilder::visitAssignmentListElement(AssignmentListElementAst* node)
 {
     PushValue<FindVariableResults> restore(m_findVariable);
 
     DeclarationBuilderBase::DefaultVisitor::visitAssignmentListElement(node);
 
     if ( m_findVariable.node ) {
         ///TODO: get a proper type here, if possible
         declareFoundVariable(AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed)));
     }
 }
 
 void DeclarationBuilder::declareFoundVariable(AbstractType::Ptr type)
 {
     Q_ASSERT(m_findVariable.node);
 
     ///TODO: support something like: foo($var[0])
     if ( !m_findVariable.isArray ) {
         DUContext *ctx = nullptr;
         if ( m_findVariable.parentIdentifier.isEmpty() ) {
             ctx = currentContext();
         } else {
             ctx = getClassContext(m_findVariable.parentIdentifier, currentContext());
         }
         if ( ctx ) {
             bool isDeclared = false;
             {
                 DUChainWriteLocker lock(DUChain::lock());
                 RangeInRevision range = m_editor->findRange(m_findVariable.node);
                 foreach ( Declaration* dec, ctx->findDeclarations(m_findVariable.identifier) ) {
                     if ( dec->kind() == Declaration::Instance ) {
                         if (!wasEncountered(dec) || (dec->context() == ctx && range < dec->range())) {
                             // just like a "redeclaration", hence we must update the range
                             // TODO: do the same for all other uses of "encounter"?
                             dec->setRange(editorFindRange(m_findVariable.node));
                             encounter(dec);
                         }
                         isDeclared = true;
                         break;
                     }
                 }
             }
             if ( !isDeclared && m_findVariable.parentIdentifier.isEmpty() ) {
                 // check also for global vars
                 isDeclared = findDeclarationImport(GlobalVariableDeclarationType, m_findVariable.identifier);
             }
             if ( !isDeclared ) {
                 // couldn't find the dec, declare it
                 if ( !m_findVariable.parentIdentifier.isEmpty() ) {
                     declareClassMember(ctx, type, m_findVariable.identifier, m_findVariable.node);
                 } else {
                     declareVariable(ctx, type, m_findVariable.identifier, m_findVariable.node);
                 }
             }
         }
     }
 }
 
 void DeclarationBuilder::visitStatement(StatementAst* node)
 {
     DeclarationBuilderBase::visitStatement(node);
 
     if (node->foreachVariable) {
         PushValue<FindVariableResults> restore(m_findVariable);
         visitForeachVariable(node->foreachVariable);
         if (m_findVariable.node) {
             declareFoundVariable(lastType());
         }
     }
 
     if (node->foreachVarAsVar) {
         PushValue<FindVariableResults> restore(m_findVariable);
         visitForeachVariable(node->foreachVarAsVar);
         if (m_findVariable.node) {
             declareFoundVariable(lastType());
         }
     }
 
     if (node->foreachExprAsVar) {
         PushValue<FindVariableResults> restore(m_findVariable);
         visitVariable(node->foreachExprAsVar);
         if (m_findVariable.node) {
             declareFoundVariable(lastType());
         }
     }
 
 }
 
 void DeclarationBuilder::visitStaticVar(StaticVarAst* node)
 {
     DeclarationBuilderBase::visitStaticVar(node);
 
     DUChainWriteLocker lock(DUChain::lock());
     openDefinition<VariableDeclaration>(identifierForNode(node->var),
                                         editorFindRange(node->var, node->var));
     currentDeclaration()->setKind(Declaration::Instance);
 
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitGlobalVar(GlobalVarAst* node)
 {
     DeclarationBuilderBase::visitGlobalVar(node);
     if (node->var) {
         QualifiedIdentifier id = identifierForNode(node->var);
         if ( recompiling() ) {
             DUChainWriteLocker lock(DUChain::lock());
             // sadly we can't use findLocalDeclarations() here, since it un-aliases declarations
             foreach ( Declaration* dec, currentContext()->localDeclarations() ) {
                 if ( dynamic_cast<AliasDeclaration*>(dec) && dec->identifier() == id.first() ) {
                     // don't redeclare but reuse the existing declaration
                     encounter(dec);
                     return;
                 }
             }
         }
         // no existing declaration found, create one
         DeclarationPointer aliasedDeclaration = findDeclarationImport(GlobalVariableDeclarationType, node->var);
         if (aliasedDeclaration) {
             DUChainWriteLocker lock(DUChain::lock());
             AliasDeclaration* dec = openDefinition<AliasDeclaration>(id, m_editor->findRange(node->var));
             dec->setAliasedDeclaration(aliasedDeclaration.data());
             closeDeclaration();
         }
     }
 }
 
 void DeclarationBuilder::visitCatchItem(CatchItemAst *node)
 {
     DeclarationBuilderBase::visitCatchItem(node);
 
     DUChainWriteLocker lock(DUChain::lock());
     openDefinition<VariableDeclaration>(identifierForNode(node->var),
                                         editorFindRange(node->var, node->var));
     currentDeclaration()->setKind(Declaration::Instance);
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitUnaryExpression(UnaryExpressionAst* node)
 {
     DeclarationBuilderBase::visitUnaryExpression(node);
     IndexedString includeFile = getIncludeFileForNode(node, m_editor);
     if ( !includeFile.isEmpty() ) {
         DUChainWriteLocker lock;
         TopDUContext* includedCtx = DUChain::self()->chainForDocument(includeFile);
         if ( !includedCtx ) {
             // invalid include
             return;
         }
 
         QualifiedIdentifier identifier(includeFile.str());
 
         foreach ( Declaration* dec, includedCtx->findDeclarations(identifier, CursorInRevision(0, 1)) ) {
             if ( dec->kind() == Declaration::Import ) {
                 encounter(dec);
                 return;
             }
         }
         injectContext(includedCtx);
         openDefinition<Declaration>(identifier, RangeInRevision(0, 0, 0, 0));
         currentDeclaration()->setKind(Declaration::Import);
         eventuallyAssignInternalContext();
         DeclarationBuilderBase::closeDeclaration();
         closeInjectedContext();
     }
 }
 
 void DeclarationBuilder::openNamespace(NamespaceDeclarationStatementAst* parent, IdentifierAst* node, const IdentifierPair& identifier, const RangeInRevision& range)
 {
     NamespaceDeclaration* dec = m_namespaces.value(node->string, nullptr);
     Q_ASSERT(dec);
     DeclarationBuilderBase::setEncountered(dec);
     openDeclarationInternal(dec);
 
     DeclarationBuilderBase::openNamespace(parent, node, identifier, range);
 }
 
 void DeclarationBuilder::closeNamespace(NamespaceDeclarationStatementAst* parent, IdentifierAst* node, const IdentifierPair& identifier)
 {
     DeclarationBuilderBase::closeNamespace(parent, node, identifier);
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitUseStatement(UseStatementAst* node)
 {
     if ( node->useFunction != -1 )
     {
         m_useNamespaceType = FunctionDeclarationType;
     }
     else if ( node->useConst != -1 )
     {
         m_useNamespaceType = ConstantDeclarationType;
     }
     else
     {
         m_useNamespaceType = ClassDeclarationType;
     }
     DeclarationBuilderBase::visitUseStatement(node);
 }
 
 void DeclarationBuilder::visitUseNamespaceOrUseGroupedNamespace(UseNamespaceOrUseGroupedNamespaceAst* node)
 {
     if (node->compoundNamespace) {
         // TODO
     } else {
         visitNonGroupedUseNamespace(node);
     }
 }
 
 void DeclarationBuilder::visitNonGroupedUseNamespace(UseNamespaceOrUseGroupedNamespaceAst* node)
 {
     DUChainWriteLocker lock;
     bool isConstIdentifier = ( m_useNamespaceType == ConstantDeclarationType );
 
     if ( currentContext()->type() != DUContext::Namespace &&
             !node->aliasIdentifier && node->identifier->namespaceNameSequence->count() == 1 ) {
         reportError(i18n("The use statement with non-compound name '%1' has no effect.",
                         identifierForNode(node->identifier->namespaceNameSequence->front()->element).toString()),
                     node->identifier, IProblem::Warning);
         return;
     }
     IdentifierAst* idNode = node->aliasIdentifier ? node->aliasIdentifier : node->identifier->namespaceNameSequence->back()->element;
     IdentifierPair id = identifierPairForNode(idNode, isConstIdentifier);
 
     ///TODO: case insensitive!
     QualifiedIdentifier qid = identifierForNamespace(node->identifier, m_editor, isConstIdentifier);
 
     DeclarationPointer dec = findDeclarationImport(m_useNamespaceType, qid);
     if (!dec && !qid.explicitlyGlobal()) {
         QualifiedIdentifier globalQid = qid;
         globalQid.setExplicitlyGlobal(true);
         dec = findDeclarationImport(m_useNamespaceType, globalQid);
     }
 
     if (dec)
     {
         // Check for a name conflict
         DeclarationPointer dec2 = findDeclarationImport(m_useNamespaceType, id.second);
 
         if (dec2 && dec2->context()->scopeIdentifier() == currentContext()->scopeIdentifier() &&
             dec2->context()->topContext() == currentContext()->topContext() &&
             dec2->identifier().toString() == id.second.toString())
         {
             reportError(i18n("Cannot use '%1' as '%2' because the name is already in use.",
                             dec.data()->identifier().toString(), id.second.toString()),
                         node->identifier, IProblem::Error);
             return;
         }
 
         AliasDeclaration* decl = openDefinition<AliasDeclaration>(id.second, m_editor->findRange(idNode));
         decl->setAliasedDeclaration(dec.data());
     }
     else
     {
         // NamespaceAliasDeclarations can't use a global import identifier
         qid.setExplicitlyGlobal(false);
 
         NamespaceAliasDeclaration* decl = openDefinition<NamespaceAliasDeclaration>(id.second,
                                                                                     m_editor->findRange(idNode));
         decl->setImportIdentifier( qid );
         decl->setPrettyName( id.first );
         decl->setKind(Declaration::NamespaceAlias);
     }
     closeDeclaration();
 
     if (node->aliasIdentifier) {
         QString aliasName = m_editor->parseSession()->symbol(node->aliasIdentifier);
 
         if (isReservedClassName(aliasName)) {
             reportError(i18n("Cannot use %1 as %2 because '%2' is a special class name", qid.toString(), aliasName), node->aliasIdentifier);
         }
     }
 }
 
 void DeclarationBuilder::visitVarExpression(VarExpressionAst* node)
 {
     DeclarationBuilderBase::visitVarExpression(node);
 
     if (node->isGenerator != -1 && currentContext()->type() != DUContext::Other) {
         reportError(i18n("The 'yield' expression can only be used inside a function"), node);
     }
 }
 
 void DeclarationBuilder::updateCurrentType()
 {
     DUChainWriteLocker lock(DUChain::lock());
     currentDeclaration()->setAbstractType(currentAbstractType());
 }
 
 void DeclarationBuilder::supportBuild(AstNode* node, DUContext* context)
 {
     // generally we are the second pass through the doc (see PreDeclarationBuilder)
     // so notify our base about it
     setCompilingContexts(false);
     DeclarationBuilderBase::supportBuild(node, context);
 }
 
 void DeclarationBuilder::closeContext()
 {
     if (currentContext()->type() == DUContext::Function) {
         Q_ASSERT(currentDeclaration<AbstractFunctionDeclaration>());
         currentDeclaration<AbstractFunctionDeclaration>()->setInternalFunctionContext(currentContext());
     }
     // We don't want the first pass to clean up stuff, since
     // there is lots of stuff we visit/encounter here first.
     // So we clean things up here.
     setCompilingContexts(true);
     DeclarationBuilderBase::closeContext();
     setCompilingContexts(false);
 }
 
 void DeclarationBuilder::encounter(Declaration* dec)
 {
     // when we are recompiling, it's important to mark decs as encountered
     // and update their comments
     if ( recompiling() && !wasEncountered(dec) ) {
         dec->setComment(comment());
         setEncountered(dec);
     }
 }
 
 bool DeclarationBuilder::isReservedClassName(QString className)
 {
     return className.compare(QLatin1String("string"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("bool"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("int"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("float"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("iterable"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("object"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("null"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("true"), Qt::CaseInsensitive) == 0
             || className.compare(QLatin1String("false"), Qt::CaseInsensitive) == 0;
 }
 
 
 }