diff --git a/completion/context.cpp b/completion/context.cpp
index 76d1503..ba8f548 100644
--- a/completion/context.cpp
+++ b/completion/context.cpp
@@ -1,1780 +1,1785 @@
 /*
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2008 Hamish Rodda <rodda@kde.org>
    Copyright 2008 Niko Sams <niko.sams@gmail.com>
    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 "context.h"
 
 #include <ktexteditor/view.h>
 #include <ktexteditor/document.h>
 #include <KLocalizedString>
 
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/types/identifiedtype.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/codemodel.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/types/unsuretype.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/util/includeitem.h>
 #include <language/codecompletion/codecompletion.h>
 
 #include <util/pushvalue.h>
 #include <util/path.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 
 #include <project/projectmodel.h>
 
 #include "../duchain/completioncodemodel.h"
 #include "../duchain/expressionparser.h"
 #include "../duchain/helper.h"
 #include "../duchain/declarations/variabledeclaration.h"
 #include "../duchain/declarations/classmethoddeclaration.h"
 #include "../duchain/types/structuretype.h"
 
 #include "../parser/phpparser.h"
 #include "../parser/phptokentext.h"
 
 #include "includefileitem.h"
 #include "codemodelitem.h"
 #include "completiondebug.h"
 #include "helpers.h"
 #include "implementationitem.h"
 #include "keyworditem.h"
 
 #include <KIO/Global>
 
 #define LOCKDUCHAIN     DUChainReadLocker lock(DUChain::lock())
 
 #define ifDebug(x)
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 typedef QList<Parser::TokenType> TokenList;
 
 /**
  * Utility class which makes it easier to access the relevant parts
  * of the token stream for code completion.
  *
  * TODO: This class should be reviewed imo - I just hacked it together, quick'n'dirty
  */
 class TokenAccess {
 public:
     /// Setup the token stream from the input code
     TokenAccess(const QString &code)
         : m_code(code)
     {
 
         Lexer lexer(&m_stream, code);
         int token;
         while ((token = lexer.nextTokenKind())) {
             Parser::Token &t = m_stream.push();
             t.begin = lexer.tokenBegin();
             t.end = lexer.tokenEnd();
             t.kind = token;
         }
         // move to last token
         m_pos = m_stream.size() - 1;
     }
 
     /// returns Token_INVALID if the position is invalid
     /// else returns the type of the current token
     Parser::TokenType type() const {
         if ( m_pos == -1 ) {
             return Parser::Token_INVALID;
         } else {
             return (Parser::TokenType) m_stream.at(m_pos).kind;
         }
     }
 
     /// convenience comparison to a tokentype
     bool operator==(const Parser::TokenType& other) const {
         return other == type();
     }
 
     /// move to previous token
     void pop() {
         if ( m_pos >= 0 ) {
             --m_pos;
         }
     }
 
     /// move relative to current token
     /// NOTE: make sure you honor the boundaries.
     void moveTo(const qint64 &relPos) {
         m_pos += relPos;
         Q_ASSERT(m_pos > 0);
         Q_ASSERT(m_pos < m_stream.size());
     }
 
     /// get type of token relative to current position
     /// returns Token_INVALID if the position goes out of the boundaries
     int typeAt(const qint64 &relPos) const {
         const qint64 pos = m_pos + relPos;
         if ( pos >= 0 && pos < m_stream.size() ) {
             return m_stream.at(pos).kind;
         } else {
             return Parser::Token_INVALID;
         }
     }
 
     /// Get string for token at a given position relative to the current one.
     /// NOTE: Make sure you honor the boundaries.
     QString stringAt(const qint64 &relPos) const {
         Parser::Token token = at(relPos);
         return m_code.mid(token.begin, token.end - token.begin + 1);
     }
 
     /// check whether the current token is prepended by the list of tokens
     /// @return -1 when not prepended by the list, else the relative index-position
     qint64 prependedBy(const TokenList &list, bool skipWhitespace = false ) const {
         // this would be useless, hence forbid it
         Q_ASSERT ( !list.isEmpty() );
 
         if ( m_pos < list.count() - 1 ) {
             // not enough tokens
             return -1;
         } else {
             uint pos = 1;
             foreach ( Parser::TokenType type, list ) {
                 if ( skipWhitespace && m_stream.at( m_pos - pos).kind == Parser::Token_WHITESPACE ) {
                     ++pos;
                 }
                 if ( m_stream.at( m_pos - pos).kind == type ) {
                     ++pos;
                     continue;
                 } else {
                     return -1;
                 }
             }
             return pos;
         }
     }
 
     /// Get the token relative to the current one.
     /// NOTE: Make sure you honor the boundaries.
     Parser::Token at(const qint64 &relPos) const {
         const qint64 pos = m_pos + relPos;
         Q_ASSERT(pos >= 0);
         Q_ASSERT(pos < m_stream.size());
         return m_stream.at(pos);
     }
 
 private:
     const QString m_code;
     TokenStream m_stream;
     qint64 m_pos;
 };
 
 /**
  * Pops all tokens from the @p lastToken and stops at the LPAREN.
  */
 void removeOtherArguments(TokenAccess &lastToken)
 {
     Q_ASSERT(lastToken.type() == Parser::Token_COMMA);
 
     // remove all other arguments
     int openLParen = 0;
     do {
         lastToken.pop();
         if ( lastToken.type() == Parser::Token_RPAREN ) {
             ++openLParen;
         } else if ( lastToken.type() == Parser::Token_LPAREN ) {
             if ( openLParen == 0 ) {
                 return;
             } else {
                 --openLParen;
             }
         }
     } while ( lastToken.type() != Parser::Token_INVALID );
 }
 
 /**
  * if token at @p pos is whitespace, decrease pos by one.
  */
 inline void skipWhiteSpace(const TokenAccess &lastToken, qint64 &pos)
 {
     if ( lastToken.typeAt(pos) == Parser::Token_WHITESPACE ) {
         --pos;
     }
 }
 
 /// add keyword to list of completion items
 #define ADD_KEYWORD(x) items << CompletionTreeItemPointer( new KeywordItem( QStringLiteral(x), Php::CodeCompletionContext::Ptr(this) ) )
 #define ADD_KEYWORD2(x, y) items << CompletionTreeItemPointer( new KeywordItem( QStringLiteral(x), Php::CodeCompletionContext::Ptr(this), QStringLiteral(y) ) )
 
 int completionRecursionDepth = 0;
 
 CodeCompletionContext::CodeCompletionContext(KDevelop::DUContextPointer context, const QString& text, const QString& followingText, const KDevelop::CursorInRevision& position, int depth)
         : KDevelop::CodeCompletionContext(context, text, position, depth)
         , m_memberAccessOperation(NoMemberAccess), m_parentAccess(false), m_isFileCompletionAfterDirname(false)
 {
     // use other ctor for parents
     Q_ASSERT(depth == 0);
 
     ifDebug(qCDebug(COMPLETION) << "non-processed text: " + text;)
 
     if ( context->type() == DUContext::Class || context->type() == DUContext::Function || context->type() == DUContext::Other
         || context->type() == DUContext::Namespace )
     {
         if ( !m_parentContext && !m_text.startsWith(QLatin1String("<?php ")) ) {
             ifDebug(qCDebug(COMPLETION) << "added start tag: " + m_text;)
             m_text.prepend("<?php ");
         }
     }
 
     m_valid = !m_text.isEmpty();
 
     if (!m_valid) {
         qCDebug(COMPLETION) << "empty completion text";
         return;
     }
 
     TokenAccess lastToken(m_text);
 //     ifDebug(qCDebug(COMPLETION) << "clearing completion text");)
 //     m_text.clear();
 
     /// even when we skip to some more meaning ful token, this will
     /// always be the end position of the last token
     const qint64 lastTokenEnd = lastToken.at(0).end + 1;
 
     bool lastWasWhitespace = lastToken == Parser::Token_WHITESPACE;
     if ( lastWasWhitespace ) {
         ifDebug(qCDebug(COMPLETION) << "skipping whitespace token";)
         lastToken.pop();
     }
 
     // when the text after the current token starts with /* we are inside
     // a multi line comment => don't offer completion
     if ( m_text.mid( lastTokenEnd, 2 ) == QLatin1String("/*") ) {
         ifDebug(qCDebug(COMPLETION) << "no completion in comments");
         m_valid = false;
         return;
     }
 
     ifDebug(qCDebug(COMPLETION) << tokenText(lastToken.type());)
 
     ///TODO: REFACTOR: push some stuff into its own methods
     ///                and call them from inside the big switch.
     ///                Then we can forget about having additional checks
     ///                beforehand and can handle it all in one place.
 
     // The following tokens require a whitespace after them for code-completion:
     if ( !lastWasWhitespace ) {
         switch ( lastToken.type() ) {
             case Parser::Token_EXTENDS:
             case Parser::Token_IMPLEMENTS:
             case Parser::Token_NEW:
             case Parser::Token_THROW:
                 ifDebug(qCDebug(COMPLETION) << "need whitespace after token for completion";)
                 m_valid = false;
                 return;
             default:
                 break;
         }
     }
 
     ifDebug(qCDebug(COMPLETION) << tokenText(lastToken.type());)
 
     switch ( lastToken.type() ) {
         case Parser::Token_COMMENT:
             // don't offer code completion in comments, i.e. single line comments that don't end on \n
             // multi-line comments are handled above
             if ( !lastWasWhitespace && !lastToken.stringAt(0).endsWith('\n')
                     && !lastToken.stringAt(0).startsWith(QLatin1String("/*")) ) {
                 ifDebug(qCDebug(COMPLETION) << "no completion in comments";)
                 m_valid = false;
             }
             break;
         case Parser::Token_EXTENDS:
             if ( lastToken.prependedBy(TokenList() << Parser::Token_WHITESPACE << Parser::Token_STRING
                                                    << Parser::Token_WHITESPACE << Parser::Token_CLASS) != -1 ) {
                 m_memberAccessOperation = ClassExtendsChoose;
                 forbidIdentifier(lastToken.stringAt(-2));
             } else if ( lastToken.prependedBy(TokenList() << Parser::Token_WHITESPACE << Parser::Token_STRING
                                                    << Parser::Token_WHITESPACE << Parser::Token_INTERFACE) != -1 ) {
                 m_memberAccessOperation = InterfaceChoose;
                 forbidIdentifier(lastToken.stringAt(-2));
             } else {
                 ifDebug(qCDebug(COMPLETION) << "token prepended by bad tokens, don't do completion";)
                 m_valid = false;
             }
             break;
         case Parser::Token_IMPLEMENTS:
             if ( lastToken.prependedBy(TokenList() << Parser::Token_WHITESPACE << Parser::Token_STRING
                                                    << Parser::Token_WHITESPACE << Parser::Token_CLASS) != -1 ) {
                 m_memberAccessOperation = InterfaceChoose;
                 forbidIdentifier(lastToken.stringAt(-2));
             } else {
                 ifDebug(qCDebug(COMPLETION) << "token prepended by bad tokens, don't do completion";)
                 m_valid = false;
             }
             break;
         case Parser::Token_COMMA:
             {
             // check if we are in the list after Token_IMPLEMENTS:
             qint64 relPos = -1;
             QList<qint64> identifierPositions;
             while ( true ) {
                 skipWhiteSpace(lastToken, relPos);
                 if ( lastToken.typeAt(relPos) == Parser::Token_STRING ) {
                     identifierPositions << relPos;
                     --relPos;
                     skipWhiteSpace(lastToken, relPos);
                             // interfaces may extend more than one interface
                     if ( ( lastToken.typeAt(relPos) == Parser::Token_EXTENDS &&
                             lastToken.typeAt(relPos - 1) == Parser::Token_WHITESPACE &&
                             lastToken.typeAt(relPos - 2) == Parser::Token_STRING &&
                             lastToken.typeAt(relPos - 3) == Parser::Token_WHITESPACE &&
                             lastToken.typeAt(relPos - 4) == Parser::Token_INTERFACE )
                         || // classes may implement more than one interface
                          ( lastToken.typeAt(relPos) == Parser::Token_IMPLEMENTS &&
                             lastToken.typeAt(relPos - 1) == Parser::Token_WHITESPACE &&
                             lastToken.typeAt(relPos - 2) == Parser::Token_STRING &&
                             lastToken.typeAt(relPos - 3) == Parser::Token_WHITESPACE &&
                             lastToken.typeAt(relPos - 4) == Parser::Token_CLASS ) )
                     {
                         identifierPositions << (relPos - 2);
                         m_memberAccessOperation = InterfaceChoose;
                         break;
                     } else if ( lastToken.typeAt(relPos) == Parser::Token_COMMA ) {
                         // skip to next entry
                         --relPos;
                         continue;
                     }
                 } else {
                     break;
                 }
             }
             if ( m_memberAccessOperation == InterfaceChoose ) {
                 ifDebug(qCDebug(COMPLETION) << "in implementation list";)
                 m_memberAccessOperation = InterfaceChoose;
                 foreach ( qint64 pos, identifierPositions ) {
                     forbidIdentifier(lastToken.stringAt(pos));
                 }
             } else {
                 // else do function call completion
                 m_memberAccessOperation = FunctionCallAccess;
 
                 ///TODO: global, static etc. enumerations.
                 removeOtherArguments(lastToken);
 
                 if ( lastToken.type() == Parser::Token_INVALID ) {
                     m_valid = false;
                 }
             }
             }
             break;
         case Parser::Token_OPEN_TAG:
             // don't do completion if no whitespace is given and there is some text following,
             // esp. for stuff like <?php <?ph <?p
             if ( !lastWasWhitespace && !followingText.isEmpty() ) {
                 ifDebug(qCDebug(COMPLETION) << "no completion because <? is followed by" + followingText;)
                 m_valid = false;
             } else {
                 // else just do normal completion
                 m_memberAccessOperation = NoMemberAccess;
             }
             break;
         case Parser::Token_OBJECT_OPERATOR:
             m_memberAccessOperation = MemberAccess;
             lastToken.pop();
             break;
         case Parser::Token_PAAMAYIM_NEKUDOTAYIM:
             m_memberAccessOperation = StaticMemberAccess;
             lastToken.pop();
             break;
         case Parser::Token_LPAREN:
             {
             qint64 pos = -1;
             skipWhiteSpace(lastToken, pos);
             if ( lastToken.typeAt(pos) == Parser::Token_CATCH ) {
                 m_memberAccessOperation = ExceptionChoose;
             } else if ( lastToken.typeAt(pos) == Parser::Token_ARRAY ) {
                 m_memberAccessOperation = NoMemberAccess;
                 ifDebug(qCDebug(COMPLETION) << "NoMemberAccess";)
                 ifDebug(qCDebug(COMPLETION) << "returning early";)
                 return;
             } else {
                 m_memberAccessOperation = FunctionCallAccess;
             }
             }
             break;
         case Parser::Token_NEW:
             if ( lastToken.prependedBy(TokenList() << Parser::Token_WHITESPACE << Parser::Token_THROW) != -1 ) {
                 m_memberAccessOperation = ExceptionChoose;
             } else {
                 m_memberAccessOperation = NewClassChoose;
             }
             break;
         case Parser::Token_THROW:
             m_memberAccessOperation = ExceptionInstanceChoose;
             break;
         case Parser::Token_CONSTANT_ENCAPSED_STRING:
             {
                 // support something like `include dirname(__FILE__) . "/...`
                 ///TODO: include __DIR__ . "/ (php 5.3)
                 bool isAfterDirname = false;
                 //NOTE: prependedBy will return -1 on failure, this is what we need in these cases
                 //      on success it will return a positive number, we'll need to switch it's sign in that case
                 qint64 relPos = lastToken.prependedBy(TokenList() << Parser::Token_CONCAT << Parser::Token_RPAREN << Parser::Token_FILE
                                                    << Parser::Token_LPAREN << Parser::Token_STRING, true);
                 if ( relPos != -1 ) {
                     // switch sign
                     relPos = -relPos;
                     if ( lastToken.stringAt(relPos + 1).compare(QLatin1String("dirname"), Qt::CaseInsensitive) == 0 ) {
                         isAfterDirname = true;
                     }
                 }
                 skipWhiteSpace(lastToken, relPos);
                 if ( lastToken.typeAt(relPos) == Parser::Token_LPAREN ) {
                     --relPos;
                 }
                 skipWhiteSpace(lastToken, relPos);
                 switch ( lastToken.typeAt(relPos) ) {
                     case Parser::Token_REQUIRE:
                     case Parser::Token_REQUIRE_ONCE:
                     case Parser::Token_INCLUDE:
                     case Parser::Token_INCLUDE_ONCE:
                         m_memberAccessOperation = FileChoose;
                         m_expression = m_text.mid( lastToken.at(0).begin + 1 ).append(followingText).trimmed();
                         m_isFileCompletionAfterDirname = isAfterDirname;
                         break;
                     default:
                         if ( m_text.at( lastToken.at(0).begin ).unicode() == '"' ) {
                             ///TODO: only offer variable completion
                             m_valid = false;
                         } else {
                             // in or after constant strings ('...') don't offer completion at all
                             m_valid = false;
                         }
                         break;
                 }
                 break;
             }
             break;
         case Parser::Token_INSTANCEOF:
             m_memberAccessOperation = InstanceOfChoose;
             break;
         case Parser::Token_AND_ASSIGN:
         case Parser::Token_ARRAY_CAST:
         case Parser::Token_ASSIGN:
         case Parser::Token_AT:
         case Parser::Token_BANG:
         case Parser::Token_BIT_AND:
         case Parser::Token_BIT_OR:
         case Parser::Token_BIT_XOR:
         case Parser::Token_BOOLEAN_AND:
         case Parser::Token_BOOLEAN_OR:
         case Parser::Token_BOOL_CAST:
         case Parser::Token_COLON:
         case Parser::Token_CONCAT:
         case Parser::Token_CONCAT_ASSIGN:
         case Parser::Token_CURLY_OPEN:
         case Parser::Token_DEC:
         case Parser::Token_DIV:
         case Parser::Token_DIV_ASSIGN:
         case Parser::Token_DOC_COMMENT:
         case Parser::Token_DOLLAR_OPEN_CURLY_BRACES:
         case Parser::Token_DOUBLE_ARROW:
         case Parser::Token_DOUBLE_CAST:
         case Parser::Token_DOUBLE_QUOTE:
         case Parser::Token_ECHO:
         case Parser::Token_ELLIPSIS:
         case Parser::Token_ENCAPSED_AND_WHITESPACE:
         case Parser::Token_EXIT:
         case Parser::Token_INC:
         case Parser::Token_INT_CAST:
         case Parser::Token_IS_EQUAL:
         case Parser::Token_IS_GREATER:
         case Parser::Token_IS_GREATER_OR_EQUAL:
         case Parser::Token_IS_IDENTICAL:
         case Parser::Token_IS_NOT_EQUAL:
         case Parser::Token_IS_NOT_IDENTICAL:
         case Parser::Token_IS_SMALLER:
         case Parser::Token_IS_SMALLER_OR_EQUAL:
         case Parser::Token_LBRACE:
         case Parser::Token_LBRACKET:
         case Parser::Token_LOGICAL_AND:
         case Parser::Token_LOGICAL_OR:
         case Parser::Token_LOGICAL_XOR:
         case Parser::Token_MINUS:
         case Parser::Token_MINUS_ASSIGN:
         case Parser::Token_MOD:
         case Parser::Token_MOD_ASSIGN:
         case Parser::Token_MUL:
         case Parser::Token_MUL_ASSIGN:
         case Parser::Token_OBJECT_CAST:
         case Parser::Token_OPEN_TAG_WITH_ECHO:
         case Parser::Token_OR_ASSIGN:
         case Parser::Token_PLUS:
         case Parser::Token_PLUS_ASSIGN:
         case Parser::Token_PRINT:
         case Parser::Token_QUESTION:
         case Parser::Token_RBRACE:
         case Parser::Token_RETURN:
         case Parser::Token_SEMICOLON:
         case Parser::Token_SL:
         case Parser::Token_SL_ASSIGN:
         case Parser::Token_SR:
         case Parser::Token_SR_ASSIGN:
         case Parser::Token_START_HEREDOC:
         case Parser::Token_START_NOWDOC:
         case Parser::Token_STRING:
         case Parser::Token_STRING_CAST:
         case Parser::Token_TILDE:
         case Parser::Token_UNSET_CAST:
         case Parser::Token_XOR_ASSIGN:
         case Parser::Token_EXP:
         case Parser::Token_EXP_ASSIGN:
             // normal completion is valid
             if ( duContext() && duContext()->type() == DUContext::Class ) {
                 // when we are inside a class context, give overloadable members as completion
                 m_memberAccessOperation = ClassMemberChoose;
             } else {
                 m_memberAccessOperation = NoMemberAccess;
             }
             break;
         case Parser::Token_ABSTRACT:
         case Parser::Token_CONST:
         case Parser::Token_FINAL:
         case Parser::Token_PUBLIC:
         case Parser::Token_PRIVATE:
         case Parser::Token_PROTECTED:
         case Parser::Token_STATIC:
         case Parser::Token_VAR:
             if ( duContext() && duContext()->type() == DUContext::Class ) {
                 // when we are inside a class context, give overloadable members as completion
                 m_memberAccessOperation = ClassMemberChoose;
             } else {
                 m_valid = false;
             }
             break;
         case Parser::Token_NAMESPACE:
         case Parser::Token_BACKSLASH:
         {
             QString identifier;
             qint64 relPos = 0;
             while (lastToken.typeAt(relPos) == Parser::Token_STRING || lastToken.typeAt(relPos) == Parser::Token_BACKSLASH) {
                 if (lastToken.typeAt(relPos) == Parser::Token_BACKSLASH) {
                     identifier.prepend("::");
                 } else {
                     identifier.prepend(lastToken.stringAt(relPos));
                 }
                 --relPos;
             }
             if ( lastToken.typeAt(relPos) == Parser::Token_NAMESPACE ) {
                 m_memberAccessOperation = NamespaceChoose;
             } else {
                 m_memberAccessOperation = BackslashAccess;
             }
             m_namespace = QualifiedIdentifier(identifier);
             break;
         }
         case Parser::Token_ARRAY:
         case Parser::Token_AS:
         case Parser::Token_BACKTICK:
+        case Parser::Token_BOOL:
         case Parser::Token_BREAK:
         case Parser::Token_CALLABLE:
         case Parser::Token_CASE:
         case Parser::Token_CATCH:
         case Parser::Token_CLASS:
         case Parser::Token_CLASS_C:
         case Parser::Token_CLONE:
         case Parser::Token_CLOSE_TAG:
         case Parser::Token_CONTINUE:
         case Parser::Token_DECLARE:
         case Parser::Token_DEFAULT:
         case Parser::Token_DNUMBER:
         case Parser::Token_DO:
         case Parser::Token_DOLLAR:
         case Parser::Token_ELSE:
         case Parser::Token_ELSEIF:
         case Parser::Token_EMPTY:
         case Parser::Token_ENDDECLARE:
         case Parser::Token_ENDFOR:
         case Parser::Token_ENDFOREACH:
         case Parser::Token_ENDIF:
         case Parser::Token_ENDSWITCH:
         case Parser::Token_ENDWHILE:
         case Parser::Token_END_HEREDOC:
         case Parser::Token_END_NOWDOC:
         case Parser::Token_EOF:
         case Parser::Token_EVAL:
         case Parser::Token_FILE:
         case Parser::Token_FINALLY:
+        case Parser::Token_FLOAT:
         case Parser::Token_FOR:
         case Parser::Token_FOREACH:
         case Parser::Token_FUNCTION:
         case Parser::Token_FUNC_C:
         case Parser::Token_GLOBAL:
         case Parser::Token_HALT_COMPILER:
         case Parser::Token_IF:
         case Parser::Token_INCLUDE:
         case Parser::Token_INCLUDE_ONCE:
         case Parser::Token_INLINE_HTML:
         case Parser::Token_INSTEADOF:
+        case Parser::Token_INT:
         case Parser::Token_INTERFACE:
         case Parser::Token_INVALID:
         case Parser::Token_ISSET:
+        case Parser::Token_ITERABLE:
         case Parser::Token_LINE:
         case Parser::Token_LIST:
         case Parser::Token_LNUMBER:
         case Parser::Token_METHOD_C:
         case Parser::Token_NAMESPACE_C:
         case Parser::Token_NUM_STRING:
         case Parser::Token_REQUIRE:
         case Parser::Token_REQUIRE_ONCE:
         case Parser::Token_RBRACKET:
         case Parser::Token_RPAREN:
+        case Parser::Token_STRING_TYPE:
         case Parser::Token_STRING_VARNAME:
         case Parser::Token_SWITCH:
         case Parser::Token_TRAIT:
         case Parser::Token_TRY:
         case Parser::Token_UNSET:
         case Parser::Token_USE:
         case Parser::Token_VARIABLE:
         case Parser::Token_WHILE:
         case Parser::Token_WHITESPACE:
         /// TODO: code completion after goto
         case Parser::Token_GOTO:
         case Parser::TokenTypeSize:
             ifDebug(qCDebug(COMPLETION) << "no completion after this token";)
             m_valid = false;
             break;
     }
 
     ifDebug(
         switch ( m_memberAccessOperation ) {
             case FileChoose:
                 qCDebug(COMPLETION) << "FileChoose";
                 break;
             case ExceptionInstanceChoose:
                 qCDebug(COMPLETION) << "ExceptionInstanceChoose";
                 break;
             case ExceptionChoose:
                 qCDebug(COMPLETION) << "ExceptionChoose";
                 break;
             case ClassMemberChoose:
                 qCDebug(COMPLETION) << "ClassMemberChoose";
                 break;
             case NoMemberAccess:
                 qCDebug(COMPLETION) << "NoMemberAccess";
                 break;
             case NewClassChoose:
                 qCDebug(COMPLETION) << "NewClassChoose";
                 break;
             case FunctionCallAccess:
                 qCDebug(COMPLETION) << "FunctionCallAccess";
                 break;
             case InterfaceChoose:
                 qCDebug(COMPLETION) << "InterfaceChoose";
                 break;
             case ClassExtendsChoose:
                 qCDebug(COMPLETION) << "ClassExtendsChoose";
                 break;
             case MemberAccess:
                 qCDebug(COMPLETION) << "MemberAccess";
                 break;
             case StaticMemberAccess:
                 qCDebug(COMPLETION) << "StaticMemberAccess";
                 break;
             case InstanceOfChoose:
                 qCDebug(COMPLETION) << "InstanceOfChoose";
                 break;
             case NamespaceChoose:
                 qCDebug(COMPLETION) << "NamespaceChoose";
                 break;
             case BackslashAccess:
                 qCDebug(COMPLETION) << "BackslashAccess";
                 break;
         }
     )
 
     ifDebug(qCDebug(COMPLETION) << tokenText(lastToken.type());)
 
     // if it's not valid, we should return early
     if ( !m_valid ) {
         ifDebug(qCDebug(COMPLETION) << "invalid completion";)
         return;
     }
 
     // trim the text to the end position of the current token
     m_text = m_text.left(lastToken.at(0).end + 1).trimmed();
     ifDebug(qCDebug(COMPLETION) << "trimmed text: " << m_text;)
 
     // check whether we need the expression or have everything we need and can return early
     switch ( m_memberAccessOperation ) {
         // these access operations don't need the previous expression evaluated
         case FileChoose:
         case ClassMemberChoose:
         case InterfaceChoose:
         case NewClassChoose:
         case ExceptionChoose:
         case ExceptionInstanceChoose:
         case ClassExtendsChoose:
         case NoMemberAccess:
         case InstanceOfChoose:
         case NamespaceChoose:
         case BackslashAccess:
             ifDebug(qCDebug(COMPLETION) << "returning early";)
             return;
         case FunctionCallAccess:
             m_memberAccessOperation = NoMemberAccess;
             Q_ASSERT(lastToken.type() == Parser::Token_LPAREN);
             if ( lastToken.prependedBy(TokenList() << Parser::Token_STRING, true) == -1 &&
                  lastToken.prependedBy(TokenList() << Parser::Token_VARIABLE, true) == -1 )
             {
                 // handle for, foreach, while, etc.
                 ifDebug(qCDebug(COMPLETION) << "NoMemberAccess (no function call)";)
             } else {
                 //The first context should never be a function-call context,
                 //so make this a NoMemberAccess context and the parent a function-call context.
                 ifDebug(qCDebug(COMPLETION) << "NoMemberAccess (creating parentContext for function call)";)
                 m_parentContext = new CodeCompletionContext(m_duContext, m_position, lastToken, depth + 1);
             }
             return;
         case MemberAccess:
         case StaticMemberAccess:
             // these types need the expression evaluated
             break;
     }
 
     evaluateExpression(lastToken);
 }
 
 CodeCompletionContext::CodeCompletionContext(KDevelop::DUContextPointer context, const KDevelop::CursorInRevision& position,
                                              TokenAccess& lastToken,  int depth)
         : KDevelop::CodeCompletionContext(context, QString(), position, depth)
         , m_memberAccessOperation(NoMemberAccess), m_parentAccess(false), m_isFileCompletionAfterDirname(false)
 {
     switch ( lastToken.type() ) {
         case Parser::Token_LPAREN:
             m_memberAccessOperation = FunctionCallAccess;
             break;
         default:
             qCDebug(COMPLETION) << "unhandled token type for parent context" << tokenText(lastToken.typeAt(0));
             Q_ASSERT(false);
             m_valid = false;
             return;
     }
 
     evaluateExpression(lastToken);
 }
 
 void CodeCompletionContext::evaluateExpression(TokenAccess& lastToken)
 {
     /// token pos
     qint64 startPos = 0;
     int openLParen = 0;
 
     if ( m_memberAccessOperation == FunctionCallAccess ) {
         Q_ASSERT(lastToken.type() == Parser::Token_LPAREN);
         // check ctor call
         qint64 pos = lastToken.prependedBy(TokenList() << Parser::Token_STRING << Parser::Token_NEW, true);
         if ( pos != -1 ) {
             startPos = -pos;
             ifDebug(qCDebug(COMPLETION) << "ctor call";)
         } else {
             // simple function call, get it's expression
             startPos = -1;
             ifDebug(qCDebug(COMPLETION) << "simple function call";)
         }
     }
 
     static const QList<int> defaultStopTokens = QList<int>()
             << Parser::Token_SEMICOLON << Parser::Token_INVALID << Parser::Token_OPEN_TAG
             << Parser::Token_OPEN_TAG_WITH_ECHO << Parser::Token_LBRACE << Parser::Token_RBRACE
             << Parser::Token_IF << Parser::Token_WHILE << Parser::Token_FOR << Parser::Token_FOREACH
             << Parser::Token_SWITCH << Parser::Token_ELSEIF;
 
 
     // find expression start
     while ( !defaultStopTokens.contains(lastToken.typeAt(startPos)) &&
             (m_memberAccessOperation == FunctionCallAccess || lastToken.typeAt(startPos) != Parser::Token_COMMA) )
     {
         if ( lastToken.typeAt(startPos) == Parser::Token_LPAREN ) {
             ++openLParen;
             if ( openLParen > 0 ) {
                 break;
             }
         } else if ( lastToken.typeAt(startPos) == Parser::Token_RPAREN ) {
             --openLParen;
         }
         --startPos;
     }
 
     if ( openLParen < 0 ) {
         ifDebug(qCDebug(COMPLETION) << "too many closed parenthesis";)
         m_valid = false;
         return;
     }
 
     // we actually incorporate the not-wanted token, hence move forward
     ++startPos;
 
     if ( lastToken.typeAt(startPos) == Parser::Token_WHITESPACE ) {
         ++startPos;
     }
 
     if ( lastToken.typeAt(startPos) == Parser::Token_RETURN ) {
         ///TODO: match against function return type
         ++startPos;
 
         if ( lastToken.typeAt(startPos) == Parser::Token_WHITESPACE ) {
             ++startPos;
         }
     }
 
     if ( m_memberAccessOperation == StaticMemberAccess ) {
         if ( lastToken.typeAt(startPos) != Parser::Token_STRING ) {
             ifDebug(qCDebug(COMPLETION) << "unsupported token for start member access:" << tokenText(lastToken.typeAt(startPos));)
             m_valid = false;
             return;
         }
 
         const QString identifier(lastToken.stringAt(startPos).toLower());
 
         if ( identifier == QLatin1String("self") || identifier == QLatin1String("parent") || identifier == QLatin1String("static") ) {
             // self and parent are only accessible from within a member function of a class
             if (DUContext* parent = m_duContext->parentContext()) {
                 LOCKDUCHAIN;
                 ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(parent->owner());
                 if (classDec) {
                     if (identifier == QLatin1String("parent")) {
                         FOREACH_FUNCTION(const BaseClassInstance& base, classDec->baseClasses) {
                             if (StructureType::Ptr classType = base.baseClass.type<StructureType>()) {
                                 if (ClassDeclaration* baseClass = dynamic_cast<ClassDeclaration*>(classType->declaration(m_duContext->topContext()))) {
                                     if (baseClass->classType() == ClassDeclarationData::Class
                                             && baseClass->classModifier() != ClassDeclarationData::Abstract) {
                                         ifDebug(qCDebug(COMPLETION) << "correction: parent can do MemberAccess");
                                         m_parentAccess = true;
                                         m_memberAccessOperation = MemberAccess;
                                         m_expressionResult.setDeclaration(baseClass);
                                         break;
                                     }
                                 }
                             }
                         }
                         if (!m_parentAccess) {
                             ifDebug(qCDebug(COMPLETION) << "class has no accessible parent class");
                             m_valid = false;
                             return;
                         }
                     } else {
                         m_expressionResult.setDeclaration(parent->owner());
                     }
                 }
             }
         } else {
             QualifiedIdentifier id(identifier);
 
             m_expressionResult.setDeclaration(findDeclarationImportHelper(duContext(), id, ClassDeclarationType));
         }
     } else {
         // Now get the string of the expression and evaluate it
         Q_ASSERT(m_expression.isEmpty());
 
         for (qint64 i = startPos; i <= 0; ++i ) {
             m_expression += lastToken.stringAt(i);
         }
 
         m_expression = m_expression.trimmed();
 
         // make sure the expression is valid
         if (m_memberAccessOperation == FunctionCallAccess) {
             m_expression.append(')');
         }
         for ( int i = openLParen; i > 0; --i ) {
             m_expression.append(')');
         }
 
         ifDebug(qCDebug(COMPLETION) << "expression: " << m_expression;)
 
         if ( !m_expression.isEmpty() ) {
             ExpressionParser expressionParser;
             m_expressionResult = expressionParser.evaluateType(m_expression.toUtf8(), m_duContext, m_position);
         }
 
         if (m_expressionResult.type()) {
             LOCKDUCHAIN;
             ifDebug(qCDebug(COMPLETION) << "expression type: " << m_expressionResult.type()->toString();)
         } else {
             ifDebug(qCDebug(COMPLETION) << QString("expression could not be evaluated"));
             if ( m_memberAccessOperation == FunctionCallAccess ) {
                 ifDebug(qCDebug(COMPLETION) << "function not found";)
                 return;
             }
             m_valid = false;
             return;
         }
     }
 
     lastToken.moveTo(startPos);
 
     // Handle recursive contexts (Example: "ret = function1(param1, function2(" )
     if ( lastToken.typeAt(-1) == Parser::Token_LPAREN ||
          lastToken.typeAt(-1) == Parser::Token_COMMA ) {
         //Our expression is within a function-call. We need to find out the possible argument-types we need to match, and show an argument-hint.
 
         lastToken.moveTo(-1);
         if ( lastToken.type() == Parser::Token_COMMA ) {
             removeOtherArguments(lastToken);
             if ( lastToken.type() == Parser::Token_INVALID ) {
                 ifDebug(qCDebug(COMPLETION) << QString("Could not find start position for parent function-call. Aborting.");)
                 m_valid = false;
                 return;
             }
         }
 
         if ( lastToken.prependedBy(TokenList() << Parser::Token_STRING, true) == -1 ) {
             // handle for, foreach, while, etc.
             ifDebug(qCDebug(COMPLETION) << "No real function call";)
             return;
         }
 
         ifDebug(qCDebug(COMPLETION) << QString("Recursive function-call: creating parent context"));
         m_parentContext = new CodeCompletionContext(m_duContext, m_position, lastToken, m_depth + 1);
 
         if (!m_parentContext->isValid()) {
             m_parentContext = nullptr;
             m_valid = false;
             return;
         }
     }
 }
 
 void CodeCompletionContext::forbidIdentifier(const QString& identifier)
 {
     QualifiedIdentifier id(identifier.toLower());
 
     ClassDeclaration *dec = dynamic_cast<ClassDeclaration*>(
                                 findDeclarationImportHelper(m_duContext.data(), id,
                                                             ClassDeclarationType).data()
                             );
     if (dec) {
         forbidIdentifier(dec);
     } else {
         // might be a class we are currently writing, i.e. without a proper declaration
         m_forbiddenIdentifiers << id.index();
     }
 }
 
 void CodeCompletionContext::forbidIdentifier(ClassDeclaration* klass)
 {
     uint id;
     {
         LOCKDUCHAIN;
         // TODO: qualifiedIdentifier is marked as expensive - any other way
         //       we can do what we are doing here?
         // TODO: maybe we should clar the m_fobiddenIdentifiers after we got
         //       our list of items...
         id = klass->qualifiedIdentifier().index();
     }
     if (m_forbiddenIdentifiers.contains(id)) {
         // nothing to do
         return;
     }
 
     m_forbiddenIdentifiers << id;
 
     // add parents so those are excluded from the completion items as well
     if (klass->baseClassesSize() > 0) {
         FOREACH_FUNCTION(const BaseClassInstance& base, klass->baseClasses) {
             StructureType::Ptr type = base.baseClass.type<StructureType>();
             if (type.data()) {
                 ClassDeclaration* parent;
                 {
                     LOCKDUCHAIN;
                     parent = dynamic_cast<ClassDeclaration*>(
                                                type->declaration(m_duContext->topContext())
                                            );
                 }
                 if (parent) {
                     forbidIdentifier(parent);
                 }
             }
         }
     }
 }
 
 CodeCompletionContext::~CodeCompletionContext()
 {
 }
 
 CodeCompletionContext::MemberAccessOperation CodeCompletionContext::memberAccessOperation() const
 {
     return m_memberAccessOperation;
 }
 
 ExpressionEvaluationResult CodeCompletionContext::memberAccessContainer() const
 {
     return m_expressionResult;
 }
 
 CodeCompletionContext* CodeCompletionContext::parentContext()
 {
     return static_cast<CodeCompletionContext*>(KDevelop::CodeCompletionContext::parentContext());
 }
 
 QList<DUContext*> CodeCompletionContext::memberAccessContainers() const
 {
     QList<DUContext*> ret;
     QList<AbstractType::Ptr> types;
     AbstractType::Ptr expressionTarget = m_expressionResult.type();
     if (UnsureType::Ptr unsureType = UnsureType::Ptr::dynamicCast(m_expressionResult.type())) {
         FOREACH_FUNCTION(const IndexedType& t, unsureType->types) {
             types << t.abstractType();
         }
     } else if (ReferenceType::Ptr referencedType = ReferenceType::Ptr::dynamicCast(m_expressionResult.type()) ) {
         types << referencedType->baseType();
     } else {
         types << expressionTarget;
     }
     foreach (const AbstractType::Ptr &type, types) {
         const IdentifiedType* idType = dynamic_cast<const IdentifiedType*>(type.data());
         Declaration* declaration = nullptr;
         if (idType) {
             declaration = idType->declaration(m_duContext->topContext());
         }
         DUContext* ctx = nullptr;
         if (declaration) {
             ctx = declaration->logicalInternalContext(m_duContext->topContext());
         }
         if (ctx) {
             ret << ctx;
         } else if (declaration) {
             //Print some debug-output
             qCDebug(COMPLETION) << "Could not get internal context from" << declaration->toString();
         } else {
             //Print some debug-output
             qCDebug(COMPLETION) << "Could not get declaration";
         }
     }
     return ret;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::completionItems(bool& abort, bool fullCompletion)
 {
     //TODO: how should this be handled?
     Q_UNUSED(fullCompletion)
 
     /// Indexed string for 'Php', identifies environment files from this language plugin
     static const IndexedString phpLangString("Php");
 
     LOCKDUCHAIN;
 
     QList<CompletionTreeItemPointer> items;
 
     if (!m_duContext)
         return items;
 
     typedef QPair<Declaration*, int> DeclarationDepthPair;
 
     if ( memberAccessOperation() == FileChoose ) {
         if ( !ICore::self() ) {
             // in unit tests we can't do anything
             qCDebug(COMPLETION) << "no core found";
             return items;
         }
         // file completion
         const Path currentDocument(m_duContext->url().str());
         Path path;
         Path base;
         if ( !m_isFileCompletionAfterDirname ) {
             path = Path(currentDocument.parent(), m_expression);
             base = path;
             if ( !m_expression.isEmpty() && !m_expression.endsWith('/') ) {
                 base = base.parent();
             }
         } else {
             if ( m_expression.startsWith('/') ) {
                 path = Path(currentDocument.parent(), m_expression.mid(1));
             } else {
                 path = currentDocument.parent();
             }
             base = path;
             if ( !m_expression.isEmpty() && !m_expression.endsWith('/') && m_expression != QLatin1String("/") ) {
                 base = base.parent();
             }
         }
         QList<Path> addedPaths;
         bool addedParentDir = false;
         const QUrl baseUrl = base.toUrl();
         foreach ( ProjectBaseItem* item, ICore::self()->projectController()->projectModel()->itemsForPath(IndexedString(base.toUrl())) ) {
             if ( abort || !item->folder() ) {
                 break;
             }
             auto folder = item->folder();
             foreach ( ProjectFileItem* subFile, folder->fileList() ) {
                 if ( abort ) {
                     break;
                 }
                 if ( addedPaths.contains(subFile->path()) ) {
                     continue;
                 } else {
                     addedPaths << subFile->path();
                 }
                 IncludeItem item;
                 item.isDirectory = false;
                 item.basePath = baseUrl;
                 item.name = subFile->fileName();
                 if ( m_isFileCompletionAfterDirname && !m_expression.startsWith('/') ) {
                     item.name.prepend('/');
                 }
                 items << CompletionTreeItemPointer(new IncludeFileItem(item));
             }
             foreach ( ProjectFolderItem* subFolder, folder->folderList() ) {
                 if ( abort ) {
                     break;
                 }
                 if ( addedPaths.contains(subFolder->path()) ) {
                     continue;
                 } else {
                     addedPaths << subFolder->path();
                 }
                 IncludeItem item;
                 item.isDirectory = true;
                 item.basePath = baseUrl;
                 item.name = subFolder->folderName();
                 if ( m_isFileCompletionAfterDirname && !m_expression.startsWith('/') ) {
                     item.name.prepend('/');
                 }
                 items << CompletionTreeItemPointer(new IncludeFileItem(item));
             }
             if ( !folder->parent() && !addedParentDir && m_expression.isEmpty() ) {
                 // expect a parent dir
                 IncludeItem item;
                 item.isDirectory = true;
                 item.basePath = baseUrl;
                 item.name = QStringLiteral("..");
                 items << CompletionTreeItemPointer(new IncludeFileItem(item));
             }
         }
 
         return items;
     } else if (memberAccessOperation() == ClassMemberChoose) {
         // get current class
         if (ClassDeclaration * currentClass = dynamic_cast<ClassDeclaration*>(m_duContext->owner())) {
             // whether we want to show a list of overloadable functions
             // i.e. not after we have typed one of the keywords var,const or abstract
             bool showOverloadable = true;
             // whether we want to remove static functions from the overloadable list
             // i.e. after we have typed "public function"
             bool filterStatic = false;
             // whether we want to remove non-static functions from the overloadable list
             // i.e. after we have typed "public static function"
             bool filterNonStatic = false;
             // private functions are always removed from the overloadable list
             // but when we type "protected function" only protected functions may be shown
             bool filterPublic = false;
 
             {
                 // add typical keywords for class member definitions
                 QStringList modifiers = getMethodTokens(m_text);
 
                 // don't add keywords when "function" was already typed
                 bool addKeywords = !modifiers.contains(QStringLiteral("function"));
 
                 if (currentClass->classModifier() == ClassDeclarationData::Abstract) {
                     // abstract is only allowed in abstract classes
                     if (modifiers.contains(QStringLiteral("abstract"))) {
                         // don't show overloadable functions when we are defining an abstract function
                         showOverloadable = false;
                     } else if (addKeywords) {
                         ADD_KEYWORD("abstract");
                     }
                 } else {
                     // final is only allowed in non-abstract classes
                     if (addKeywords && !modifiers.contains(QStringLiteral("final"))) {
                         ADD_KEYWORD("final");
                     }
                 }
 
                 if (modifiers.contains(QStringLiteral("private"))) {
                     // overloadable functions must not be declared private
                     showOverloadable = false;
                 } else if (modifiers.contains(QStringLiteral("protected"))) {
                     // only show protected overloadable methods
                     filterPublic = true;
                 } else if (addKeywords && !modifiers.contains(QStringLiteral("public"))) {
                     ADD_KEYWORD("public");
                     ADD_KEYWORD("protected");
                     ADD_KEYWORD("private");
                 }
 
                 if (modifiers.contains(QStringLiteral("static"))) {
                     filterNonStatic = true;
                 } else {
                     if (addKeywords) {
                         ADD_KEYWORD("static");
                     } else {
                         filterStatic = true;
                     }
                 }
 
                 if (addKeywords) {
                     ADD_KEYWORD("function");
                 }
 
                 if (modifiers.isEmpty()) {
                     // var and const may not have any modifiers
                     ADD_KEYWORD("var");
                     ADD_KEYWORD("const");
                 }
             }
             ifDebug( qCDebug(COMPLETION) << "showOverloadable" << showOverloadable; )
             // complete overloadable methods from parents
             if (showOverloadable) {
                 // TODO: use m_duContext instead of ctx
                 // overloadable choose is only possible inside classes which extend/implement others
                 if (currentClass->baseClassesSize()) {
                     DUContext* ctx = currentClass->internalContext();
                     if (!ctx) {
                         qCDebug(COMPLETION) << "invalid class context";
                         return items;
                     }
                     QList<uint> alreadyImplemented;
                     //TODO: use the token stream here as well
                     //TODO: always add __construct, __destruct and maby other magic functions
                     // get all visible declarations and add inherited to the completion items
                     foreach(DeclarationDepthPair decl, ctx->allDeclarations(ctx->range().end, m_duContext->topContext(), false)) {
                         ClassMemberDeclaration *member = dynamic_cast<ClassMemberDeclaration*>(decl.first);
                         ClassFunctionDeclaration *classFunc = dynamic_cast<ClassFunctionDeclaration*>(decl.first);
                         if (member) {
                             if (decl.second == 0) {
                                 // this function is already implemented
                                 alreadyImplemented << decl.first->indexedIdentifier().getIndex();
                                 continue;
                             }
                             // skip already implemented functions
                             if (alreadyImplemented.contains(decl.first->indexedIdentifier().getIndex())) {
                                 continue;
                             }
                             // skip non-static functions when requested
                             if (filterNonStatic && !member->isStatic()) {
                                 continue;
                             }
                             // skip static functions when requested
                             if (filterStatic && member->isStatic()) {
                                 continue;
                             }
                             // always skip private functions
                             if (member->accessPolicy() == Declaration::Private) {
                                 continue;
                             }
                             // skip public functions when requested
                             if (filterPublic && member->accessPolicy() == Declaration::Public) {
                                 // make sure no non-public base members are added
                                 alreadyImplemented << decl.first->indexedIdentifier().getIndex();
                                 continue;
                             }
                             // skip final members
                             if (classFunc && classFunc->isFinal()) {
                                 // make sure no non-final base members are added
                                 alreadyImplemented << decl.first->indexedIdentifier().getIndex();
                                 continue;
                             }
                             // make sure we inherit or implement the base class of this member
                             if (!member->context() || !member->context()->owner()) {
                                 qCDebug(COMPLETION) << "invalid parent context/owner:" << member->toString();
                                 continue;
                             }
                             if (!currentClass->isPublicBaseClass(dynamic_cast<ClassDeclaration*>(member->context()->owner()),
                                                                     m_duContext->topContext())) {
                                 continue;
                             }
 
                             ImplementationItem::HelperType itype;
                             if (!member->isFunctionDeclaration()) {
                                 itype = ImplementationItem::OverrideVar;
                             } else if (member->isAbstract()) {
                                 itype = ImplementationItem::Implement;
                             } else {
                                 itype = ImplementationItem::Override;
                             }
                             ifDebug( qCDebug(COMPLETION) << "ImplementationItem" << itype; )
 
                             items << CompletionTreeItemPointer(new ImplementationItem(itype, DeclarationPointer(decl.first),
                                                                 Php::CodeCompletionContext::Ptr(this), decl.second));
                             // don't add identical items twice to the completion choices
                             alreadyImplemented << decl.first->indexedIdentifier().getIndex();
                         }
                     }
                 }
             } else {
                 qCDebug(COMPLETION) << "invalid owner declaration for overloadable completion";
             }
         }
     } else if (m_memberAccessOperation == BackslashAccess || m_memberAccessOperation == NamespaceChoose) {
         DUContext* ctx = nullptr;
         if (m_namespace.isEmpty()) {
             ctx = m_duContext->topContext();
         } else {
             foreach(Declaration* dec, m_duContext->topContext()->findDeclarations(m_namespace)) {
                 if (dec->kind() == Declaration::Namespace) {
                     ctx = dec->internalContext();
                     break;
                 }
             }
         }
         if (!ctx) {
             qCDebug(COMPLETION) << "could not find namespace:" << m_namespace.toString();
             return items;
         }
         foreach(Declaration* dec, ctx->localDeclarations()) {
             if (!isValidCompletionItem(dec)) {
                 continue;
             } else {
                 items << CompletionTreeItemPointer(
                             new NormalDeclarationCompletionItem(
                                     DeclarationPointer(dec),
                                     Php::CodeCompletionContext::Ptr(this), depth()
                                 )
                          );
             }
         }
     } else if (m_expressionResult.type()) {
         QList<DUContext*> containers = memberAccessContainers();
         qCDebug(COMPLETION) << "containers: " << containers.count();
         if (!containers.isEmpty()) {
             // get the parent class when we are inside a method declaration
             ClassDeclaration* currentClass = nullptr;
             if (m_duContext->owner() && m_duContext->owner()->isFunctionDeclaration() &&
                     m_duContext->parentContext() && m_duContext->parentContext()->owner()) {
                 currentClass = dynamic_cast<ClassDeclaration*>(m_duContext->parentContext()->owner());
             }
 
             foreach(DUContext* ctx, containers) {
                 ClassDeclaration* accessedClass = dynamic_cast<ClassDeclaration*>(ctx->owner());
                 if (abort)
                     return items;
 
                 foreach(DeclarationDepthPair decl, ctx->allDeclarations(
                                                             ctx->range().end, m_duContext->topContext(), false))
                 {
                     //If we have StaticMemberAccess, which means A::Bla, show only static members,
                     //except if we're within a class that derives from the container
                     ClassMemberDeclaration* classMember = dynamic_cast<ClassMemberDeclaration*>(decl.first);
                     if (memberAccessOperation() != StaticMemberAccess) {
                         if (classMember && classMember->isStatic())
                             continue; //Skip static class members when not doing static access
                     } else {
                         if (!classMember || !classMember->isStatic())
                             continue; //Skip static class members when not doing static access
                     }
 
                     // check access policy
                     if (classMember && accessedClass) {
                         // by default only show public declarations
                         Declaration::AccessPolicy ap = Declaration::Public;
                         if (currentClass) {
                             // if we are inside a class, we might want to show protected or private members
                             ClassDeclaration* memberClass = dynamic_cast<ClassDeclaration*>(classMember->context()->owner());
                             if (memberClass) {
                                 if (currentClass == accessedClass) {
                                     if (currentClass == memberClass) {
                                         // we can show all members of the current class
                                         ap = Declaration::Private;
                                     } else if (currentClass->isPublicBaseClass(memberClass, m_duContext->topContext())) {
                                         // we can show all but private members of ancestors of the current class
                                         ap = Declaration::Protected;
                                     }
                                 } else if (currentClass->isPublicBaseClass(accessedClass, m_duContext->topContext())
                                             && (accessedClass == memberClass ||
                                                 accessedClass->isPublicBaseClass(memberClass, m_duContext->topContext()))) {
                                     // we can show all but private members of ancestors of the current class
                                     ap = Declaration::Protected;
                                 }
                             }
                         }
                         if (ap < classMember->accessPolicy()) {
                             continue;
                         }
                     }
 
                     if (!decl.first->identifier().isEmpty())
                         items << CompletionTreeItemPointer(
                                     new NormalDeclarationCompletionItem(
                                             DeclarationPointer(
                                                 decl.first),
                                                 Php::CodeCompletionContext::Ptr(this),
                                                 decl.second
                                             )
                                     );
                 }
             }
         } else {
             qCDebug(COMPLETION) << "setContext: no container-type";
         }
 
     } else {
         //Show all visible declarations
         QSet<uint> existingIdentifiers;
         QList<DeclarationDepthPair> decls = m_duContext->allDeclarations(
             CursorInRevision::invalid(),
             m_duContext->topContext()
         );
 
         qCDebug(COMPLETION) << "setContext: using all declarations visible:" << decls.size();
 
         QListIterator<DeclarationDepthPair> i(decls);
         i.toBack();
         while (i.hasPrevious()) {
             DeclarationDepthPair decl = i.previous();
             Declaration* dec = decl.first;
             if (dec->kind() == Declaration::Instance) {
                 // filter non-superglobal vars of other contexts
                 if (dec->context() != m_duContext.data() && !m_duContext->imports(dec->context())) {
                     VariableDeclaration* vDec = dynamic_cast<VariableDeclaration*>(dec);
                     if ( vDec && !vDec->isSuperglobal() ) {
                         continue;
                     }
                 }
 
                 if (existingIdentifiers.contains(dec->indexedIdentifier().getIndex())) continue;
                 existingIdentifiers.insert(dec->indexedIdentifier().getIndex());
             }
             if (abort)
                 return items;
             if (!isValidCompletionItem(dec)) continue;
             items << CompletionTreeItemPointer(
                         new NormalDeclarationCompletionItem(
                                 DeclarationPointer(dec),
                                 Php::CodeCompletionContext::Ptr(this),
                                 decl.second
                         )
                     );
         }
 
         foreach(QSet<IndexedString> urlSets, completionFiles()) {
             foreach(const IndexedString &url, urlSets) {
                 if (url == m_duContext->url()) {
                     continue;
                 }
                 uint count = 0;
                 const CodeModelItem* foundItems = nullptr;
                 CodeModel::self().items(url, count, foundItems);
                 for (uint i = 0; i < count; ++i) {
                     CodeModelItem::Kind k = foundItems[i].kind;
                     if (((k & CodeModelItem::Function) || (k & CodeModelItem::Variable)) && !(k & CodeModelItem::ClassMember)) {
                         foreach(const ParsingEnvironmentFilePointer &env, DUChain::self()->allEnvironmentFiles(url)) {
                             if (env->language() != phpLangString) continue;
                             TopDUContext* top = env->topContext();
                             if(!top) continue;
                             if (m_duContext->imports(top)) continue;
                             QList<Declaration*> decls = top->findDeclarations(foundItems[i].id);
                             foreach(Declaration* decl, decls) {
                                 if (abort) return items;
                                 // we don't want to have class methods/properties, just normal functions
                                 // and other global stuff
                                 if ( decl->context() && decl->context()->type() == DUContext::Class ) {
                                     continue;
                                 }
                                 if (!isValidCompletionItem(decl)) continue;
                                 if ( VariableDeclaration* vDec = dynamic_cast<VariableDeclaration*>(decl) ) {
                                     if ( !vDec->isSuperglobal() ) {
                                         continue;
                                     }
                                 }
                                 items << CompletionTreeItemPointer(
                                             new NormalDeclarationCompletionItem(
                                                     DeclarationPointer(decl),
                                                     Php::CodeCompletionContext::Ptr(this)
                                             )
                                         );
                             }
                         }
                     }
                 }
             }
         }
 
         foreach(QSet<IndexedString> urlSets, completionFiles()) {
             foreach(const IndexedString &url, urlSets) {
                 uint count = 0;
                 const CompletionCodeModelItem* foundItems = nullptr;
                 CompletionCodeModel::self().items(url, count, foundItems);
                 for (uint i = 0; i < count; ++i) {
                     if (abort) return items;
                     if (m_memberAccessOperation == ExceptionChoose) {
                         if (!(foundItems[i].kind & CompletionCodeModelItem::Exception)) continue;
                     }
                     auto files = DUChain::self()->allEnvironmentFiles(url);
                     items.reserve(files.size());
                     foreach(const ParsingEnvironmentFilePointer &env, files) {
                         Q_ASSERT(env->language() == phpLangString);
                         items << CompletionTreeItemPointer ( new CodeModelCompletionItem(env, foundItems[i]));
                     }
                 }
             }
         }
     }
 
     ///Find all recursive function-calls that should be shown as call-tips
     CodeCompletionContext::Ptr parentContext(this);
     do {
         if (abort)
             return items;
 
         parentContext = parentContext->parentContext();
         if (parentContext) {
             if (parentContext->memberAccessOperation() == CodeCompletionContext::FunctionCallAccess) {
                 if (!parentContext->memberAccessContainer().allDeclarationIds().isEmpty()) {
                     Declaration* decl = parentContext->memberAccessContainer().allDeclarationIds().first()
                                             .getDeclaration(m_duContext->topContext());
 
                     if (!isValidCompletionItem(decl)) {
                         continue;
                     }
                     if ( !decl->isFunctionDeclaration() ) {
                         if ( ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(decl) ) {
                             // search for ctor
                             decl = nullptr;
                             foreach ( Declaration* dec, classDec->internalContext()->findDeclarations(Identifier("__construct")) ) {
                                 if ( dec->isFunctionDeclaration() ) {
                                     decl = dec;
                                     break;
                                 }
                             }
                             if ( !decl ) {
                                 foreach ( Declaration* dec, classDec->internalContext()->findDeclarations(classDec->identifier()) ) {
                                     if ( dec->isFunctionDeclaration() ) {
                                         decl = dec;
                                         break;
                                     }
                                 }
                             }
                             if ( !decl ) {
                                 continue;
                             }
                         } else if ( !decl->type<FunctionType>() ) {
                             qCDebug(COMPLETION) << "parent decl is neither function nor class nor closure, skipping" << decl->toString();
                             continue;
                         }
                     }
                     items << CompletionTreeItemPointer(
                                 new NormalDeclarationCompletionItem(
                                         DeclarationPointer(decl),
                                         Php::CodeCompletionContext::Ptr(parentContext.data())
                                 )
                             );
                 }
             } else {
                 qCDebug(COMPLETION) << "parent-context has non function-call access type";
             }
         }
     } while (parentContext);
 
     if ( m_memberAccessOperation == NoMemberAccess ) {
         ///TODO: function-like statements should just be handled as a function with declaration etc.
         ///      e.g.: empty, eval, die, exit, isset, unset
         ///      but _not_ echo, print, catch, include*, require*
         ///TODO: use user's style for indendation etc.
         ADD_KEYWORD2("abstract class", "abstract class %SELECT%NAME%ENDSELECT% {\n%INDENT%\n}\n");
         ADD_KEYWORD2("final class", "final class %SELECT%NAME%ENDSELECT% {\n%INDENT%\n}\n");
         ADD_KEYWORD2("class", "class %SELECT%NAME%ENDSELECT% {\n%INDENT%\n}\n");
         ADD_KEYWORD2("interface", "interface %SELECT%NAME%ENDSELECT% {\n%INDENT%\n}\n");
         ADD_KEYWORD2("array", "array(\n%INDENT%%CURSOR%\n)");
         ADD_KEYWORD2("break", "break;\n");
         ADD_KEYWORD2("case", "case %SELECT%CASE%ENDSELECT%:\n%INDENT%\n%INDENT%break;\n");
         ADD_KEYWORD2("throw", "throw %CURSOR%;\n");
         ADD_KEYWORD2("try", "try {\n%INDENT%%CURSOR%\n} catch() {\n$%INDENT%\n}\n");
         ADD_KEYWORD2("catch", "catch(%CURSOR%) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("clone", "clone %CURSOR%;\n");
         ADD_KEYWORD2("continue", "continue;\n");
         ADD_KEYWORD2("declare", "declare(%CURSOR%);\n");
         ADD_KEYWORD2("default", "default:\n%INDENT%%CURSOR%\n%INDENT%break;\n");
         ADD_KEYWORD2("do", "do {\n%INDENT%%CURSOR%\n} while();\n");
         ADD_KEYWORD2("echo", "echo %CURSOR%;\n");
         ADD_KEYWORD2("else", "else {\n%INDENT%%CURSOR%\n}\n");
         ADD_KEYWORD2("elseif", "elseif (%CURSOR%) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("endif", "endif;");
         ADD_KEYWORD2("endforeach", "endforeach;");
         ADD_KEYWORD2("endswitch", "endswitch;");
         ADD_KEYWORD2("endwhile", "endwhile;");
         ADD_KEYWORD2("endfor", "endfor;");
         ADD_KEYWORD2("enddeclare", "enddeclare;");
         ADD_KEYWORD2("empty", "empty(%CURSOR%)");
         ADD_KEYWORD2("eval", "eval(%CURSOR%)");
         ADD_KEYWORD2("die", "die(%CURSOR%);\n");
         ADD_KEYWORD2("exit", "exit(%CURSOR%);\n");
         ///TODO: only activate when after "class NAME "
         ADD_KEYWORD("extends");
         ADD_KEYWORD("implements");
         ADD_KEYWORD2("for", "for(%CURSOR%;;) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("foreach", "foreach(%CURSOR%) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("function", "function %SELECT%NAME%ENDSELECT%() {\n%INDENT%\n}\n");
         ADD_KEYWORD2("global", "global $%CURSOR%;");
         ADD_KEYWORD2("if", "if (%CURSOR%) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("include", "include '%CURSOR%';\n");
         ADD_KEYWORD2("include_once", "include_once '%CURSOR%';\n");
         ADD_KEYWORD2("require", "require '%CURSOR%';\n");
         ADD_KEYWORD2("require_once", "require_once '%CURSOR%';\n");
         ADD_KEYWORD2("isset", "isset(%CURSOR%)");
         ADD_KEYWORD2("list", "list(%CURSOR%)");
         ADD_KEYWORD2("print", "print %CURSOR%;\n");
         ADD_KEYWORD2("return", "return %CURSOR%;\n");
         ADD_KEYWORD2("static", "static $%CURSOR%%;\n");
         ADD_KEYWORD2("unset", "unset(%CURSOR%);\n");
         ADD_KEYWORD2("while", "while (%CURSOR%) {\n%INDENT%\n}\n");
         ADD_KEYWORD2("switch", "switch (%CURSOR%) {\n%INDENT%\n}\n");
     }
 
     return items;
 }
 
 inline bool CodeCompletionContext::isValidCompletionItem(Declaration* dec)
 {
     if ( !dec || dec->range().isEmpty() ) {
         // hack for included files
         return false;
     }
     if ( dec->kind() == Declaration::Type && dec->qualifiedIdentifier().isEmpty() ) {
         // filter closures
         return false;
     }
 
     static DUChainPointer<ClassDeclaration> exceptionDecl;
     if (!exceptionDecl) {
         /// Qualified identifier for 'exception'
         static const KDevelop::QualifiedIdentifier exceptionQId(QStringLiteral("exception"));
         QList<Declaration*> decs = dec->context()->findDeclarations(exceptionQId);
         Q_ASSERT(decs.count());
         if (!decs.isEmpty()) { // additional safe-guard, see e.g. https://bugs.kde.org/show_bug.cgi?id=294218
             exceptionDecl = dynamic_cast<ClassDeclaration*>(decs.first());
             Q_ASSERT(exceptionDecl);
         }
     }
     if (!exceptionDecl) {
         // safe-guard, see: https://bugs.kde.org/show_bug.cgi?id=294218
         qWarning() << "could not find PHP-Exception declaration, related code completion will be broken.";
     }
 
     if (m_memberAccessOperation == ExceptionChoose
             || m_memberAccessOperation == NewClassChoose
             || m_memberAccessOperation == InterfaceChoose
             || m_memberAccessOperation == ClassExtendsChoose
             || m_memberAccessOperation == InstanceOfChoose) {
         // filter current class
         if (!m_forbiddenIdentifiers.isEmpty() && m_forbiddenIdentifiers.contains(dec->qualifiedIdentifier().index())) {
             return false;
         }
         ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(dec);
 
         // filter non-classes
         if (!classDec) {
             return false;
         }
         // show non-interface and non-abstract
         else if (m_memberAccessOperation == NewClassChoose) {
             return !(classDec->classModifier() & ClassDeclarationData::Abstract)
                    && classDec->classType() == ClassDeclarationData::Class;
         }
         // filter non-exception classes
         else if (m_memberAccessOperation == ExceptionChoose) {
             if (!exceptionDecl) {
                 // safe-guard, see: https://bugs.kde.org/show_bug.cgi?id=294218
                 return false;
             }
             return classDec->equalQualifiedIdentifier(exceptionDecl.data())
                    || classDec->isPublicBaseClass(exceptionDecl.data(), m_duContext->topContext());
         }
         // show interfaces
         else if (m_memberAccessOperation == InterfaceChoose) {
             return classDec->classType() == ClassDeclarationData::Interface;
         }
         // show anything but final classes and interfaces
         else if (m_memberAccessOperation == ClassExtendsChoose) {
             return !(classDec->classModifier() & ClassDeclarationData::Final)
                    && classDec->classType() == ClassDeclarationData::Class;
         }
         else if (m_memberAccessOperation == InstanceOfChoose) {
             return true;
         }
     }
 
     if (m_memberAccessOperation == ExceptionInstanceChoose) {
         if (!exceptionDecl) {
             // safe-guard, see: https://bugs.kde.org/show_bug.cgi?id=294218
             return false;
         }
         if (dec->kind() != Declaration::Instance) {
             return false;
         }
         StructureType::Ptr structType = dec->type<StructureType>();
         if (!structType) {
             return false;
         }
         ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(structType->declaration(dec->topContext()));
         if (!classDec) {
             return false;
         }
         return classDec->isPublicBaseClass(exceptionDecl.data(), m_duContext->topContext());
     }
 
     if (m_memberAccessOperation == NoMemberAccess) {
         // filter private methods and class members when doing a global completion
         // when we are inside a class function, don't filter the private stuff
         // of the current class
         // NOTE: ClassFunctionDeclaration inherits ClassMemberDeclaration
         // NOTE: both have to have a parent context with type class
         if ( dec->context() && dec->context()->type() == DUContext::Class
                 && m_duContext->parentContext() != dec->context() )
         {
             if ( ClassMemberDeclaration* memberDec = dynamic_cast<ClassMemberDeclaration*>(dec) ) {
                 if ( memberDec->accessPolicy() == Declaration::Private ) {
                     return false;
                 }
             }
         }
         if ( !dec->isFunctionDeclaration() && m_duContext.data() == dec->context() && m_position < dec->range().start ) {
             return false;
         }
     }
 
     if (m_memberAccessOperation == NamespaceChoose) {
         return dec->kind() == Declaration::Namespace;
     }
 
     return true;
 }
 
 QList<QSet<IndexedString> > CodeCompletionContext::completionFiles()
 {
     QList<QSet<IndexedString> > ret;
     if (ICore::self()) {
         auto projects = ICore::self()->projectController()->projects();
         ret.reserve(projects.size());
         foreach(IProject* project, projects) {
             ret << project->fileSet();
         }
     }
     return ret;
 }
 
 }
diff --git a/duchain/builders/declarationbuilder.cpp b/duchain/builders/declarationbuilder.cpp
index ea29dfb..214f311 100644
--- a/duchain/builders/declarationbuilder.cpp
+++ b/duchain/builders/declarationbuilder.cpp
@@ -1,1527 +1,1527 @@
 /***************************************************************************
  *   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 "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 assigment 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,
         ReferencedTopDUContext 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();
 }
 
 void DeclarationBuilder::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node)
 {
     ClassDeclaration* interfaceDec = openTypeDeclaration(node->interfaceName, ClassDeclarationData::Interface);
     openType(interfaceDec->abstractType());
     DeclarationBuilderBase::visitInterfaceDeclarationStatement(node);
     closeType();
     closeDeclaration();
 }
 
 void DeclarationBuilder::visitTraitDeclarationStatement(TraitDeclarationStatementAst * node)
 {
     ClassDeclaration* traitDec = openTypeDeclaration(node->traitName, ClassDeclarationData::Trait);
     openType(traitDec->abstractType());
     DeclarationBuilderBase::visitTraitDeclarationStatement(node);
     closeType();
     closeDeclaration();
     m_upcomingClassVariables.clear();
 }
 
 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->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()->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());
 
     // check for redeclaration of private or protected stuff
     {
         // only interesting context might be the class context when we are inside a method
         DUContext *ctx = currentContext()->parentContext();
         foreach ( Declaration* dec, parentCtx->findDeclarations(identifier) ) {
             if ( ClassMemberDeclaration* cdec = dynamic_cast<ClassMemberDeclaration*>(dec) ) {
                 if ( cdec->accessPolicy() == Declaration::Private && cdec->context() != ctx ) {
                     reportError(i18n("Cannot redeclare private property %1 from this context.",
                                         cdec->toString()), node);
                     return;
                 } else if ( cdec->accessPolicy() == Declaration::Protected
                             && cdec->context() != ctx
                             && ( !ctx || !ctx->imports(cdec->context()) ) ) {
                     reportError(i18n("Cannot redeclare protected property %1 from this context.",
                                         cdec->toString()), node);
                     return;
                 }
                 if ( cdec->abstractType()->indexed() == type->indexed() ) {
                     encounter(dec);
                     return;
                 }
             }
         }
     }
 
     // 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)
 {
     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 redeclarations
         DUChainWriteLocker lock(DUChain::lock());
         foreach(Declaration * dec, currentContext()->findLocalDeclarations(identifierForNode(node->identifier).first(), startPos(node->identifier)))
         {
             if (wasEncountered(dec) && !dec->isFunctionDeclaration() && dec->abstractType()->modifiers() & AbstractType::ConstModifier) {
                 reportRedeclarationError(dec, node->identifier);
                 break;
             }
         }
     }
     ClassMemberDeclaration* dec = openDefinition<ClassMemberDeclaration>(node->identifier, node->identifier);
     {
         DUChainWriteLocker lock(DUChain::lock());
         dec->setAccessPolicy(Declaration::Public);
         dec->setStatic(true);
         dec->setKind(Declaration::Instance);
     }
     DeclarationBuilderBase::visitConstantDeclaration(node);
     closeDeclaration();
     if ( m_reportErrors ) {
         // const class members may only be ints, floats, bools or strings
         bool badType = true;
         if ( IntegralType* type = fastCast<IntegralType*>(lastType().data()) ) {
             switch( type->dataType() ) {
                 case IntegralType::TypeBoolean:
                 case IntegralType::TypeFloat:
                 case IntegralType::TypeInt:
                 case IntegralType::TypeString:
                 case IntegralType::TypeNull:
                     badType = false;
                     break;
                 default:
                     // every other type is a badType (see above)
                     break;
             }
         }
         if ( badType ) {
             reportError(i18n("Only booleans, ints, floats and strings are allowed for class constants."), node->scalar);
         }
     }
 }
 
 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 {
         alias = original;
     }
 
     if (!list.isEmpty()) {
         ClassMethodDeclaration* olddec = dynamic_cast<ClassMethodDeclaration*>(list.first());
         TraitMethodAliasDeclaration* newdec;
 
         // no existing declaration found, create one
         if (node->aliasIdentifier) {
             newdec = openDefinition<TraitMethodAliasDeclaration>(alias, m_editor->findRange(node->aliasIdentifier));
             newdec->setPrettyName(identifierPairForNode(node->aliasIdentifier).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 & 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());
         }
         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, 0);
 
     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 && symbol.compare(QLatin1String("null"), Qt::CaseInsensitive) != 0 ) {
+        } else if ( node->parameterType && node->parameterType->objectType && 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 if ( !node->defaultValue && funDec->defaultParametersSize() ) {
         reportError(i18n("Following parameters must have a default value assigned."), node);
     }
     {
         // 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::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 ( ReferenceType::Ptr rType = ReferenceType::Ptr::dynamicCast((*it)->abstractType()) ) {
                             if ( IntegralType::Ptr integral = IntegralType::Ptr::dynamicCast(rType->baseType()) ) {
                                 if ( integral->dataType() == IntegralType::TypeMixed ) {
                                     // referenced mixed to referenced @p type
                                     ReferenceType::Ptr newType(new ReferenceType());
                                     newType->setBaseType(type);
                                     (*it)->setType(newType);
                                     return;
                                 }
                             }
                         }
                         if ( IntegralType::Ptr integral = IntegralType::Ptr::dynamicCast((*it)->abstractType()) ) {
                             if ( integral->dataType() == IntegralType::TypeMixed ) {
                                 // mixed to @p type
                                 (*it)->setType(type);
                                 return;
                             }
                         }
                         // else make it unsure
                         UnsureType::Ptr unsure = UnsureType::Ptr::dynamicCast((*it)->abstractType());
                         // maybe it's referenced?
                         ReferenceType::Ptr rType = ReferenceType::Ptr::dynamicCast((*it)->abstractType());
                         if ( !unsure && rType ) {
                             unsure = UnsureType::Ptr::dynamicCast(rType->baseType());
                         }
                         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);
 
     if ( !m_findVariable.identifier.isEmpty() && currentAbstractType()) {
         //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 {
             // assigment 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);
         } else if ( node->stringFunctionNameOrClass ) {
             id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
             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, 0);
     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).cast<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:
             // http://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::visitUseNamespace(UseNamespaceAst* node)
 {
     DUChainWriteLocker lock;
 
     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);
 
     ///TODO: case insensitive!
     QualifiedIdentifier qid = identifierForNamespace(node->identifier, m_editor);
     ///TODO: find out why this must be done (see mail to kdevelop-devel on jan 18th 2011)
     qid.setExplicitlyGlobal( false );
 
     DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, qid);
 
     if (dec)
     {
         // Check for a name conflict
         DeclarationPointer dec2 = findDeclarationImport(ClassDeclarationType, 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
     {
         NamespaceAliasDeclaration* decl = openDefinition<NamespaceAliasDeclaration>(id.second,
                                                                                     m_editor->findRange(idNode));
         decl->setImportIdentifier( qid );
         decl->setPrettyName( id.first );
         decl->setKind(Declaration::NamespaceAlias);
     }
     closeDeclaration();
 }
 
 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);
     }
 }
 
 }
diff --git a/duchain/builders/typebuilder.cpp b/duchain/builders/typebuilder.cpp
index 0053763..ec05394 100644
--- a/duchain/builders/typebuilder.cpp
+++ b/duchain/builders/typebuilder.cpp
@@ -1,593 +1,554 @@
 /***************************************************************************
  *   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 "typebuilder.h"
 
 #include <language/duchain/identifier.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/integraltype.h>
 #include "../declarations/classdeclaration.h"
 #include "../types/indexedcontainer.h"
 #include "../types/integraltypeextended.h"
 #include "../types/structuretype.h"
 #include <duchaindebug.h>
 
 #include "editorintegrator.h"
 #include "parsesession.h"
 #include "phpdebugvisitor.h"
 #include "expressionparser.h"
 #include "expressionvisitor.h"
 #include "../declarations/classmethoddeclaration.h"
 #include <language/duchain/types/unsuretype.h>
 
 using namespace KDevelop;
 namespace Php
 {
 
 TypeBuilder::TypeBuilder()
     : TypeBuilderBase()
     , m_gotTypeFromDocComment(false)
     , m_gotReturnTypeFromDocComment(false)
 {
 }
 
 TypeBuilder::~TypeBuilder()
 {
 }
 
 AbstractType::Ptr TypeBuilder::parseType(QString type, AstNode* node)
 {
     uint iType = 0;
     type = type.trimmed();
     if (!type.compare(QLatin1String("int"), Qt::CaseInsensitive) || !type.compare(QLatin1String("integer"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeInt;
     } else if (!type.compare(QLatin1String("float"), Qt::CaseInsensitive) || !type.compare(QLatin1String("double"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeFloat;
     } else if (!type.compare(QLatin1String("bool"), Qt::CaseInsensitive) || !type.compare(QLatin1String("boolean"), Qt::CaseInsensitive)
             || !type.compare(QLatin1String("false"), Qt::CaseInsensitive) || !type.compare(QLatin1String("true"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeBoolean;
     } else if (!type.compare(QLatin1String("string"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeString;
     } else if (!type.compare(QLatin1String("mixed"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeMixed;
     } else if (!type.compare(QLatin1String("array"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeArray;
     } else if (!type.compare(QLatin1String("resource"), Qt::CaseInsensitive)) {
         return AbstractType::Ptr(new IntegralTypeExtended(IntegralTypeExtended::TypeResource));
     } else if (!type.compare(QLatin1String("null"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeNull;
     } else if (!type.compare(QLatin1String("void"), Qt::CaseInsensitive)) {
         iType = IntegralType::TypeVoid;
     } else if (!type.compare(QLatin1String("self"), Qt::CaseInsensitive)
             || !type.compare(QLatin1String("this"), Qt::CaseInsensitive) || !type.compare(QLatin1String("static"), Qt::CaseInsensitive)) {
         DUChainReadLocker lock(DUChain::lock());
         if ( currentContext()->type() == DUContext::Class && currentContext()->owner() ) {
             return currentContext()->owner()->abstractType();
         }
     } else {
         if (!type.compare(QLatin1String("object"), Qt::CaseInsensitive)) {
             type = QStringLiteral("stdclass");
         }
         //don't use openTypeFromName as it uses cursor for findDeclarations
         DeclarationPointer decl = findDeclarationImport(ClassDeclarationType,
                                                         QualifiedIdentifier(type.toLower()));
         if (decl && decl->abstractType()) {
             return decl->abstractType();
         }
         if (type.contains('|')) {
             QList<AbstractType::Ptr> types;
             foreach (const QString& t, type.split('|')) {
                 AbstractType::Ptr subType = parseType(t, node);
                 if (!(IntegralType::Ptr::dynamicCast(subType) && IntegralType::Ptr::staticCast(subType)->dataType() == IntegralType::TypeMixed)) {
                     types << parseType(t, node);
                 }
             }
             if (!type.isEmpty()) {
                 UnsureType::Ptr ret(new UnsureType());
                 foreach (const AbstractType::Ptr& t, types) {
                     ret->addType(t->indexed());
                 }
                 //qCDebug(DUCHAIN) << type << ret->toString();
                 return AbstractType::Ptr::staticCast(ret);
             }
         }
         iType = IntegralType::TypeMixed;
     }
     AbstractType::Ptr ret(new IntegralType(iType));
     //qCDebug(DUCHAIN) << type << ret->toString();
     return ret;
 }
 
 AbstractType::Ptr TypeBuilder::injectParseType(QString type, AstNode* node)
 {
     AbstractType::Ptr ret = parseType(type, node);
     injectType(ret);
     //qCDebug(DUCHAIN) << type << ret->toString();
     return ret;
 }
 
 /**
  * Find all (or only one - see @p docCommentName) values for a given needle
  * in a doc-comment. Needle has to start a line in the doccomment,
  * i.e.:
  *
  *  * @docCommentName value
  *
  * or
  *
  *  /// @docCommentName value
  */
 QStringList findInDocComment(const QString &docComment, const QString &docCommentName, const bool onlyOne)
 {
     QStringList matches;
     // optimization that does not require potentially slow regexps
     // old code was something like this:
     /*
     if (!docComment.isEmpty()) {
         QRegExp rx("\\*\\s+@param\\s([^\\s]*)");
         int pos = 0;
         while ((pos = rx.indexIn(docComment, pos)) != -1) {
             ret << parseType(rx.cap(1), node);
             pos += rx.matchedLength();
         }
     }
     */
 
     for ( int i = 0, size = docComment.size(); i < size; ++i ) {
         if ( docComment[i].isSpace() || docComment[i] == '*' || docComment[i] == '/' ) {
             // skip whitespace and comment-marker at beginning of line
             continue;
         } else if ( docComment[i] == '@' && docComment.midRef(i + 1, docCommentName.size()) == docCommentName ) {
             // find @return or similar
             i += docCommentName.size() + 1;
             // skip whitespace (at least one is required)
             if ( i >= size || !docComment[i].isSpace() ) {
                 // skip to next line
                 i = docComment.indexOf('\n', i);
                 if ( i == -1 ) {
                     break;
                 }
                 continue;
             } else if ( docComment[i] == '\n' ) {
                 continue;
             }
             ++i; // at least one whitespace
             while ( i < size && docComment[i].isSpace() ) {
                 ++i;
             }
             // finally get the typename
             int pos = i;
             while ( pos < size && !docComment[pos].isSpace() ) {
                 ++pos;
             }
             if ( pos > i ) {
                 matches << docComment.mid(i, pos - i);
                 if ( onlyOne ) {
                     break;
                 } else {
                     i = pos;
                 }
             }
         }
         // skip to next line
         i = docComment.indexOf('\n', i);
         if ( i == -1 ) {
             break;
         }
     }
 
     return matches;
 }
 
 AbstractType::Ptr TypeBuilder::parseDocComment(AstNode* node, const QString& docCommentName)
 {
     m_gotTypeFromDocComment = false;
     const QString& docComment = editor()->parseSession()->docComment(node->startToken);
 
     if ( !docComment.isEmpty() ) {
         const QStringList& matches = findInDocComment(docComment, docCommentName, true);
         if ( !matches.isEmpty() ) {
             AbstractType::Ptr type;
             if (matches.first() == QLatin1String("$this")) {
                 DUChainReadLocker lock(DUChain::lock());
                 if (currentContext()->owner()) {
                     type = currentContext()->owner()->abstractType();
                 }
             } else {
                 type = injectParseType(matches.first(), node);
             }
             if (type) {
                 m_gotTypeFromDocComment = true;
             }
             return type;
         }
     }
     return AbstractType::Ptr();
 }
 
 QList<AbstractType::Ptr> TypeBuilder::parseDocCommentParams(AstNode* node)
 {
     QList<AbstractType::Ptr> ret;
     QString docComment = editor()->parseSession()->docComment(node->startToken);
     if ( !docComment.isEmpty() ) {
         const QStringList& matches = findInDocComment(docComment, QStringLiteral("param"), false);
         if ( !matches.isEmpty() ) {
             ret.reserve(matches.size());
             foreach ( const QString& type, matches ) {
                 ret << parseType(type, node);
             }
         }
     }
     return ret;
 }
 
 AbstractType::Ptr TypeBuilder::getTypeForNode(AstNode* node)
 {
 
     AbstractType::Ptr type;
     if (node) {
         type = parseDocComment(node, QStringLiteral("var")); //we fully trust in @var typehint and don't try to evaluate ourself
         if (!type) {
             node->ducontext = currentContext();
             ExpressionParser ep;
             ep.setCreateProblems(true);
             ExpressionEvaluationResult res = ep.evaluateType(node, editor());
             if (res.hadUnresolvedIdentifiers()) {
                 m_hadUnresolvedIdentifiers = true;
             }
             type = res.type();
         }
     }
     if (!type) {
         type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
     }
     return type;
 }
 
 FunctionType::Ptr TypeBuilder::openFunctionType(AstNode* node)
 {
     FunctionType::Ptr functionType = FunctionType::Ptr(new FunctionType());
 
     openType(functionType);
 
     functionType->setReturnType(parseDocComment(node, QStringLiteral("return")));
     m_gotReturnTypeFromDocComment = functionType->returnType();
     updateCurrentType();
 
     return functionType;
 }
 
 void TypeBuilder::visitClassDeclarationStatement(ClassDeclarationStatementAst* node)
 {
     // the predeclaration builder should have set up a type already
     // and the declarationbuilder should have set that as current type
     Q_ASSERT(hasCurrentType() && currentType<StructureType>());
 
     TypeBuilderBase::visitClassDeclarationStatement(node);
 }
 
 void TypeBuilder::visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst* node)
 {
     // the predeclaration builder should have set up a type already
     // and the declarationbuilder should have set that as current type
     Q_ASSERT(hasCurrentType() && currentType<StructureType>());
 
     TypeBuilderBase::visitInterfaceDeclarationStatement(node);
 }
 
 void TypeBuilder::visitTraitDeclarationStatement(TraitDeclarationStatementAst* node)
 {
     // the predeclaration builder should have set up a type already
     // and the declarationbuilder should have set that as current type
     Q_ASSERT(hasCurrentType() && currentType<StructureType>());
 
     TypeBuilderBase::visitTraitDeclarationStatement(node);
 }
 
 void TypeBuilder::visitClassStatement(ClassStatementAst *node)
 {
     if (node->methodName) {
         //method declaration
         m_currentFunctionParams = parseDocCommentParams(node);
         openFunctionType(node);
         TypeBuilderBase::visitClassStatement(node);
         if (currentType<FunctionType>() && !currentType<FunctionType>()->returnType()) {
             currentType<FunctionType>()->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
         }
         closeType();
     } else {
         //member-variable
         parseDocComment(node, QStringLiteral("var"));
         TypeBuilderBase::visitClassStatement(node);
         if (m_gotTypeFromDocComment) {
             clearLastType();
             m_gotTypeFromDocComment = false;
         }
     }
 }
 
 void TypeBuilder::visitClassVariable(ClassVariableAst *node)
 {
     if (!m_gotTypeFromDocComment) {
         openAbstractType(getTypeForNode(node->value));
 
         TypeBuilderBase::visitClassVariable(node);
 
         closeType();
     } else {
         TypeBuilderBase::visitClassVariable(node);
     }
 }
 
 void TypeBuilder::visitConstantDeclaration(ConstantDeclarationAst* node)
 {
     if (!m_gotTypeFromDocComment || !currentAbstractType()) {
         AbstractType::Ptr type = getTypeForNode(node->scalar);
         type->setModifiers(type->modifiers() | AbstractType::ConstModifier);
         openAbstractType(type);
 
         TypeBuilderBase::visitConstantDeclaration(node);
 
         closeType();
     } else {
         currentAbstractType()->setModifiers(currentAbstractType()->modifiers() & AbstractType::ConstModifier);
         TypeBuilderBase::visitConstantDeclaration(node);
     }
 }
 
 void TypeBuilder::visitParameter(ParameterAst *node)
 {
-    AbstractType::Ptr type;
-    if (node->isVariadic != -1) {
-        if (node->parameterType) {
-            //don't use openTypeFromName as it uses cursor for findDeclarations
-            DeclarationPointer decl = findDeclarationImport(ClassDeclarationType,
-                                                      identifierForNamespace(node->parameterType, editor()));
-            if (decl) {
-                IndexedContainer *container = new IndexedContainer();
-                const IndexedString *containerType = new IndexedString("array");
-                container->addEntry(decl->abstractType());
-                container->setPrettyName(*containerType);
-                type = AbstractType::Ptr(container);
-            }
-        } else {
-            type = AbstractType::Ptr(new IntegralType(IntegralType::TypeArray));
-        }
-    } else if (node->parameterType) {
-        //don't use openTypeFromName as it uses cursor for findDeclarations
-        DeclarationPointer decl = findDeclarationImport(ClassDeclarationType,
-                                                  identifierForNamespace(node->parameterType, editor()));
-        if (decl) {
-            type = decl->abstractType();
-        }
-    } else if (node->arrayType != -1) {
-        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeArray));
-    } else if (node->defaultValue) {
-        ExpressionVisitor v(editor());
-        node->defaultValue->ducontext = currentContext();
-        v.visitNode(node->defaultValue);
-        type = v.result().type();
-    }
-    if (!type) {
-        if (m_currentFunctionParams.count() > currentType<FunctionType>()->arguments().count()) {
-            type = m_currentFunctionParams.at(currentType<FunctionType>()->arguments().count());
-        } else {
-            type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
-        }
+    AbstractType::Ptr phpDocTypehint;
+    if (m_currentFunctionParams.count() > currentType<FunctionType>()->arguments().count()) {
+        phpDocTypehint = m_currentFunctionParams.at(currentType<FunctionType>()->arguments().count());
     }
 
-    if ( node->isRef != -1 ) {
-      ReferenceType::Ptr p( new ReferenceType() );
-      p->setBaseType( type );
-
-      type = p.cast<AbstractType>();
-    }
+    AbstractType::Ptr type = parameterType(node, phpDocTypehint, editor(), currentContext());
 
     openAbstractType(type);
     TypeBuilderBase::visitParameter(node);
     closeType();
     DUChainWriteLocker lock(DUChain::lock());
     currentType<FunctionType>()->addArgument(type);
 }
 
 void TypeBuilder::visitFunctionDeclarationStatement(FunctionDeclarationStatementAst* node)
 {
     m_currentFunctionParams = parseDocCommentParams(node);
     // the predeclarationbuilder should have already built the type
     // and the declarationbuilder should have set it to open
     Q_ASSERT(hasCurrentType());
     FunctionType::Ptr type = currentType<FunctionType>();
     Q_ASSERT(type);
 
     type->setReturnType(parseDocComment(node, QStringLiteral("return")));
     m_gotReturnTypeFromDocComment = type->returnType();
 
     updateCurrentType();
 
     TypeBuilderBase::visitFunctionDeclarationStatement(node);
 
     if (!type->returnType()) {
         type->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
     }
 }
 
 void TypeBuilder::visitClosure(ClosureAst* node)
 {
     m_currentFunctionParams = parseDocCommentParams(node);
     FunctionType::Ptr type = FunctionType::Ptr(new FunctionType());
     openType(type);
 
     type->setReturnType(parseDocComment(node, QStringLiteral("return")));
     m_gotReturnTypeFromDocComment = type->returnType();
 
     updateCurrentType();
 
     TypeBuilderBase::visitClosure(node);
 
     if (!type->returnType()) {
         type->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
     }
     closeType();
 }
 
 void TypeBuilder::visitAssignmentExpression(AssignmentExpressionAst* node)
 {
     // performance: only try to find type when we are actually in an assignment expr
     if (node->assignmentExpression || node->assignmentExpressionEqual) {
         openAbstractType(getTypeForNode(node));
     }
 
     TypeBuilderBase::visitAssignmentExpression(node);
 
     if (node->assignmentExpression || node->assignmentExpressionEqual) {
         closeType();
     }
 }
 
 void TypeBuilder::visitStaticVar(StaticVarAst *node)
 {
     openAbstractType(getTypeForNode(node->value));
 
     TypeBuilderBase::visitStaticVar(node);
 
     closeType();
 }
 
 void TypeBuilder::visitStatement(StatementAst* node)
 {
     TypeBuilderBase::visitStatement(node);
     if ( !m_gotReturnTypeFromDocComment && node->returnExpr && hasCurrentType() && currentType<FunctionType>())
     {
         FunctionType::Ptr ft = currentType<FunctionType>();
         // qCDebug(DUCHAIN) << "return" << (ft->returnType() ? ft->returnType()->toString() : "none") << lastType()->toString();
         AbstractType::Ptr type = getTypeForNode(node->returnExpr);
         if (type) {
             // ignore references for return values, PHP does so as well
             if ( ReferenceType::Ptr rType = ReferenceType::Ptr::dynamicCast(type) ) {
                 type = rType->baseType();
             }
             if (ft->returnType() && !ft->returnType()->equals(type.data())) {
                 if (ft->returnType().cast<IntegralType>()
                     && ft->returnType().cast<IntegralType>()->dataType() == IntegralType::TypeMixed)
                 {
                     //don't add TypeMixed to the list, just ignore
                     ft->setReturnType(type);
                 } else {
                     UnsureType::Ptr retT;
                     if (ft->returnType().cast<UnsureType>()) {
                         //qCDebug(DUCHAIN) << "we already have an unsure type";
                         retT = ft->returnType().cast<UnsureType>();
                         if (type.cast<UnsureType>()) {
                             //qCDebug(DUCHAIN) << "add multiple to returnType";
                             FOREACH_FUNCTION(const IndexedType& t, type.cast<UnsureType>()->types) {
                                 retT->addType(t);
                             }
                         } else {
                             //qCDebug(DUCHAIN) << "add to returnType";
                             retT->addType(type->indexed());
                         }
                     } else {
                         if (type.cast<UnsureType>()) {
                             retT = type.cast<UnsureType>();
                         } else {
                             retT = new UnsureType();
                             retT->addType(type->indexed());
                         }
                         retT->addType(ft->returnType()->indexed());
                     }
                     ft->setReturnType(AbstractType::Ptr::staticCast(retT));
                 }
             } else {
                 ft->setReturnType(type);
             }
             updateCurrentType();
         }
     }
 
     AstNode *foreachNode = nullptr;
     if (node->foreachVar) {
         foreachNode = node->foreachVar;
     } else if (node->foreachExpr) {
         foreachNode = node->foreachExpr;
     } else if (node->foreachExprAsVar) {
         foreachNode = node->foreachExprAsVar;
     }
     if (foreachNode) {
         ExpressionVisitor v(editor());
         foreachNode->ducontext = currentContext();
         v.visitNode(foreachNode);
         DUChainReadLocker lock(DUChain::lock());
         bool foundType = false;
         if (StructureType::Ptr type = StructureType::Ptr::dynamicCast(v.result().type())) {
             ClassDeclaration *classDec = dynamic_cast<ClassDeclaration*>(type->declaration(currentContext()->topContext()));
             if (!classDec) {
                 ///FIXME: this is just a hack for https://bugs.kde.org/show_bug.cgi?id=269369
                 ///       a proper fix needs full fledged two-pass, i.e. get rid of PreDeclarationBuilder
                 // 0 == global lookup and the delcaration is found again...
                 classDec = dynamic_cast<ClassDeclaration*>(type->declaration(nullptr));
             }
             if (classDec) {
                 /// Qualified identifier for 'iterator'
                 static const QualifiedIdentifier iteratorQId(QStringLiteral("iterator"));
                 ClassDeclaration* iteratorDecl = dynamic_cast<ClassDeclaration*>(
                     findDeclarationImport(ClassDeclarationType, iteratorQId).data()
                 );
                 Q_ASSERT(iteratorDecl);
                 if (classDec->isPublicBaseClass(iteratorDecl, currentContext()->topContext())) {
                     /// Qualified identifier for 'current'
                     static const QualifiedIdentifier currentQId(QStringLiteral("current"));
                     foreach (Declaration *d, classDec->internalContext()->findDeclarations(currentQId)) {
                         if (!dynamic_cast<ClassMethodDeclaration*>(d)) continue;
                         Q_ASSERT(d->type<FunctionType>());
                         injectType(d->type<FunctionType>()->returnType());
                         foundType = true;
                         // qCDebug(DUCHAIN) << "that's it: " << d->type<FunctionType>()->returnType()->toString();
                     }
                 }
             }
         }
         if (!foundType) {
             injectType(AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed)));
         }
     }
 }
 
 void TypeBuilder::visitCatchItem(Php::CatchItemAst *node)
 {
     TypeBuilderBase::visitCatchItem(node);
     DeclarationPointer dec = findDeclarationImport(ClassDeclarationType,
                                                    identifierForNamespace(node->catchClass, m_editor));
     if (dec && dec->abstractType()) {
         openAbstractType(dec->abstractType());
         closeType();
     }
 
 }
 
 void TypeBuilder::updateCurrentType()
 {
     // do nothing
 }
 
 }
 
diff --git a/duchain/builders/usebuilder.cpp b/duchain/builders/usebuilder.cpp
index d99fde9..836cd50 100644
--- a/duchain/builders/usebuilder.cpp
+++ b/duchain/builders/usebuilder.cpp
@@ -1,275 +1,275 @@
 /***************************************************************************
  *   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 "usebuilder.h"
 
 #include <KLocalizedString>
 
 #include "editorintegrator.h"
 #include "expressionvisitor.h"
 #include "parsesession.h"
 #include <duchaindebug.h>
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 class UseExpressionVisitor : public ExpressionVisitor
 {
 public:
     UseExpressionVisitor(EditorIntegrator* editor, UseBuilder* useBuilder)
             : ExpressionVisitor(editor), m_builder(useBuilder) {
     }
 
 protected:
     void usingDeclaration(AstNode* node, const DeclarationPointer& decl) override {
         m_builder->newCheckedUse(node, decl);
     }
 
 private:
     UseBuilder* m_builder;
 };
 
 UseBuilder::UseBuilder( EditorIntegrator* editor )
 {
     m_editor = editor;
 }
 
 ReferencedTopDUContext UseBuilder::build ( const IndexedString& url, AstNode* node, ReferencedTopDUContext updateContext )
 {
     // just for safety purposes: running the UseBuilder on the internal function file
     // will lead to undefined behavior due to the amount of optimization it has received
     // (esp. in the contextbuilder)
     Q_ASSERT(url != internalFunctionFile());
     return UseBuilderBase::build ( url, node, updateContext );
 }
 
 void UseBuilder::visitParameter(ParameterAst *node)
 {
-    if (node->parameterType) {
-        buildNamespaceUses(node->parameterType);
+    if (node->parameterType && node->parameterType->objectType) {
+        buildNamespaceUses(node->parameterType->objectType);
     }
 }
 
 void UseBuilder::visitClassImplements(ClassImplementsAst *node)
 {
     if (node->implementsSequence) {
         const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
         do {
             buildNamespaceUses(__it->element);
             __it = __it->next;
         } while (__it != __end);
     }
 }
 
 void UseBuilder::visitClassExtends(ClassExtendsAst *node)
 {
     buildNamespaceUses(node->identifier);
 }
 
 void UseBuilder::visitClassStatement(ClassStatementAst *node)
 {
      if (!node->traitsSequence) {
         UseBuilderBase::visitClassStatement(node);
         return;
      }
 
     const KDevPG::ListNode< NamespacedIdentifierAst* >* it = node->traitsSequence->front();
     forever {
         buildNamespaceUses(it->element, ClassDeclarationType);
 
         if ( it->hasNext() ) {
             it = it->next;
         } else {
             break;
         }
     }
 
     if (node->imports) {
         visitTraitAliasDeclaration(node->imports);
     }
 
     UseBuilderBase::visitClassStatement(node);
 }
 
 void UseBuilder::visitTraitAliasStatement(TraitAliasStatementAst *node)
 {
     if (node->conflictIdentifierSequence) {
         const KDevPG::ListNode< NamespacedIdentifierAst* >* it = node->conflictIdentifierSequence->front();
         forever {
             buildNamespaceUses(it->element, ClassDeclarationType);
 
             if ( it->hasNext() ) {
                 it = it->next;
             } else {
                 break;
             }
         }
     }
 
     DUChainWriteLocker lock;
     DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, identifierForNamespace(node->importIdentifier->identifier, m_editor));
 
     if (dec) {
         QualifiedIdentifier original = identifierPairForNode(node->importIdentifier->methodIdentifier).second;
         QList <Declaration*> list = dec.data()->internalContext()->findLocalDeclarations(original.last(), dec.data()->internalContext()->range().start);
 
         if (!list.isEmpty()) {
             UseBuilderBase::newUse(node->importIdentifier->methodIdentifier, DeclarationPointer(list.first()));
         }
     }
 
     lock.unlock();
 
     visitTraitAliasIdentifier(node->importIdentifier);
 }
 
 void UseBuilder::visitTraitAliasIdentifier(TraitAliasIdentifierAst *node)
 {
     buildNamespaceUses(node->identifier, ClassDeclarationType);
 }
 
 void UseBuilder::visitExpr(ExprAst* node)
 {
     visitNodeWithExprVisitor(node);
 }
 
 void UseBuilder::visitGlobalVar(GlobalVarAst* node)
 {
     if (node->var) {
         DeclarationPointer dec = findDeclarationImport(GlobalVariableDeclarationType, node->var);
         if (dec) {
             newCheckedUse(node->var, dec);
         }
     }
 }
 
 void UseBuilder::visitStaticScalar(StaticScalarAst* node)
 {
     if (currentContext()->type() == DUContext::Class) {
         visitNodeWithExprVisitor(node);
     }
 }
 
 void UseBuilder::visitStatement(StatementAst *node)
 {
     if (node->foreachVar) {
         visitNodeWithExprVisitor(node->foreachVar);
     } else if (node->unsetVariablesSequence) {
         visitNodeWithExprVisitor(node);
     }
 
     if (node->foreachExprAsVar) {
         visitNodeWithExprVisitor(node->foreachExprAsVar);
     }
     if (node->foreachVarAsVar) {
         visitNodeWithExprVisitor(node->foreachVarAsVar);
     }
     if (node->foreachVariable) {
         visitNodeWithExprVisitor(node->foreachVariable);
     }
 
     UseBuilderBase::visitStatement(node);
 }
 
 void UseBuilder::visitCatchItem(CatchItemAst *node)
 {
     if (node->catchClass) {
         buildNamespaceUses(node->catchClass, ClassDeclarationType);
     }
     UseBuilderBase::visitCatchItem(node);
 }
 
 void UseBuilder::newCheckedUse(AstNode* node, const DeclarationPointer& declaration, bool reportNotFound)
 {
     if ( declaration && declaration->comment().contains("@deprecated") ) {
         reportError(i18n("Usage of %1 is deprecated.", declaration->toString()), node, IProblem::Hint);
     } else if ( !declaration && reportNotFound ) {
         reportError(i18n("Declaration not found: %1", m_editor->parseSession()->symbol(node)), node, IProblem::Hint);
     }
     UseBuilderBase::newUse(node, declaration);
 }
 
 void UseBuilder::visitUnaryExpression( UnaryExpressionAst* node )
 {
     IndexedString includeFile = getIncludeFileForNode(node, m_editor);
     if ( !includeFile.isEmpty() ) {
         QualifiedIdentifier identifier(includeFile.str());
 
         DUChainWriteLocker lock(DUChain::lock());
         foreach ( Declaration* dec, currentContext()->topContext()->findDeclarations(identifier) ) {
             if ( dec->kind() == Declaration::Import ) {
                 newUse(node->includeExpression, DeclarationPointer(dec));
                 return;
             }
         }
     }
 }
 
 void UseBuilder::visitUseNamespace(UseNamespaceAst* node)
 {
     buildNamespaceUses(node->identifier, NamespaceDeclarationType);
 }
 
 void UseBuilder::buildNamespaceUses(NamespacedIdentifierAst* node, DeclarationType lastType)
 {
     const QualifiedIdentifier identifier = identifierForNamespace(node, m_editor);
     QualifiedIdentifier curId;
     curId.setExplicitlyGlobal(identifier.explicitlyGlobal());
     Q_ASSERT(identifier.count() == node->namespaceNameSequence->count());
     for ( int i = 0; i < identifier.count() - 1; ++i ) {
         curId.push(identifier.at(i));
         AstNode* n = node->namespaceNameSequence->at(i)->element;
         DeclarationPointer dec = findDeclarationImport(NamespaceDeclarationType, curId);
         if (!dec || dec->range() != editorFindRange(n, n)) {
             newCheckedUse(n, dec, true);
         }
     }
     newCheckedUse(node->namespaceNameSequence->back()->element,
                   findDeclarationImport(lastType, identifier),
                   lastType == ClassDeclarationType || lastType == ConstantDeclarationType
                   || lastType == FunctionDeclarationType || lastType == NamespaceDeclarationType);
 }
 
 void UseBuilder::openNamespace(NamespaceDeclarationStatementAst* parent, IdentifierAst* node,
                                const IdentifierPair& identifier, const RangeInRevision& range)
 {
     if (node != parent->namespaceNameSequence->back()->element) {
         DeclarationPointer dec = findDeclarationImport(NamespaceDeclarationType, identifier.second);
         if (!dec || dec->range() != editorFindRange(node, node)) {
             newCheckedUse(node, dec);
         }
     }
     UseBuilderBase::openNamespace(parent, node, identifier, range);
 }
 
 void UseBuilder::visitNodeWithExprVisitor(AstNode* node)
 {
     UseExpressionVisitor v(m_editor, this);
     node->ducontext = currentContext();
     v.visitNode(node);
 
     if (v.result().hadUnresolvedIdentifiers()) {
         m_hadUnresolvedIdentifiers = true;
     }
 }
 
 }
diff --git a/duchain/expressionvisitor.cpp b/duchain/expressionvisitor.cpp
index 7ae39ec..0b542d7 100644
--- a/duchain/expressionvisitor.cpp
+++ b/duchain/expressionvisitor.cpp
@@ -1,819 +1,792 @@
 /***************************************************************************
  *   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 "expressionvisitor.h"
 #include "parsesession.h"
 #include "editorintegrator.h"
 #include "helper.h"
 #include "declarations/variabledeclaration.h"
 #include "declarations/classdeclaration.h"
 
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/structuretype.h>
 
 #include "duchaindebug.h"
 
 #define ifDebug(x)
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 ExpressionVisitor::ExpressionVisitor(EditorIntegrator* editor)
         : m_editor(editor), m_createProblems(false),
           m_offset(CursorInRevision::invalid()), m_currentContext(nullptr),
           m_isAssignmentExpressionEqual(false),
           m_inDefine(false)
 {
 }
 
 DeclarationPointer ExpressionVisitor::processVariable(VariableIdentifierAst* variable)
 {
     Q_ASSERT(m_currentContext);
 
     CursorInRevision position = m_editor->findPosition(variable->variable, EditorIntegrator::BackEdge);
 
     if ( m_offset.isValid() ) {
         position.line += m_offset.line;
         position.column += m_offset.column;
     }
 
     DeclarationPointer ret;
     Identifier identifier = identifierForNode(variable).last();
 
     ifDebug(qCDebug(DUCHAIN) << "processing variable" << identifier.toString() << position.castToSimpleCursor();)
 
     DUChainReadLocker lock;
 
     if (identifier.nameEquals(Identifier(QStringLiteral("this")))) {
         if (m_currentContext->parentContext()
                 && m_currentContext->parentContext()->type() == DUContext::Class
                 && m_currentContext->parentContext()->owner()) {
             ret = m_currentContext->parentContext()->owner();
         }
     } else {
         //DontSearchInParent-flag because (1) in Php global variables aren't available in function
         //context and (2) a function body consists of a single context (so this is no problem)
         ret = findVariableDeclaration(m_currentContext, identifier, position, DUContext::DontSearchInParent);
     }
     if (!ret && m_currentContext->type() == DUContext::Namespace)
     {
         ret = findVariableDeclaration(m_currentContext, identifier, position, DUContext::NoSearchFlags);
     }
     if (!ret) {
         //look for a function argument
         ///TODO: why doesn't m_currentContext->findDeclarations() work?
         ///      evaluate if the stuff below is fast enough (faster?) than findDeclarations()
         ///see r1028306
         foreach(const DUContext::Import &import, m_currentContext->importedParentContexts() ) {
             if ( !import.isDirect() || import.position > position ) {
                 continue;
             }
             DUContext* ctx = import.context(m_currentContext->topContext());
             if ( ctx->type() == DUContext::Function ) {
                 QList<Declaration*> args = ctx->findLocalDeclarations(identifier);
                 if ( !args.isEmpty() ) {
                     ret = args.first();
                     break;
                 }
             }
         }
     }
     if (!ret) {
         //look for a superglobal variable
         foreach(Declaration* dec, m_currentContext->topContext()->findDeclarations(identifier, position)) {
             VariableDeclaration* varDec = dynamic_cast<VariableDeclaration*>(dec);
             if (varDec && varDec->isSuperglobal()) {
                 ret = dec;
                 break;
             }
         }
     }
 
     lock.unlock();
 
     if ( !m_isAssignmentExpressionEqual || identifier.nameEquals( Identifier(QStringLiteral("this")) )
          // might be something like $s = $s . $s; in which case we have to add a use for the first $s
          || (ret && ret->range().end < position) )
     {
         // also don't report uses for the place of declaration
         if (!ret || ret->range().end != position) {
             usingDeclaration(variable, ret);
         }
     }
     ifDebug(qCDebug(DUCHAIN) << "found declaration:" << (ret ? ret->toString() : QString("no declaration found"));)
     return ret;
 }
 
 void ExpressionVisitor::visitNode(AstNode *node)
 {
     if (node && node->ducontext) {
         m_currentContext = node->ducontext;
     }
     Q_ASSERT(m_currentContext);
     DefaultVisitor::visitNode(node);
 }
 
 void ExpressionVisitor::visitAssignmentExpression(AssignmentExpressionAst *node)
 {
     if (node->assignmentExpressionEqual) {
         m_isAssignmentExpressionEqual = true;
     }
     visitNode(node->expression);
     m_isAssignmentExpressionEqual = false;
 
     visitNode(node->assignmentExpressionEqual);
     visitNode(node->assignmentExpression);
 
     if (node->operation == OperationPlus || node->operation == OperationMinus ||
             node->operation == OperationMul || node->operation == OperationDiv ||
             node->operation == OperationExp) {
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeInt)));
     } else if (node->operation == OperationConcat) {
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeString)));
     }
 }
 
 void ExpressionVisitor::visitArrayIndexSpecifier(ArrayIndexSpecifierAst* node)
 {
     DefaultVisitor::visitArrayIndexSpecifier(node);
 
     // it's an array item but we don't support it really, so just assign type mixed and be done
     m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed)));
 }
 
 void ExpressionVisitor::visitCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst *node)
 {
     if (node->variable) {
         m_result.setDeclaration(processVariable(node->variable));
     }
     DefaultVisitor::visitCompoundVariableWithSimpleIndirectReference(node);
 }
 
 void ExpressionVisitor::visitVariable(VariableAst* node)
 {
     if ( node->variablePropertiesSequence &&
          node->variablePropertiesSequence->front() &&
          node->variablePropertiesSequence->front()->element &&
          node->variablePropertiesSequence->front()->element->variableProperty &&
          node->variablePropertiesSequence->front()->element->variableProperty->objectProperty ) {
         // make sure we mark $foo as a use in $foo->...
         bool isAssignmentExpressionEqual = m_isAssignmentExpressionEqual;
         m_isAssignmentExpressionEqual = false;
         DefaultVisitor::visitVariable(node);
         m_isAssignmentExpressionEqual = isAssignmentExpressionEqual;
     } else {
         DefaultVisitor::visitVariable(node);
     }
 }
 
 void ExpressionVisitor::visitVarExpressionNewObject(VarExpressionNewObjectAst *node)
 {
     DefaultVisitor::visitVarExpressionNewObject(node);
     if (node->className->staticIdentifier != -1) {
         static const QualifiedIdentifier id(QStringLiteral("static"));
         DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, id);
         usingDeclaration(node->className, dec);
         m_result.setDeclaration(dec);
     } else if (node->className->identifier) {
         const QualifiedIdentifier id = identifierForNamespace(node->className->identifier, m_editor);
         DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, id);
         usingDeclaration(node->className->identifier->namespaceNameSequence->back()->element, dec);
         buildNamespaceUses(node->className->identifier, id);
         m_result.setDeclaration(dec);
     }
 }
 
 void ExpressionVisitor::visitVarExpressionArray(VarExpressionArrayAst *node)
 {
     DefaultVisitor::visitVarExpressionArray(node);
     m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeArray)));
 }
 
 void ExpressionVisitor::visitClosure(ClosureAst* node)
 {
     FunctionType* closureType = new FunctionType;
     m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
     if (node->functionBody) {
         visitInnerStatementList(node->functionBody);
     }
     closureType->setReturnType(m_result.type());
 
     if (node->parameters->parametersSequence) {
         const KDevPG::ListNode< ParameterAst* >* it = node->parameters->parametersSequence->front();
         forever {
-            AbstractType::Ptr type;
-            if (it->element->parameterType) {
-                //don't use openTypeFromName as it uses cursor for findDeclarations
-                DeclarationPointer decl = findDeclarationImport(ClassDeclarationType,
-                                            identifierForNamespace(it->element->parameterType, m_editor));
-                if (decl) {
-                    type = decl->abstractType();
-                }
-            } else if (it->element->arrayType != -1) {
-                type = AbstractType::Ptr(new IntegralType(IntegralType::TypeArray));
-            } else if (it->element->callableType != -1) {
-                type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
-            } else if (it->element->defaultValue) {
-                ExpressionVisitor v(m_editor);
-                it->element->defaultValue->ducontext = m_currentContext;
-                v.visitNode(it->element->defaultValue);
-                type = v.result().type();
-            }
-            if (!type) {
-                type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
-            }
-
-            if ( it->element->isRef != -1 ) {
-                ReferenceType::Ptr p( new ReferenceType() );
-                p->setBaseType( type );
-
-                type = p.cast<AbstractType>();
-            }
+            AbstractType::Ptr type = parameterType(it->element, {}, m_editor, m_currentContext);
             closureType->addArgument(type);
             if ( it->hasNext() ) {
                 it = it->next;
             } else {
                 break;
             }
         }
     }
 
     if (node->lexicalVars && node->lexicalVars->lexicalVarsSequence) {
         const KDevPG::ListNode< LexicalVarAst* >* it = node->lexicalVars->lexicalVarsSequence->front();
         DUChainWriteLocker lock;
         forever {
             DeclarationPointer found;
             foreach(Declaration* dec, m_currentContext->findDeclarations(identifierForNode(it->element->variable))) {
                 if (dec->kind() == Declaration::Instance) {
                     found = dec;
                     break;
                 }
             }
             usingDeclaration(it->element->variable, found);
             if ( it->hasNext() ) {
                 it = it->next;
             } else {
                 break;
             }
         }
     }
 
     m_result.setType(AbstractType::Ptr(closureType));
 }
 
 void ExpressionVisitor::visitFunctionCallParameterList( FunctionCallParameterListAst* node )
 {
     QList<DeclarationPointer> decs = m_result.allDeclarations();
     AbstractType::Ptr type = m_result.type();
 
     DefaultVisitor::visitFunctionCallParameterList( node );
 
     m_result.setDeclarations(decs);
     m_result.setType(type);
 }
 
 void ExpressionVisitor::visitFunctionCallParameterListElement(FunctionCallParameterListElementAst* node)
 {
     DefaultVisitor::visitFunctionCallParameterListElement(node);
 
     if (m_inDefine) m_inDefine = false; //reset after first parameter passed, the second argument can be a class name
 }
 
 void ExpressionVisitor::visitFunctionCall(FunctionCallAst* node)
 {
     if (node->stringFunctionNameOrClass && !node->stringFunctionName && !node->varFunctionName) {
         QualifiedIdentifier id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
         if (id.toString(RemoveExplicitlyGlobalPrefix) == QLatin1String("define")
                 && node->stringParameterList && node->stringParameterList->parametersSequence
                 && node->stringParameterList->parametersSequence->count() > 0) {
             //in a define() call the first argument is the constant name. we don't want to look for a class name to build uses
             m_inDefine = true;
         }
     }
 
     DefaultVisitor::visitFunctionCall(node);
 
     m_inDefine = false;
 
     if (node->stringFunctionNameOrClass) {
         if (node->stringFunctionName) {
             //static function call foo::bar()
             DUContext* context = findClassContext(node->stringFunctionNameOrClass);
             if (context) {
                 DUChainReadLocker lock(DUChain::lock());
                 QualifiedIdentifier methodName(stringForNode(node->stringFunctionName).toLower());
                 m_result.setDeclarations(context->findDeclarations(methodName));
                 lock.unlock();
                 if (!m_result.allDeclarations().isEmpty()) {
                     usingDeclaration(node->stringFunctionName, m_result.allDeclarations().last());
                     FunctionType::Ptr function = m_result.allDeclarations().last()->type<FunctionType>();
                     if (function) {
                         m_result.setType(function->returnType());
                     } else {
                         m_result.setType(AbstractType::Ptr());
                     }
                 }
             } else {
                 m_result.setHadUnresolvedIdentifiers(true);
                 usingDeclaration(node->stringFunctionName, DeclarationPointer());
                 m_result.setType(AbstractType::Ptr());
             }
         } else if (node->varFunctionName) {
             //static function call foo::$bar()
         } else if (node->expr) {
             //static function call foo::{expr}()
             const QualifiedIdentifier id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
             DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, id);
             usingDeclaration(node->stringFunctionNameOrClass->namespaceNameSequence->back()->element, dec);
             buildNamespaceUses(node->stringFunctionNameOrClass, id);
             m_result.setDeclaration(dec);
         } else {
             //global function call foo();
             const QualifiedIdentifier id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
             DeclarationPointer dec = findDeclarationImport(FunctionDeclarationType, id);
             ifDebug(qCDebug(DUCHAIN) << "function call of" << (dec ? dec->toString() : QString("function not found"));)
             m_result.setDeclaration(dec);
             usingDeclaration(node->stringFunctionNameOrClass->namespaceNameSequence->back()->element, dec);
             buildNamespaceUses(node->stringFunctionNameOrClass, id);
             if (dec) {
                 FunctionType::Ptr function = dec->type<FunctionType>();
                 if (function) {
                     m_result.setType(function->returnType());
                 } else {
                     m_result.setType(AbstractType::Ptr());
                 }
             } else {
                 m_result.setHadUnresolvedIdentifiers(true);
             }
         }
     }
 }
 ///TODO: DUContext pointer?
 DUContext* ExpressionVisitor::findClassContext(IdentifierAst* className)
 {
     DUContext* context = nullptr;
     DeclarationPointer declaration = findDeclarationImport(ClassDeclarationType, className);
     usingDeclaration(className, declaration);
     if (declaration) {
         DUChainReadLocker lock(DUChain::lock());
         context = declaration->internalContext();
         if (!context && m_currentContext->parentContext() && m_currentContext->parentContext()->localScopeIdentifier() == declaration->qualifiedIdentifier()) {
             //className is currentClass (internalContext is not yet set)
             context = m_currentContext->parentContext();
         }
     }
     return context;
 }
 ///TODO: DUContext pointer?
 DUContext* ExpressionVisitor::findClassContext(NamespacedIdentifierAst* className)
 {
     DUContext* context = nullptr;
     const QualifiedIdentifier id = identifierForNamespace(className, m_editor);
     DeclarationPointer declaration = findDeclarationImport(ClassDeclarationType, id);
     usingDeclaration(className->namespaceNameSequence->back()->element, declaration);
     buildNamespaceUses(className, id);
     if (declaration) {
         DUChainReadLocker lock(DUChain::lock());
         context = declaration->internalContext();
         if (!context && m_currentContext->parentContext() && m_currentContext->parentContext()->localScopeIdentifier() == declaration->qualifiedIdentifier()) {
             //className is currentClass (internalContext is not yet set)
             context = m_currentContext->parentContext();
         }
     }
     return context;
 }
 
 void ExpressionVisitor::visitConstantOrClassConst(ConstantOrClassConstAst *node)
 {
     DefaultVisitor::visitConstantOrClassConst(node);
 
     if (node->classConstant) {
         //class constant Foo::BAR
         DUContext* context = findClassContext(node->constant);
         if (context) {
             DUChainReadLocker lock(DUChain::lock());
             m_result.setDeclarations(context->findDeclarations(Identifier(m_editor->parseSession()->symbol(node->classConstant))));
             lock.unlock();
             if (!m_result.allDeclarations().isEmpty()) {
                 usingDeclaration(node->classConstant, m_result.allDeclarations().last());
             } else {
                 usingDeclaration(node->classConstant, DeclarationPointer());
             }
             if (!stringForNode(node->classConstant).compare(QLatin1String("class"), Qt::CaseInsensitive)) {
                 m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeString)));
             }
         } else {
             m_result.setType(AbstractType::Ptr());
         }
     } else {
         QString str(stringForNode(node->constant).toLower());
         if (str == QLatin1String("true") || str == QLatin1String("false")) {
             m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean)));
         } else if (str == QLatin1String("null")) {
             m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeNull)));
         } else {
             //constant (created with declare('foo', 'bar')) or const Foo = 1;
             QualifiedIdentifier id = identifierForNamespace(node->constant, m_editor, true);
             DeclarationPointer declaration = findDeclarationImport(ConstantDeclarationType, id);
             if (!declaration) {
                 ///TODO: is this really wanted?
                 //it could also be a global function call, without ()
                 declaration = findDeclarationImport(FunctionDeclarationType, id);
             }
             m_result.setDeclaration(declaration);
             usingDeclaration(node->constant->namespaceNameSequence->back()->element, declaration);
             buildNamespaceUses(node->constant, id);
         }
     }
 }
 
 void ExpressionVisitor::visitScalar(ScalarAst *node)
 {
     DefaultVisitor::visitScalar(node);
 
     if (node->commonScalar) {
         uint type = IntegralType::TypeVoid;
         switch (node->commonScalar->scalarType) {
         case ScalarTypeInt:
             type = IntegralType::TypeInt;
             break;
         case ScalarTypeFloat:
             type = IntegralType::TypeFloat;
             break;
         case ScalarTypeString:
             type = IntegralType::TypeString;
             break;
         }
         m_result.setType(AbstractType::Ptr(new IntegralType(type)));
     } else if (node->varname != -1) {
         //STRING_VARNAME-Token, probably the type of varname should be used
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeString)));
     } else if (node->encapsList) {
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeString)));
     }
 
     if (!m_inDefine && node->commonScalar && node->commonScalar->scalarType == ScalarTypeString) {
         QString str = m_editor->parseSession()->symbol(node->commonScalar);
         QRegExp exp("^['\"]([A-Za-z0-9_]+)['\"]$");
         if (exp.exactMatch(str)) {
             //that *could* be a class name
             QualifiedIdentifier id(exp.cap(1).toLower());
             DeclarationPointer declaration = findDeclarationImport(ClassDeclarationType, id);
             if (declaration) {
                 usingDeclaration(node->commonScalar, declaration);
             } else {
                 m_result.setHadUnresolvedIdentifiers(true);
             }
         }
     }
 }
 
 
 void ExpressionVisitor::visitStaticScalar(StaticScalarAst *node)
 {
     if (node->ducontext) {
         m_currentContext = node->ducontext;
     }
     Q_ASSERT(m_currentContext);
 
     DefaultVisitor::visitStaticScalar(node);
 
     uint type = IntegralType::TypeVoid;
     if (node->value) {
         switch (node->value->scalarType) {
         case ScalarTypeInt:
             type = IntegralType::TypeInt;
             break;
         case ScalarTypeFloat:
             type = IntegralType::TypeFloat;
             break;
         case ScalarTypeString:
             type = IntegralType::TypeString;
             break;
         }
     } else if (node->plusValue || node->minusValue) {
         type = IntegralType::TypeInt;
     } else if (node->array != -1) {
         type = IntegralType::TypeArray;
     }
     if (type != IntegralType::TypeVoid) {
         m_result.setType(AbstractType::Ptr(new IntegralType(type)));
     }
 }
 
 void ExpressionVisitor::visitEncapsVar(EncapsVarAst *node)
 {
     DefaultVisitor::visitEncapsVar(node);
     if (node->variable) {
         // handle $foo
         DeclarationPointer dec = processVariable(node->variable);
         if (dec && node->propertyIdentifier) {
             // handle property in $foo->bar
             DeclarationPointer foundDec;
             DUChainReadLocker lock(DUChain::lock());
             if ( StructureType::Ptr structType = dec->type<StructureType>() ) {
                 if ( ClassDeclaration* cdec = dynamic_cast<ClassDeclaration*>(structType->declaration(m_currentContext->topContext())) ) {
                     ///TODO: share code with visitVariableProperty
                     DUContext* ctx = cdec->internalContext();
                     if (!ctx && m_currentContext->parentContext()) {
                         if (m_currentContext->parentContext()->localScopeIdentifier() == cdec->qualifiedIdentifier()) {
                             //class is currentClass (internalContext is not yet set)
                             ctx = m_currentContext->parentContext();
                         }
                     }
                     if (ctx) {
                         foreach( Declaration* pdec, ctx->findDeclarations(identifierForNode(node->propertyIdentifier)) ) {
                             if ( !pdec->isFunctionDeclaration() ) {
                                 foundDec = pdec;
                                 break;
                             }
                         }
                     }
                 }
             }
             lock.unlock();
             usingDeclaration(node->propertyIdentifier, foundDec);
         }
     }
 }
 
 void ExpressionVisitor::visitVariableProperty(VariablePropertyAst *node)
 {
     ifDebug(qCDebug(DUCHAIN) << "node:" << m_editor->parseSession()->symbol(node)
         << (node->isFunctionCall != -1 ? QString("is function call") : QString("is no function call"));)
     if (node->objectProperty && node->objectProperty->objectDimList) {
         //handle $foo->bar() and $foo->baz, $foo is m_result.type()
 
         if (m_result.type() && StructureType::Ptr::dynamicCast(m_result.type())) {
             DUChainReadLocker lock(DUChain::lock());
             Declaration* declaration = StructureType::Ptr::staticCast(m_result.type())->declaration(m_currentContext->topContext());
             if (declaration) {
                 ifDebug(qCDebug(DUCHAIN) << "parent:" << declaration->toString();)
                 DUContext* context = declaration->internalContext();
                 if (!context && m_currentContext->parentContext()) {
                     if (m_currentContext->parentContext()->localScopeIdentifier() == declaration->qualifiedIdentifier()) {
                         //class is currentClass (internalContext is not yet set)
                         context = m_currentContext->parentContext();
                     }
                 }
                 if (context) {
                     QualifiedIdentifier propertyId;
                     if ( node->isFunctionCall != -1 ) {
                         propertyId = QualifiedIdentifier(stringForNode(node->objectProperty->objectDimList->variableName->name).toLower());
                     } else {
                         propertyId = identifierForNode(node->objectProperty->objectDimList->variableName->name);
                     }
                     ifDebug(qCDebug(DUCHAIN) << "property id:" << propertyId.toString();)
 
                     QList<Declaration*> decs;
                     foreach ( Declaration* dec, context->findDeclarations(propertyId) ) {
                         if ( node->isFunctionCall != -1 ) {
                             if ( dec->isFunctionDeclaration() ) {
                                 decs << dec;
                                 ifDebug(qCDebug(DUCHAIN) << "found:" << dec->toString();)
                             }
                         } else {
                             if ( !dec->isFunctionDeclaration() ) {
                                 decs << dec;
                                 ifDebug(qCDebug(DUCHAIN) << "found:" << dec->toString();)
                             }
                         }
                     }
                     m_result.setDeclarations(decs);
                     lock.unlock();
                     if (!m_result.allDeclarations().isEmpty()) {
                         if ( !m_isAssignmentExpressionEqual ) {
                             usingDeclaration(node->objectProperty->objectDimList->variableName, m_result.allDeclarations().last());
                         }
                         if (node->isFunctionCall != -1) {
                             FunctionType::Ptr function = m_result.allDeclarations().last()->type<FunctionType>();
                             if (function) {
                                 m_result.setType(function->returnType());
                             } else {
                                 m_result.setType(AbstractType::Ptr());
                             }
                         }
                     } else {
                         if ( !m_isAssignmentExpressionEqual ) {
                             usingDeclaration(node->objectProperty->objectDimList->variableName,
                                              DeclarationPointer());
                         }
                         m_result.setType(AbstractType::Ptr());
                     }
                 } else {
                     m_result.setType(AbstractType::Ptr());
                 }
             } else {
                 m_result.setType(AbstractType::Ptr());
             }
         }
     }
     DefaultVisitor::visitVariableProperty(node);
 }
 
 void ExpressionVisitor::visitStaticMember(StaticMemberAst* node)
 {
     //don't call DefaultVisitor::visitStaticMember(node);
     //because we would end up in visitCompoundVariableWithSimpleIndirectReference
     if (node->variable->variable->variable) {
         DUContext* context = findClassContext(node->className);
         if (context) {
             DUChainReadLocker lock(DUChain::lock());
             m_result.setDeclarations(context->findDeclarations(identifierForNode(node->variable->variable->variable)));
             lock.unlock();
             if (!m_result.allDeclarations().isEmpty()) {
                 usingDeclaration(node->variable->variable->variable, m_result.allDeclarations().last());
             } else {
                 usingDeclaration(node->variable->variable->variable, DeclarationPointer());
             }
         } else {
             usingDeclaration(node->className, DeclarationPointer());
             m_result.setType(AbstractType::Ptr());
         }
         if (node->variable->offsetItemsSequence) {
             const KDevPG::ListNode< DimListItemAst* >* it = node->variable->offsetItemsSequence->front();
             do {
                 visitDimListItem(it->element);
             } while(it->hasNext() && (it = it->next));
         }
     }
 }
 
 void ExpressionVisitor::visitUnaryExpression(UnaryExpressionAst* node)
 {
     DefaultVisitor::visitUnaryExpression(node);
     if (node->castType) {
         uint type = 0;
         switch (node->castType) {
         case CastInt:
             type = IntegralType::TypeInt;
             break;
         case CastDouble:
             type = IntegralType::TypeFloat;
             break;
         case CastString:
             type = IntegralType::TypeString;
             break;
         case CastArray:
             type = IntegralType::TypeArray;
             break;
         case CastObject: {
             /// Qualified identifier for 'stdclass'
             static const QualifiedIdentifier stdclassQId(QStringLiteral("stdclass"));
             DUChainReadLocker lock(DUChain::lock());
             m_result.setDeclarations(m_currentContext->findDeclarations(stdclassQId));
             break;
         }
         case CastBool:
             type = IntegralType::TypeBoolean;
             break;
         case CastUnset:
             //TODO
             break;
         }
         if (type) {
             m_result.setType(AbstractType::Ptr(new IntegralType(type)));
         }
     }
 }
 
 void ExpressionVisitor::visitAdditiveExpressionRest(AdditiveExpressionRestAst* node)
 {
     DefaultVisitor::visitAdditiveExpressionRest(node);
     if (node->operation == OperationPlus || node->operation == OperationMinus) {
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeInt)));
     } else if (node->operation == OperationConcat) {
         m_result.setType(AbstractType::Ptr(new IntegralType(IntegralType::TypeString)));
     }
 }
 
 void ExpressionVisitor::visitRelationalExpression(RelationalExpressionAst *node)
 {
     DefaultVisitor::visitRelationalExpression(node);
     if (node->instanceofType && node->instanceofType->identifier) {
         const QualifiedIdentifier id = identifierForNamespace(node->instanceofType->identifier, m_editor);
         DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, id);
         usingDeclaration(node->instanceofType->identifier->namespaceNameSequence->back()->element, dec);
         buildNamespaceUses(node->instanceofType->identifier, id);
         m_result.setDeclaration(dec);
     }
 }
 
 QString ExpressionVisitor::stringForNode(AstNode* id)
 {
     if (!id)
         return QString();
 
     return m_editor->parseSession()->symbol(id);
 }
 
 QualifiedIdentifier ExpressionVisitor::identifierForNode(IdentifierAst* id)
 {
     if (!id)
         return QualifiedIdentifier();
 
     return QualifiedIdentifier(stringForNode(id));
 }
 
 QString ExpressionVisitor::stringForNode(VariableIdentifierAst* id)
 {
     if (!id)
         return QString();
     QString ret(m_editor->parseSession()->symbol(id->variable));
     ret = ret.mid(1); //cut off $
     return ret;
 }
 
 QualifiedIdentifier ExpressionVisitor::identifierForNode(VariableIdentifierAst* id)
 {
     if (!id)
         return QualifiedIdentifier();
 
     return QualifiedIdentifier(stringForNode(id));
 }
 
 void ExpressionVisitor::setCreateProblems(bool v)
 {
     m_createProblems = v;
 }
 
 void ExpressionVisitor::setOffset(const CursorInRevision& offset)
 {
     m_offset = offset;
 }
 
 void ExpressionVisitor::buildNamespaceUses(NamespacedIdentifierAst* namespaces, const QualifiedIdentifier& identifier)
 {
     QualifiedIdentifier curId;
     curId.setExplicitlyGlobal(identifier.explicitlyGlobal());
     Q_ASSERT(identifier.count() == namespaces->namespaceNameSequence->count());
     for ( int i = 0; i < identifier.count() - 1; ++i ) {
         curId.push(identifier.at(i));
         AstNode* node = namespaces->namespaceNameSequence->at(i)->element;
         DeclarationPointer dec = findDeclarationImport(NamespaceDeclarationType, curId);
         usingDeclaration(node, dec);
     }
 }
 
 DeclarationPointer ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, IdentifierAst* node)
 {
     // methods and class names are case insensitive
     QualifiedIdentifier id;
     if ( declarationType == ClassDeclarationType || declarationType == FunctionDeclarationType ) {
         id = QualifiedIdentifier(stringForNode(node).toLower());
     } else {
         id = identifierForNode(node);
     }
     return findDeclarationImport(declarationType, id);
 }
 
 DeclarationPointer ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, VariableIdentifierAst* node)
 {
     return findDeclarationImport(declarationType, identifierForNode(node));
 }
 
 DeclarationPointer ExpressionVisitor::findDeclarationImport( DeclarationType declarationType,
                                                              const QualifiedIdentifier& identifier)
 {
     return findDeclarationImportHelper(m_currentContext, identifier, declarationType);
 }
 
 Declaration* ExpressionVisitor::findVariableDeclaration(DUContext* context, Identifier identifier,
                                                         CursorInRevision position, DUContext::SearchFlag flag)
 {
     QList<Declaration*> decls = context->findDeclarations(identifier, position,
                                                         nullptr, flag);
     for (int i = decls.count() - 1; i >= 0; i--) {
         Declaration *dec = decls.at(i);
         if (dec->kind() == Declaration::Instance && dynamic_cast<VariableDeclaration*>(dec)) {
             return dec;
         }
     }
 
     return nullptr;
 }
 
 }
diff --git a/duchain/helper.cpp b/duchain/helper.cpp
index e42d092..6dbaef5 100644
--- a/duchain/helper.cpp
+++ b/duchain/helper.cpp
@@ -1,421 +1,506 @@
 /***************************************************************************
  *   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 "helper.h"
 
 #include <KParts/MainWindow>
 #include <KLocalizedString>
 
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/stringhelpers.h>
 #include <language/duchain/parsingenvironment.h>
+#include <language/duchain/types/unsuretype.h>
+#include <language/duchain/types/integraltype.h>
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/iproject.h>
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include "editorintegrator.h"
 #include "../parser/parsesession.h"
 #include "phpast.h"
 #include "phpdefaultvisitor.h"
 #include "declarations/classdeclaration.h"
 #include "declarations/classmethoddeclaration.h"
 #include "declarations/functiondeclaration.h"
+#include "types/indexedcontainer.h"
+#include "types/integraltypeextended.h"
+#include "expressionparser.h"
+#include "expressionvisitor.h"
 
 #include "duchaindebug.h"
 
 #define ifDebug(x)
 
 using namespace KDevelop;
 
 namespace Php
 {
 
 bool isMatch(Declaration* declaration, DeclarationType declarationType)
 {
     if (declarationType == ClassDeclarationType
             && dynamic_cast<ClassDeclaration*>(declaration)
        ) {
         return true;
     } else if (declarationType == FunctionDeclarationType
                && dynamic_cast<FunctionDeclaration*>(declaration)
               ) {
         return true;
     } else if (declarationType == ConstantDeclarationType
                && declaration->abstractType() && declaration->abstractType()->modifiers() & AbstractType::ConstModifier
                && (!declaration->context() || declaration->context()->type() != DUContext::Class)
               ) {
         return true;
     } else if (declarationType == GlobalVariableDeclarationType
                && declaration->kind() == Declaration::Instance
                && !(declaration->abstractType() && declaration->abstractType()->modifiers() & AbstractType::ConstModifier)
               ) {
         return true;
     } else if (declarationType == NamespaceDeclarationType
                && (declaration->kind() == Declaration::Namespace || declaration->kind() == Declaration::NamespaceAlias || dynamic_cast<ClassDeclaration*>(declaration)) )
     {
         return true;
     }
     return false;
 }
 
 DeclarationPointer findDeclarationImportHelper(DUContext* currentContext, const QualifiedIdentifier& id,
         DeclarationType declarationType)
 {
     /// Qualified identifier for 'self'
     static const QualifiedIdentifier selfQId(QStringLiteral("self"));
     /// Qualified identifier for 'parent'
     static const QualifiedIdentifier parentQId(QStringLiteral("parent"));
     /// Qualified identifier for 'static'
     static const QualifiedIdentifier staticQId(QStringLiteral("static"));
 
     ifDebug(qCDebug(DUCHAIN) << id.toString() << declarationType;)
     if (declarationType == ClassDeclarationType && id == selfQId) {
         DUChainReadLocker lock(DUChain::lock());
         if (currentContext->type() == DUContext::Class) {
             return DeclarationPointer(currentContext->owner());
         } else if (currentContext->parentContext() && currentContext->parentContext()->type() == DUContext::Class) {
             return DeclarationPointer(currentContext->parentContext()->owner());
         } else {
             return DeclarationPointer();
         }
     } else if (declarationType == ClassDeclarationType && id == staticQId) {
         DUChainReadLocker lock;
         if (currentContext->type() == DUContext::Class) {
             return DeclarationPointer(currentContext->owner());
         } else if (currentContext->parentContext() && currentContext->parentContext()->type() == DUContext::Class) {
             return DeclarationPointer(currentContext->parentContext()->owner());
         } else {
             return DeclarationPointer();
         }
     } else if (declarationType == ClassDeclarationType && id == parentQId) {
         //there can be just one Class-Context imported
         DUChainReadLocker lock;
         DUContext* classCtx = nullptr;
         if (currentContext->type() == DUContext::Class) {
             classCtx = currentContext;
         } else if (currentContext->parentContext() && currentContext->parentContext()->type() == DUContext::Class) {
             classCtx = currentContext->parentContext();
         }
         if (classCtx) {
             foreach(const DUContext::Import &i, classCtx->importedParentContexts()) {
                 DUContext* ctx = i.context(classCtx->topContext());
                 if (ctx && ctx->type() == DUContext::Class) {
                     return DeclarationPointer(ctx->owner());
                 }
             }
         }
         return DeclarationPointer();
     } else {
         DUChainReadLocker lock;
         QList<Declaration*> foundDeclarations = currentContext->topContext()->findDeclarations(id);
         if (foundDeclarations.isEmpty()) {
             // If it's not in the top context, try the current context (namespaces...)
             // this fixes the bug: https://bugs.kde.org/show_bug.cgi?id=322274
             foundDeclarations = currentContext->findDeclarations(id);
         }
         if (foundDeclarations.isEmpty()) {
             // If it is neither in the top not the current context it might be defined in a different context
             // Look up with fully qualified identifier
             foundDeclarations = currentContext->topContext()->findDeclarations(identifierWithNamespace(id, currentContext));
         }
 
         foreach(Declaration *declaration, foundDeclarations) {
             if (isMatch(declaration, declarationType)) {
                 return DeclarationPointer(declaration);
             }
         }
         if ( currentContext->url() == internalFunctionFile() ) {
             // when compiling php internal functions, we don't need to ask the persistent symbol table for anything
             return DeclarationPointer();
         }
 
         lock.unlock();
 
         if (declarationType != GlobalVariableDeclarationType) {
             ifDebug(qCDebug(DUCHAIN) << "No declarations found with findDeclarations, trying through PersistentSymbolTable";)
             DeclarationPointer decl;
 
             decl = findDeclarationInPST(currentContext, id, declarationType);
 
             if (!decl)
             {
                 decl = findDeclarationInPST(currentContext, identifierWithNamespace(id, currentContext), declarationType);
             }
 
             if (decl) {
                 ifDebug(qCDebug(DUCHAIN) << "PST declaration exists";)
             } else {
                 ifDebug(qCDebug(DUCHAIN) << "PST declaration does not exist";)
             }
             return decl;
         }
     }
 
     ifDebug(qCDebug(DUCHAIN) << "returning 0";)
     return DeclarationPointer();
 }
 
 DeclarationPointer findDeclarationInPST(DUContext* currentContext, QualifiedIdentifier id, DeclarationType declarationType)
 {
     ifDebug(qCDebug(DUCHAIN) << "PST: " << id.toString() << declarationType;)
     uint nr;
     const IndexedDeclaration* declarations = nullptr;
     DUChainWriteLocker wlock;
     PersistentSymbolTable::self().declarations(id, nr, declarations);
     ifDebug(qCDebug(DUCHAIN) << "found declarations:" << nr;)
     /// Indexed string for 'Php', identifies environment files from this language plugin
     static const IndexedString phpLangString("Php");
 
     for (uint i = 0; i < nr; ++i) {
         ParsingEnvironmentFilePointer env = DUChain::self()->environmentFileForDocument(declarations[i].indexedTopContext());
         if(!env) {
             ifDebug(qCDebug(DUCHAIN) << "skipping declaration, missing meta-data";)
             continue;
         }
         if(env->language() != phpLangString) {
             ifDebug(qCDebug(DUCHAIN) << "skipping declaration, invalid language" << env->language().str();)
             continue;
         }
 
         if (!declarations[i].declaration()) {
             ifDebug(qCDebug(DUCHAIN) << "skipping declaration, doesn't have declaration";)
             continue;
         } else if (!isMatch(declarations[i].declaration(), declarationType)) {
             ifDebug(qCDebug(DUCHAIN) << "skipping declaration, doesn't match with declarationType";)
             continue;
         }
         TopDUContext* top = declarations[i].declaration()->context()->topContext();
 
         /*
             * NOTE:
             * To enable PHPUnit test classes, this check has been disabled.
             * Formerly it only loaded declarations from open projects, but PHPUnit declarations
             * belong to no project.
             *
             * If this behavior is unwanted, reinstate the check.
             * Miha Cancula <miha@noughmad.eu>
             */
         /*
         if (ICore::self() && !ICore::self()->projectController()->projects().isEmpty()) {
             bool loadedProjectContainsUrl = false;
             foreach(IProject *project, ICore::self()->projectController()->projects()) {
                 if (project->fileSet().contains(top->url())) {
                     loadedProjectContainsUrl = true;
                     break;
                 }
             }
             if (!loadedProjectContainsUrl) {
                 ifDebug(qCDebug(DUCHAIN) << "skipping declaration, not in loaded project";)
                 continue;
             }
         }
         */
 
         currentContext->topContext()->addImportedParentContext(top);
         currentContext->topContext()->parsingEnvironmentFile()
         ->addModificationRevisions(top->parsingEnvironmentFile()->allModificationRevisions());
         currentContext->topContext()->updateImportsCache();
         ifDebug(qCDebug(DUCHAIN) << "using" << declarations[i].declaration()->toString() << top->url();)
         wlock.unlock();
         return DeclarationPointer(declarations[i].declaration());
     }
 
     wlock.unlock();
     ifDebug(qCDebug(DUCHAIN) << "returning 0";)
     return DeclarationPointer();
 }
 
 QByteArray formatComment(AstNode* node, EditorIntegrator* editor)
 {
     return KDevelop::formatComment(editor->parseSession()->docComment(node->startToken).toUtf8());
 }
 
 //Helper visitor to extract a commonScalar node
 //used to get the value of an function call argument
 class ScalarExpressionVisitor : public DefaultVisitor
 {
 public:
     ScalarExpressionVisitor() : m_node(nullptr) {}
     CommonScalarAst* node() const {
         return m_node;
     }
 private:
     void visitCommonScalar(CommonScalarAst* node) override {
         m_node = node;
     }
     CommonScalarAst* m_node;
 };
 
 CommonScalarAst* findCommonScalar(AstNode* node)
 {
     ScalarExpressionVisitor visitor;
     visitor.visitNode(node);
     return visitor.node();
 }
 
 static bool includeExists(const Path &include)
 {
     const QString path = include.pathOrUrl();
     {
         DUChainReadLocker lock;
         if (DUChain::self()->chainForDocument(IndexedString(path))) {
             return true;
         }
     }
     if ( include.isLocalFile() ) {
         return QFile::exists(path);
     } else {
         return false;
     }
 }
 
 static IndexedString findIncludeFile(const QString &includePath, const IndexedString &currentDocument)
 {
     if ( includePath.isEmpty() ) {
         return IndexedString();
     }
 
     // check remote files
     if ( includePath.startsWith(QLatin1String("http://"), Qt::CaseInsensitive)
             || includePath.startsWith(QLatin1String("ftp://"), Qt::CaseInsensitive) ) {
         // always expect remote includes to exist
         return IndexedString(includePath);
     }
 
     const Path currentPath(currentDocument.str());
 
     // look for file relative to current url
     Path include = Path(currentPath.parent(), includePath);
     if ( includeExists(include) ) {
         return IndexedString(include.pathOrUrl());
     }
 
     // in the first round look for a project that is a parent of the current document
     // in the next round look for any project
     for (int i = 0; i < 2; ++i) {
         foreach(IProject* project, ICore::self()->projectController()->projects()) {
             if ( !i && !project->path().isParentOf(currentPath)) {
                 continue;
             }
             include = Path(project->path(), includePath);
             if ( includeExists(include) ) {
                 return IndexedString(include.pathOrUrl());
             }
         }
     }
 
     //TODO configurable include paths
 
     return IndexedString();
 }
 
 IndexedString getIncludeFileForNode(UnaryExpressionAst* node, EditorIntegrator* editor) {
     if ( node->includeExpression ) {
         //find name of the constant (first argument of the function call)
         CommonScalarAst* scalar = findCommonScalar(node->includeExpression);
         if (scalar && scalar->string != -1) {
             QString str = editor->parseSession()->symbol(scalar->string);
             str = str.mid(1, str.length() - 2);
             if ( str == QLatin1String(".") || str == QLatin1String("..") || str.endsWith('/') ) {
                 return IndexedString();
             }
             return findIncludeFile(str, editor->parseSession()->currentDocument());
         }
     }
 
     return IndexedString();
 }
 
 QString prettyName(Declaration* dec) {
     if (!dec) {
         return {};
     } else if ( dec->context() && dec->context()->type() == DUContext::Class && dec->isFunctionDeclaration() ) {
         ClassMethodDeclaration* classMember = dynamic_cast<ClassMethodDeclaration*>(dec);
         Q_ASSERT(classMember);
         return classMember->prettyName().str();
     } else if ( dec->isFunctionDeclaration() ) {
         FunctionDeclaration* func = dynamic_cast<FunctionDeclaration*>(dec);
         Q_ASSERT(func);
         return func->prettyName().str();
     } else if ( dec->internalContext() && dec->internalContext()->type() == DUContext::Class ) {
         ClassDeclaration* classDec = dynamic_cast<ClassDeclaration*>(dec);
         Q_ASSERT(classDec);
         return classDec->prettyName().str();
     } else {
         return dec->identifier().toString();
     }
 }
 
 const KDevelop::IndexedString& internalFunctionFile()
 {
     static const KDevelop::IndexedString internalFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevphpsupport/phpfunctions.php")));
     return internalFile;
 }
 
 const KDevelop::IndexedString& phpLanguageString()
 {
     static const KDevelop::IndexedString phpLangString("Php");
     return phpLangString;
 }
 
 const IndexedString& internalTestFile()
 {
     static const KDevelop::IndexedString phpUnitFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevphpsupport/phpunitdeclarations.php")));
     return phpUnitFile;
 }
 
 QualifiedIdentifier identifierForNamespace(NamespacedIdentifierAst* node, EditorIntegrator* editor, bool lastIsConstIdentifier)
 {
     QualifiedIdentifier id;
     if (node->isGlobal != -1) {
         id.setExplicitlyGlobal(true);
     }
     const KDevPG::ListNode< IdentifierAst* >* it = node->namespaceNameSequence->front();
     do {
         if (lastIsConstIdentifier && !it->hasNext()) {
             id.push(Identifier(editor->parseSession()->symbol(it->element)));
         } else {
             id.push(Identifier(editor->parseSession()->symbol(it->element).toLower()));
         }
     } while (it->hasNext() && (it = it->next));
     return id;
 }
 
 QualifiedIdentifier identifierWithNamespace(const QualifiedIdentifier& base, DUContext* context)
 {
     DUChainReadLocker lock;
     auto scope = context;
     while (scope && scope->type() != DUContext::Namespace) {
         scope = scope->parentContext();
     }
 
     if (scope) {
         return scope->scopeIdentifier() + base;
     } else {
         return base;
     }
 }
 
+AbstractType::Ptr parameterTypehint(const ParameterTypeAst* parameterType, EditorIntegrator *editor, DUContext* currentContext)
+{
+    Q_ASSERT(parameterType);
+    AbstractType::Ptr type;
+
+    if (parameterType->objectType) {
+        //don't use openTypeFromName as it uses cursor for findDeclarations
+        DeclarationPointer decl = findDeclarationImportHelper(currentContext,
+                                                    identifierForNamespace(parameterType->objectType, editor), ClassDeclarationType);
+        if (decl) {
+            type = decl->abstractType();
+        }
+    } else if (parameterType->arrayType != -1) {
+        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeArray));
+    } else if (parameterType->boolType != -1) {
+        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean));
+    } else if (parameterType->floatType != -1) {
+        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeFloat));
+    } else if (parameterType->intType != -1) {
+        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeInt));
+    } else if (parameterType->stringType != -1) {
+        type = AbstractType::Ptr(new IntegralType(IntegralType::TypeString));
+    }
+
+    if (type && parameterType->isNullable != -1) {
+        AbstractType::Ptr nullType = AbstractType::Ptr(new IntegralType(IntegralType::TypeNull));
+        if (type.cast<UnsureType>()) {
+            UnsureType::Ptr unsure = type.cast<UnsureType>();
+            unsure->addType(nullType->indexed());
+        } else {
+            UnsureType::Ptr unsure(new UnsureType());
+            unsure->addType(type->indexed());
+            unsure->addType(nullType->indexed());
+
+            type = AbstractType::Ptr(unsure);
+        }
+    }
+
+    return type;
+}
+
+AbstractType::Ptr parameterType(const ParameterAst* node, AbstractType::Ptr phpDocTypehint, EditorIntegrator* editor, DUContext* currentContext)
+{
+    AbstractType::Ptr type;
+    if (node->parameterType) {
+        type = parameterTypehint(node->parameterType, editor, currentContext);
+    } else if (node->defaultValue) {
+        ExpressionVisitor v(editor);
+        node->defaultValue->ducontext = currentContext;
+        v.visitNode(node->defaultValue);
+        type = v.result().type();
+    }
+    if (!type) {
+        if (phpDocTypehint) {
+            type = phpDocTypehint;
+        } else {
+            type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
+        }
+    }
+
+    if ( node->isRef != -1 ) {
+      ReferenceType::Ptr p( new ReferenceType() );
+      p->setBaseType( type );
+
+      type = p.cast<AbstractType>();
+    }
+
+    if (node->isVariadic != -1) {
+        IndexedContainer *container = new IndexedContainer();
+        const IndexedString *containerType = new IndexedString("array");
+        container->addEntry(type);
+        container->setPrettyName(*containerType);
+        type = AbstractType::Ptr(container);
+    }
+
+    Q_ASSERT(type);
+    return type;
+}
+
 }
diff --git a/duchain/helper.h b/duchain/helper.h
index b6bf00e..198d5a5 100644
--- a/duchain/helper.h
+++ b/duchain/helper.h
@@ -1,89 +1,93 @@
 /***************************************************************************
  *   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.         *
  ***************************************************************************/
 #ifndef PHPDUCHAINHELPER_H
 #define PHPDUCHAINHELPER_H
 
 #include "phpduchainexport.h"
 
 #include <language/duchain/identifier.h>
 #include <language/duchain/ducontext.h>
+#include <language/duchain/types/abstracttype.h>
 #include <serialization/indexedstring.h>
 
 namespace KDevelop
 {
 class Declaration;
 class DUContext;
 }
 namespace Php
 {
 struct UnaryExpressionAst;
 struct AstNode;
 struct CommonScalarAst;
 struct NamespacedIdentifierAst;
+struct ParameterAst;
 class EditorIntegrator;
 
 enum DeclarationType {
     ClassDeclarationType,
     FunctionDeclarationType,
     ConstantDeclarationType,
     GlobalVariableDeclarationType,
     NamespaceDeclarationType
 };
 
 KDEVPHPDUCHAIN_EXPORT bool isMatch(KDevelop::Declaration* declaration, DeclarationType declarationType);
 
 KDEVPHPDUCHAIN_EXPORT KDevelop::DeclarationPointer findDeclarationImportHelper(KDevelop::DUContext* currentContext,
                                                                                const KDevelop::QualifiedIdentifier& id,
                                                                                DeclarationType declarationType);
 
 KDEVPHPDUCHAIN_EXPORT KDevelop::DeclarationPointer findDeclarationInPST(KDevelop::DUContext* currentContext,
                                                                         KDevelop::QualifiedIdentifier id,
                                                                         DeclarationType declarationType);
 
 KDEVPHPDUCHAIN_EXPORT QByteArray formatComment(AstNode* node, EditorIntegrator* editor);
 
 KDEVPHPDUCHAIN_EXPORT CommonScalarAst* findCommonScalar(AstNode* node);
 
 KDEVPHPDUCHAIN_EXPORT KDevelop::IndexedString getIncludeFileForNode(UnaryExpressionAst* node, EditorIntegrator* editor);
 
 KDEVPHPDUCHAIN_EXPORT QString prettyName(KDevelop::Declaration* dec);
 
 KDEVPHPDUCHAIN_EXPORT const KDevelop::IndexedString& internalFunctionFile();
 
 KDEVPHPDUCHAIN_EXPORT const KDevelop::IndexedString& internalTestFile();
 
 /// Indexed string for 'Php', identifies environment files from this language plugin
 KDEVPHPDUCHAIN_EXPORT const KDevelop::IndexedString& phpLanguageString();
 
 /**
  * Get proper QualifiedIdentifier for a NamespacedIdentifierAst.
  *
  * Identifier will be all lowercase except for the last identifier if @p lastIsConstIdentifier is set to true.
  */
 KDEVPHPDUCHAIN_EXPORT KDevelop::QualifiedIdentifier identifierForNamespace(NamespacedIdentifierAst* node, EditorIntegrator* editor,
                                                                            bool lastIsConstIdentifier = false);
 
 /**
  * Get proper QualifiedIdentifier for a basic identifier.
  */
 KDEVPHPDUCHAIN_EXPORT KDevelop::QualifiedIdentifier identifierWithNamespace(const KDevelop::QualifiedIdentifier& base, KDevelop::DUContext* context);
 
+KDEVPHPDUCHAIN_EXPORT KDevelop::AbstractType::Ptr parameterType(const ParameterAst* node, KDevelop::AbstractType::Ptr phpDocTypehint, EditorIntegrator* editor, KDevelop::DUContext *currentContext);
+
 }
 #endif
diff --git a/duchain/tests/duchain.cpp b/duchain/tests/duchain.cpp
index abd5bc8..30195f1 100644
--- a/duchain/tests/duchain.cpp
+++ b/duchain/tests/duchain.cpp
@@ -1,3096 +1,3265 @@
 /* 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 "../types/indexedcontainer.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::declareVariadicFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? function foo(...$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);
+    AbstractType::Ptr arg = fun->arguments().first();
+    QVERIFY(arg);
+    QVERIFY(arg.cast<IndexedContainer>());
+    QCOMPARE(arg.cast<IndexedContainer>()->typesCount(), 1);
+    QCOMPARE(arg.cast<IndexedContainer>()->prettyName().str(), QStringLiteral("array"));
+
+    AbstractType::Ptr typehint = arg.cast<IndexedContainer>()->typeAt(0).abstractType();
+    QVERIFY(typehint);
+    QVERIFY(IntegralType::Ptr::dynamicCast(typehint));
+    QVERIFY(IntegralType::Ptr::dynamicCast(typehint)->dataType() == IntegralType::TypeMixed);
 }
 
 void TestDUChain::declareTypehintVariadicFunction()
 {
     //                 0         1         2         3         4         5         6         7
     //                 01234567890123456789012345678901234567890123456789012345678901234567890123456789
     QByteArray method("<? class A {} function foo(A ...$i) { } ");
 
     TopDUContext* top = parse(method, DumpAll);
     DUChainReleaser releaseTop(top);
 
     DUChainWriteLocker lock(DUChain::lock());
 
     FunctionType::Ptr fun = top->localDeclarations().at(1)->type<FunctionType>();
     QVERIFY(fun);
     QCOMPARE(fun->arguments().count(), 1);
 
     AbstractType::Ptr arg = fun->arguments().first();
     QVERIFY(arg);
     QVERIFY(arg.cast<IndexedContainer>());
     QCOMPARE(arg.cast<IndexedContainer>()->typesCount(), 1);
     QCOMPARE(arg.cast<IndexedContainer>()->prettyName().str(), QStringLiteral("array"));
 
     AbstractType::Ptr typehint = arg.cast<IndexedContainer>()->typeAt(0).abstractType();
     QVERIFY(typehint);
     QCOMPARE(typehint->toString(), QStringLiteral("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::declareTypehintBoolFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    QByteArray method("<? function foo(bool $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::TypeBoolean);
+
+    IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
+    QVERIFY(type);
+    QVERIFY(type->dataType() == IntegralType::TypeBoolean);
+}
+
+void TestDUChain::declareTypehintFloatFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    QByteArray method("<? function foo(float $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::TypeFloat);
+
+    IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
+    QVERIFY(type);
+    QVERIFY(type->dataType() == IntegralType::TypeFloat);
+}
+
+void TestDUChain::declareTypehintIntFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    QByteArray method("<? function foo(int $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::TypeInt);
+
+    IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
+    QVERIFY(type);
+    QVERIFY(type->dataType() == IntegralType::TypeInt);
+}
+
+void TestDUChain::declareTypehintStringFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    QByteArray method("<? function foo(string $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::TypeString);
+
+    IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
+    QVERIFY(type);
+    QVERIFY(type->dataType() == IntegralType::TypeString);
+}
+
+void TestDUChain::declareNullableTypehintArrayFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    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);
+
+    UnsureType::Ptr argType = UnsureType::Ptr::dynamicCast(fun->arguments().first());
+    QVERIFY(argType);
+    QCOMPARE(argType->typesSize(), 2u);
+    QVERIFY(argType->types()[0].abstractType().cast<IntegralType>());
+    QVERIFY(argType->types()[0].abstractType().cast<IntegralType>()->dataType() == IntegralType::TypeArray);
+    QVERIFY(argType->types()[1].abstractType().cast<IntegralType>());
+    QVERIFY(argType->types()[1].abstractType().cast<IntegralType>()->dataType() == IntegralType::TypeNull);
+
+    UnsureType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<UnsureType>();
+    QVERIFY(type);
+    QCOMPARE(type->typesSize(), 2u);
+    QVERIFY(type->types()[0].abstractType().cast<IntegralType>());
+    QVERIFY(type->types()[0].abstractType().cast<IntegralType>()->dataType() == IntegralType::TypeArray);
+    QVERIFY(type->types()[1].abstractType().cast<IntegralType>());
+    QVERIFY(type->types()[1].abstractType().cast<IntegralType>()->dataType() == IntegralType::TypeNull);
+}
+
+void TestDUChain::declareTypehintWithPhpdocFunction()
+{
+    //                 0         1         2         3
+    //                 0123456789012345678901234567890123
+    QByteArray method("<? /**\n * @param string $i\n */ function foo(int $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::TypeInt);
+
+    IntegralType::Ptr type = top->childContexts().first()->localDeclarations().first()->type<IntegralType>();
+    QVERIFY(type);
+    QVERIFY(type->dataType() == IntegralType::TypeInt);
+}
+
+void TestDUChain::declareNullableTypehintCallableFunction()
+{
+    //                 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);
 }
 
 void TestDUChain::functionArgumentUnpacking_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::newRow("unpackVariable") << QStringLiteral("<? $a = [ 1,2 ];\n$b = [ 3,4 ];\nfunction aaa($c,$d,$e,$f) { }\naaa(...$a, ...$b);\n");
 
     QTest::newRow("unpackLiteral") << QStringLiteral("<? function aaa($c,$d,$e,$f) { }\naaa(...[1,2], ...[3,4]);\n");
 
     QTest::newRow("unpackFunction") << QStringLiteral("<? function bbb() { return [1,2,3,4]; }\nfunction aaa($c,$d,$e,$f) { }\naaa(...bbb());\n");
 }
 
 void TestDUChain::functionArgumentUnpacking()
 {
     QFETCH(QString, code);
 
     TopDUContext* top = parse(code.toUtf8(), DumpNone);
     QVERIFY(top);
     DUChainReleaser releaseTop(top);
     DUChainWriteLocker lock(DUChain::lock());
 
     QVERIFY(top->problems().isEmpty());
 }
diff --git a/duchain/tests/duchain.h b/duchain/tests/duchain.h
index 43b9140..9773d09 100644
--- a/duchain/tests/duchain.h
+++ b/duchain/tests/duchain.h
@@ -1,163 +1,170 @@
 /* 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.
 */
 
 #ifndef TESTDUCHAIN_H
 #define TESTDUCHAIN_H
 
 #include "tests/duchaintestbase.h"
 
 namespace Php
 {
 class TestDUChain : public DUChainTestBase
 {
     Q_OBJECT
 
 public:
     TestDUChain();
 
 private slots:
     void declareFunction();
     void declareVar();
     void varTypehint();
     void declareClass();
     void classMemberVar();
     void declareTypehintFunction();
     void declareVariadicFunction();
     void declareTypehintVariadicFunction();
     void declareTypehintArrayFunction();
     void declareTypehintCallableFunction();
+    void declareTypehintBoolFunction();
+    void declareTypehintFloatFunction();
+    void declareTypehintIntFunction();
+    void declareTypehintStringFunction();
+    void declareNullableTypehintArrayFunction();
+    void declareNullableTypehintCallableFunction();
+    void declareTypehintWithPhpdocFunction();
     void returnTypeClass();
     void declarationReturnType();
     void declarationReturnTypeInRecursingFunction();
     void returnTypeViaMember();
     void declarationMultipleReturnTypes();
     void declarationReturnTypeDocBlock();
     void declarationReturnTypeDocBlockIntegral();
     void declarationReturnTypeClassChain();
     void classImplementsInterface();
     void classExtends();
     void staticMethod();
     void ownStaticMethod();
     void thisVar();
     void objectFunctionCall();
     void objectFunctionCall2();
     void objectFunctionCall3();
     void objectVariable();
     void staticMemberVariable();
     void ownStaticMemberVariable();
     void classConst();
     void classConst_data();
     void fileConst();
     void fileConst_data();
     void define();
     void defaultFunctionParam();
     void globalFunction();
     void globalVariableFromInternalFunctions();
     void newObjectFromOtherFile();
     void unknownReturnType();
     void staticFunctionCallFromOtherFile();
     void classConstantFromOtherFile();
     void globalFunctionCallFromOtherFile();
     void constantFromOtherFile();
     void singleton();
     void internalFunctions();
     void trueFalse();
     void null();
     void array();
     void functionDocBlock();
     void variableDocBlock();
     void functionDocBlockParams();
     void memberFunctionDocBlockParams();
     void foreachLoop();
     void php4StyleConstructor();
     void constructor();
     void destructor();
     void functionInFunction();
     void objectWithClassName();
     void largeNumberOfDeclarations();
     void staticVariable();
     void returnTypeTwoDeclarations();
     void globalVariableNotVisibleInFunction();
     void globalVariableInFunction();
     void nonGlobalVariableInFunction();
     void superglobalInFunction();
     void returnWithoutFunction();
     void circularInheritance();
     void findDeclarations();
     void memberTypeAfterMethod();
     void catchDeclaration();
     void resourceType();
     void foreachIterator();
     void foreachIterator2();
     void foreachIterator3();
     void foreachIterator4();
     void returnThis();
     void unsureReturnType();
     void unsureReturnType2();
     void unsureReturnType3();
     void unsureReturnType4();
     void referencedArgument();
     void unsureReferencedArgument();
     void defaultArgument();
     void declareMemberOutOfClass();
     void declareMemberOutOfClass2();
     void declareMemberInClassMethod();
     void thisRedeclaration();
     void implicitArrayDeclaration();
     void implicitReferenceDeclaration();
     void classContextRange();
     void lateClassMembers();
     void list();
     void alternateDocCommentTypeHints();
     void findFunctionArgs();
     void undeclaredPropertyInString();
     void undeclaredVarPropertyInString();
     void upcommingClassInString();
     void namespaces();
     void namespacesNoCurly();
     void useNamespace();
     void namespaceStaticVar();
     void namespacedCatch();
     void errorRecovery_data();
     void errorRecovery();
     void varStatic();
     void staticNowdoc();
     void curlyVarAfterObj();
     void embeddedHTML_data();
     void embeddedHTML();
     void cases();
     void closureParser();
     void closures();
     void closureEmptyUse();
     void iifeParser();
     void iife();
     void gotoTest();
     void ternary();
     void bug296709();
     void declareFinalMethod();
     void testTodoExtractor();
     void useThisAsArray();
     void wrongUseOfThisAsArray();
     void staticFunctionClassPhp54();
     void functionArgumentUnpacking_data();
     void functionArgumentUnpacking();
 };
 
 }
 
 #endif
diff --git a/parser/php.g b/parser/php.g
index b758bcb..71a3db4 100644
--- a/parser/php.g
+++ b/parser/php.g
@@ -1,1207 +1,1220 @@
 -------------------------------------------------------------------------------
 -- 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") ;;
+       GOTO ("goto"), TRAIT ("trait"), INSTEADOF ("insteadof"), CALLABLE ("callable"),
+       ITERABLE ("iterable"), BOOL ("bool"), FLOAT ("float"), INT ("int"), STRING_TYPE ("string") ;;
 
 -- 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 ("**"), ELLIPSIS ("..."),
        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) | (isVariadic=ELLIPSIS | 0) 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)
+(parameterType=parameterType | 0) (isRef=BIT_AND | 0)
     (isVariadic=ELLIPSIS | 0) variable=variableIdentifier (ASSIGN defaultValue=staticScalar | 0)
 -> parameter ;;
 
+    (isNullable=QUESTION | 0) (
+        objectType=namespacedIdentifier
+      | arrayType=ARRAY
+      | callableType=CALLABLE
+      | iterableType=ITERABLE
+      | boolType=BOOL
+      | floatType=FLOAT
+      | intType=INT
+      | stringType=STRING_TYPE
+    )
+-> parameterType ;;
+
     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 <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/parser/phplexer.cpp b/parser/phplexer.cpp
index e95c10b..a810963 100644
--- a/parser/phplexer.cpp
+++ b/parser/phplexer.cpp
@@ -1,1038 +1,1048 @@
 /***************************************************************************
  *   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 "phplexer.h"
 
 #include "phpparser.h"
 #include "tokenstream.h"
 
 #include <QtCore/QString>
 #include <QtCore/QStringList>
 #include <QtCore/QRegExp>
 #include <QtCore/QDebug>
 
 #include "parserdebug.h"
 
 namespace Php
 {
 
 Lexer::Lexer(TokenStream* tokenStream, const QString& content, int initialState):
         m_content(content), m_tokenStream(tokenStream),
         m_curpos(0), m_contentSize(m_content.size()),
         m_tokenBegin(0), m_tokenEnd(0), m_haltCompiler(0)
 {
     pushState(ErrorState);
     if (initialState == DefaultState) {
         pushState(HtmlState);
     }
     pushState(initialState);
 }
 
 int Lexer::state(int deepness) const
 {
     return m_state.at(m_state.size() - deepness - 1);
 }
 void Lexer::printState()
 {
     int s = state();
     if (s == ErrorState)
         qDebug() << "ErrorState";
     else if (s == HtmlState)
         qDebug() << "HtmlState";
     else if (s == DefaultState)
         qDebug() << "DefaultState";
     else if (s == String)
         qDebug() << "String";
     else if (s == StringVariable)
         qDebug() << "StringVariable";
     else if (s == StringVariableBracket)
         qDebug() << "StringVariableBracket";
     else if (s == StringVariableObjectOperator)
         qDebug() << "StringVariableObjectOperator";
     else if (s == StringVariableCurly)
         qDebug() << "StringVariableCurly";
     else if (s == StringVarname)
         qDebug() << "StringVarname";
     else if (s == StringHeredoc)
         qDebug() << "StringHeredoc";
     else if (s == StringBacktick)
         qDebug() << "StringBacktick";
 }
 
 void Lexer::pushState(int state)
 {
     m_state.push(state);
 }
 
 void Lexer::popState()
 {
     m_state.pop();
 }
 
 int Lexer::nextTokenKind()
 {
     int token = Parser::Token_INVALID;
     if (m_curpos >= m_contentSize) {
         m_tokenBegin = -1;
         m_tokenEnd = -1;
         createNewline(m_curpos);
         return 0;
     }
 
     const QChar* it = m_content.constData();
     it += m_curpos;
     m_tokenBegin = m_curpos;
     switch (state()) {
     case HtmlState:
         if (it->unicode() == '<' && (it + 1)->unicode() == '?'
             ///TODO: per-project configuration to set whether we use shortags
             ///      or not. In the former case we'd need to rise an error here
             && !( (it + 2)->toLower().unicode() == 'x'
                  && (it + 3)->toLower().unicode() == 'm'
                  && (it + 4)->toLower().unicode() == 'l' ) )
         {
             token = Parser::Token_OPEN_TAG;
             if ((it + 2)->unicode() == '=') {
                 token = Parser::Token_OPEN_TAG_WITH_ECHO;
                 m_curpos++;
                 it++;
             } else if ((it + 2)->toLower().unicode() == 'p'
                     && (it + 3)->toLower().unicode() == 'h'
                     && (it + 4)->toLower().unicode() == 'p'
                     && (it + 5)->isSpace()) {
                 m_curpos += 4;
                 if ((it + 5)->unicode() == '\n') createNewline(m_curpos + 1);
             }
             m_curpos++;
             pushState(DefaultState);
         } else {
             token = Parser::Token_INLINE_HTML;
             while (m_curpos < m_contentSize) {
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 if ((it + 1)->unicode() == '<' && (it + 2)->unicode() == '?') {
                     break;
                 }
                 it++;
                 m_curpos++;
             }
         }
         break;
     case DefaultState:
     case StringVariableCurly: {
         if (it->isSpace()) {
             token = Parser::Token_WHITESPACE;
             while (m_curpos < m_contentSize && it->isSpace()) {
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 it++;
                 m_curpos++;
             }
             m_curpos--;
         } else if (it->isDigit() || (it->unicode() == '.' && (it + 1)->isDigit())) {
             QString num;bool hasPoint = false;
             bool hex = false;
             bool bin = false;
             if (it->unicode() == '0' && (it + 1)->toLower() == 'x') {
                 it += 2;
                 m_curpos += 2;
                 hex = true;
             }
             if (it->unicode() == '0' && (it + 1)->toLower() == 'b') {
                 it += 2;
                 m_curpos += 2;
                 bin = true;
             }
             while (m_curpos < m_contentSize && (
                         it->isDigit()
                         || (!hex && !hasPoint && it->unicode() == '.')
                         || (bin && (it->unicode() == '0' || it->unicode() == '1'))
                         || (hex && (it->toLower() == 'a' || it->toLower() == 'b' ||
                                     it->toLower() == 'c' || it->toLower() == 'd' ||
                                     it->toLower() == 'e' || it->toLower() == 'f')))) {
                 if (it->unicode() == '.') hasPoint = true;
                 num.append(*it);
                 it++;
                 m_curpos++;
             }
             if (!hex && !bin && it->toLower() == 'e' &&
                     ((it + 1)->isDigit() ||
                      (((it + 1)->unicode() == '-' || (it + 1)->unicode() == '+') && (it + 2)->isDigit()))) {
                 //exponential number
                 token = Parser::Token_DNUMBER;
                 m_curpos++;
                 it++;
                 if (it->unicode() == '-' || it->unicode() == '+') {
                     it++;
                     m_curpos++;
                 }
                 while (m_curpos < m_contentSize && (it->isDigit())) {
                     it++;
                     m_curpos++;
                 }
                 m_curpos--;
             } else {
                 m_curpos--;
                 if (hasPoint) {
                     token = Parser::Token_DNUMBER;
                 } else {
                     bool ok;
                     //check if string can be converted to long
                     //if we get an overflow use double
                     num.toLong(&ok, hex ? 16 : 10);
                     if (ok) {
                         token = Parser::Token_LNUMBER;
                     } else {
                         token = Parser::Token_DNUMBER;
                     }
                 }
             }
 
         } else if (processVariable(it)) {
             token = Parser::Token_VARIABLE;
         } else if (it->unicode() == '$') {
             //when it was not recognized as variable
             token = Parser::Token_DOLLAR;
         } else if (it->unicode() == '}') {
             token = Parser::Token_RBRACE;
             if (state() == StringVariableCurly) {
                 popState();
             }
         } else if (it->unicode() == '{') {
             token = Parser::Token_LBRACE;
             if (state() == StringVariableCurly) {
                 pushState(StringVariableCurly);
             }
         } else if (it->unicode() == ')') {
             token = Parser::Token_RPAREN;
         } else if (it->unicode() == '(') {
             it++;
             int pos = m_curpos + 1;
             while (pos < m_contentSize && it->isSpace()) {
                 it++;
                 pos++;
             }
             const int nameStart = pos;
             while (pos < m_contentSize && it->isLetter()) {
                 it++;
                 pos++;
             }
             const auto name = m_content.midRef(nameStart, pos - nameStart);
             while (pos < m_contentSize && it->isSpace()) {
                 it++;
                 pos++;
             }
             if (it->unicode() == ')') {
                 if (name.compare(QLatin1String("int"), Qt::CaseInsensitive) == 0
                     || name.compare(QLatin1String("integer"), Qt::CaseInsensitive) == 0)
                 {
                     token = Parser::Token_INT_CAST;
                 } else if (name.compare(QLatin1String("real"), Qt::CaseInsensitive) == 0
                     || name.compare(QLatin1String("double"), Qt::CaseInsensitive) == 0
                     || name.compare(QLatin1String("float"), Qt::CaseInsensitive) == 0)
                 {
                     token = Parser::Token_DOUBLE_CAST;
                 } else if (name.compare(QLatin1String("string"), Qt::CaseInsensitive) == 0) {
                     token = Parser::Token_STRING_CAST;
                 } else if (name.compare(QLatin1String("binary"), Qt::CaseInsensitive) == 0) {
                     //as in php
                     token = Parser::Token_STRING_CAST;
                 } else if (name.compare(QLatin1String("array"), Qt::CaseInsensitive) == 0) {
                     token = Parser::Token_ARRAY_CAST;
                 } else if (name.compare(QLatin1String("object"), Qt::CaseInsensitive) == 0) {
                     token = Parser::Token_OBJECT_CAST;
                 } else if (name.compare(QLatin1String("bool"), Qt::CaseInsensitive) == 0
                     || name.compare(QLatin1String("boolean"), Qt::CaseInsensitive) == 0)
                 {
                     token = Parser::Token_BOOL_CAST;
                 } else if (name.compare(QLatin1String("unset"), Qt::CaseInsensitive) == 0) {
                     token = Parser::Token_UNSET_CAST;
                 } else {
                     token = Parser::Token_LPAREN;
                 }
 
                 if (token != Parser::Token_LPAREN) {
                     m_curpos = pos;
                 }
             } else {
                 token = Parser::Token_LPAREN;
             }
         } else if (it->unicode() == ']') {
             token = Parser::Token_RBRACKET;
         } else if (it->unicode() == '[') {
             token = Parser::Token_LBRACKET;
         } else if (it->unicode() == ',') {
             token = Parser::Token_COMMA;
         } else if (it->unicode() == '@') {
             token = Parser::Token_AT;
         } else if (it->unicode() == '!') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 if ((it + 2)->unicode() == '=') {
                     m_curpos++;
                     token = Parser::Token_IS_NOT_IDENTICAL;
                 } else {
                     token = Parser::Token_IS_NOT_EQUAL;
                 }
             } else {
                 token = Parser::Token_BANG;
             }
         } else if (it->unicode() == '<') {
             if ((it + 1)->unicode() == '<') {
                 m_curpos++;
                 if ((it + 2)->unicode() == '<' && state() != StringVariableCurly) {
                     //HEREDOC string (<<< EOD\nfoo\nEOD;\n)
                     int pos = 3;
                     while (m_curpos + pos < m_contentSize &&
                             ((it + pos)->unicode() == ' ' || (it + pos)->unicode() == '\t')) {
                         pos++;
                     }
                     bool isNowdoc = (it + pos)->unicode() == '\'';
                     bool foundQuote = isNowdoc || (it + pos)->unicode() == '"';
                     if (foundQuote) {
                         ++pos;
                     }
                     if ((it + pos)->isLetter() || (it + pos)->unicode() == '_') { //identifier must start with a letter
                         m_hereNowDocIdentifier.clear();
                         while (m_curpos + pos < m_contentSize &&
                                 ((it + pos)->isDigit() || (it + pos)->isLetter() || (it + pos)->unicode() == '_')) {
                             m_hereNowDocIdentifier.append(*(it + pos));
                             pos++;
                         }
                         if (foundQuote && (m_curpos + pos) < m_contentSize) {
                             if (isNowdoc && (it+pos)->unicode() == '\'') {
                                 ++pos;
                             } else if ((it+pos)->unicode() == '"') {
                                 ++pos;
                             }
                         }
                         if (m_curpos + pos < m_contentSize && (it + pos)->unicode() == '\n') {
                             //identifier must be followed by newline, newline is part of HEREDOC token
                             if (isNowdoc) {
                                 token = Parser::Token_START_NOWDOC;
                                 pushState(StringNowdoc);
                             } else {
                                 token = Parser::Token_START_HEREDOC;
                                 pushState(StringHeredoc);
                             }
                             m_curpos += pos - 1;
                             createNewline(m_curpos);
                         }
                     }
                 }
 
                 if (token != Parser::Token_START_HEREDOC && token != Parser::Token_START_NOWDOC) {
                     if ((it + 2)->unicode() == '=') {
                         m_curpos++;
                         token = Parser::Token_SL_ASSIGN;
                     } else {
                         token = Parser::Token_SL;
                     }
                 }
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_IS_SMALLER_OR_EQUAL;
             } else if ((it + 1)->unicode() == '>') {
                 m_curpos++;
                 token = Parser::Token_IS_NOT_EQUAL;
             } else {
                 token = Parser::Token_IS_SMALLER;
             }
         } else if (it->unicode() == '>') {
             if ((it + 1)->unicode() == '>') {
                 m_curpos++;
                 if ((it + 2)->unicode() == '=') {
                     m_curpos++;
                     token = Parser::Token_SR_ASSIGN;
                 } else {
                     token = Parser::Token_SR;
                 }
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_IS_GREATER_OR_EQUAL;
             } else {
                 token = Parser::Token_IS_GREATER;
             }
         } else if (it->unicode() == '~') {
             token = Parser::Token_TILDE;
         } else if (it->unicode() == ':') {
             if ((it + 1)->unicode() == ':') {
                 m_curpos++;
                 token = Parser::Token_PAAMAYIM_NEKUDOTAYIM;
             } else {
                 token = Parser::Token_COLON;
             }
         } else if (it->unicode() == '?') {
             if ((it + 1)->unicode() == '>') {
                 //accept CLOSE_TAG inside StringVariableCurly too, as php does
                 token = Parser::Token_CLOSE_TAG;
                 m_curpos++;
                 while (state() != HtmlState) popState();
             } else {
                 token = Parser::Token_QUESTION;
             }
         } else if (it->unicode() == '-' && (it + 1)->unicode() == '>') {
             m_curpos++;
             token = Parser::Token_OBJECT_OPERATOR;
             if (isValidVariableIdentifier(it + 2)) {
                 pushState(StringVariableObjectOperator);
             }
         } else if (it->unicode() == '%') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_MOD_ASSIGN;
             } else {
                 token = Parser::Token_MOD;
             }
         } else if (it->unicode() == '/') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_DIV_ASSIGN;
             } else if ((it + 1)->unicode() == '/') {
                 //accept COMMENT inside StringVariableCurly too, as php does
                 if ((it + 2)->unicode() == '/') {
                     token = Parser::Token_DOC_COMMENT;
                 } else {
                     token = Parser::Token_COMMENT;
                 }
                 while (m_curpos < m_contentSize) {
                     if (m_curpos + 1 < m_contentSize && it->unicode() == '?' && (it + 1)->unicode() == '>') {
                         --it;
                         --m_curpos;
                         break;
                     }
                     if ( it->unicode() == '\n' ) {
                         createNewline(m_curpos);
                         if ( token == Parser::Token_COMMENT ) {
                             break;
                         } else {
                             // lookahead to check whether this doc comment spans multiple lines
                             const QChar* it2 = it + 1;
                             int pos = m_curpos + 1;
                             while ( pos < m_contentSize && (it2)->isSpace() && (it2)->unicode() != '\n' ) {
                                 ++it2;
                                 ++pos;
                             }
                             if ( it2->unicode() == '/' && (it2 + 1)->unicode() == '/'
                                  && (it2 + 2)->unicode() == '/' ) {
                                 // seems to be a multi-line doc-comment
                                 it = it2 + 2;
                                 m_curpos = pos + 2;
                                 continue;
                             } else {
                                 // not a multi-line doc-comment
                                 break;
                             }
                         }
                     }
                     it++;
                     m_curpos++;
                 }
             } else if ((it + 1)->unicode() == '*') {
                 //accept COMMENT inside StringVariableCurly too, as php does
                 if ((it + 2)->unicode() == '*' && (it + 3)->isSpace()) {
                     token = Parser::Token_DOC_COMMENT;
                 } else {
                     token = Parser::Token_COMMENT;
                 }
                 it += 2;
                 m_curpos += 2;
                 while (m_curpos < m_contentSize && !(it->unicode() == '*' && (it + 1)->unicode() == '/')) {
                     if (it->unicode() == '\n') {
                         createNewline(m_curpos);
                     }
                     it++;
                     m_curpos++;
                 }
                 m_curpos++;
             } else {
                 token = Parser::Token_DIV;
             }
         } else if (it->unicode() == '#') {
             //accept COMMENT inside StringVariableCurly too, as php does
             token = Parser::Token_COMMENT;
             while (m_curpos < m_contentSize) {
                 if (m_curpos + 1 < m_contentSize && it->unicode() == '?' && (it + 1)->unicode() == '>') {
                     --it;
                     --m_curpos;
                     break;
                 }
                 if (it->unicode() == '\n') {
                     createNewline(m_curpos);
                     break;
                 }
                 it++;
                 m_curpos++;
             }
         } else if (it->unicode() == '^') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_XOR_ASSIGN;
             } else {
                 token = Parser::Token_BIT_XOR;
             }
         } else if (it->unicode() == '*') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_MUL_ASSIGN;
             } else if ((it + 1)->unicode() == '*') {
                 m_curpos++;
                 if ((it + 2)->unicode() == '=') {
                     m_curpos++;
                     token = Parser::Token_EXP_ASSIGN;
                 } else {
                     token = Parser::Token_EXP;
                 }
             } else {
                 token = Parser::Token_MUL;
             }
         } else if (it->unicode() == '|') {
             if ((it + 1)->unicode() == '|') {
                 m_curpos++;
                 token = Parser::Token_BOOLEAN_OR;
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_OR_ASSIGN;
             } else {
                 token = Parser::Token_BIT_OR;
             }
         } else if (it->unicode() == '&') {
             if ((it + 1)->unicode() == '&') {
                 m_curpos++;
                 token = Parser::Token_BOOLEAN_AND;
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_AND_ASSIGN;
             } else {
                 token = Parser::Token_BIT_AND;
             }
         } else if (it->unicode() == '+') {
             if ((it + 1)->unicode() == '+') {
                 m_curpos++;
                 token = Parser::Token_INC;
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_PLUS_ASSIGN;
             } else {
                 token = Parser::Token_PLUS;
             }
         } else if (it->unicode() == '-') {
             if ((it + 1)->unicode() == '-') {
                 m_curpos++;
                 token = Parser::Token_DEC;
             } else if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_MINUS_ASSIGN;
             } else {
                 token = Parser::Token_MINUS;
             }
         } else if (it->unicode() == '.') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 token = Parser::Token_CONCAT_ASSIGN;
             } else if ((it + 1)->unicode() == '.' && (it + 2)->unicode() == '.') {
                  m_curpos = m_curpos + 2;
                token = Parser::Token_ELLIPSIS;
             } else {
                 token = Parser::Token_CONCAT;
             }
         } else if (it->unicode() == '\\') {
             token = Parser::Token_BACKSLASH;
         } else if (it->unicode() == ';') {
             token = Parser::Token_SEMICOLON;
         } else if (it->unicode() == '\'') {
             token = Parser::Token_CONSTANT_ENCAPSED_STRING;
             it++;
             m_curpos++;
             int startPos = m_curpos;
             while (m_curpos < m_contentSize
                     && (it->unicode() != '\'' || isEscapedWithBackslash(it, m_curpos, startPos))) {
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 it++;
                 m_curpos++;
             }
             // if the string is never terminated, make sure we don't overflow the boundaries
             if ( m_curpos == m_contentSize ) {
                 --m_curpos;
             }
         } else if (it->unicode() == '"') {
             it++;
             m_curpos++;
             int stringSize = 0;
             bool foundVar = false;
             while (m_curpos + stringSize < m_contentSize
                     && (it->unicode() != '"' || isEscapedWithBackslash(it, m_curpos + stringSize, m_curpos)))
             {
                 if (it->unicode() == '$'  && !isEscapedWithBackslash(it, m_curpos + stringSize, m_curpos)
                         && ((it + 1)->unicode() == '{'
                             || (isValidVariableIdentifier(it + 1) && !(it + 1)->isDigit()))) {
                     foundVar = true;
                     break;
                 }
                 it++;
                 stringSize++;
             }
             if (!foundVar) {
                 // if the string is never terminated, make sure we don't overflow the boundaries
                 if ( m_curpos + stringSize == m_contentSize ) {
                     m_curpos--;
                 }
                 token = Parser::Token_CONSTANT_ENCAPSED_STRING;
                 it -= stringSize;
                 for (int j = 0; j < stringSize; j++) {
                     if (it->unicode() == '\n') {
                         createNewline(m_curpos + j);
                     }
                     it++;
                 }
                 m_curpos += stringSize;
             } else {
                 // properly set the token pos to the starting double quote
                 m_curpos--;
                 token = Parser::Token_DOUBLE_QUOTE;
                 pushState(String);
             }
         } else if (it->unicode() == '`') {
             token = Parser::Token_BACKTICK;
             pushState(StringBacktick);
         } else if (it->unicode() == '=') {
             if ((it + 1)->unicode() == '=') {
                 m_curpos++;
                 if ((it + 2)->unicode() == '=') {
                     m_curpos++;
                     token = Parser::Token_IS_IDENTICAL;
                 } else {
                     token = Parser::Token_IS_EQUAL;
                 }
             } else if ((it + 1)->unicode() == '>') {
                 m_curpos++;
                 token = Parser::Token_DOUBLE_ARROW;
             } else {
                 token = Parser::Token_ASSIGN;
             }
         } else if (isValidVariableIdentifier(it) && !it->isDigit()) {
             const int from = m_curpos;
             while (m_curpos < m_contentSize && (isValidVariableIdentifier(it))) {
                 it++;
                 m_curpos++;
             }
             const QStringRef name = m_content.midRef(from, m_curpos - from);
             m_curpos--;
             if (name.compare(QLatin1String("echo"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ECHO;
             } else if (name.compare(QLatin1String("include"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_INCLUDE;
             } else if (name.compare(QLatin1String("include_once"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_INCLUDE_ONCE;
             } else if (name.compare(QLatin1String("require"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_REQUIRE;
             } else if (name.compare(QLatin1String("require_once"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_REQUIRE_ONCE;
             } else if (name.compare(QLatin1String("eval"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_EVAL;
             } else if (name.compare(QLatin1String("print"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_PRINT;
             } else if (name.compare(QLatin1String("abstract"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ABSTRACT;
             } else if (name.compare(QLatin1String("break"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_BREAK;
             } else if (name.compare(QLatin1String("case"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CASE;
             } else if (name.compare(QLatin1String("catch"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CATCH;
             } else if (name.compare(QLatin1String("class"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CLASS;
             } else if (name.compare(QLatin1String("const"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CONST;
             } else if (name.compare(QLatin1String("continue"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CONTINUE;
             } else if (name.compare(QLatin1String("default"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_DEFAULT;
             } else if (name.compare(QLatin1String("do"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_DO;
             } else if (name.compare(QLatin1String("else"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ELSE;
             } else if (name.compare(QLatin1String("extends"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_EXTENDS;
             } else if (name.compare(QLatin1String("final"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FINAL;
             } else if (name.compare(QLatin1String("for"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FOR;
             } else if (name.compare(QLatin1String("if"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_IF;
             } else if (name.compare(QLatin1String("implements"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_IMPLEMENTS;
             } else if (name.compare(QLatin1String("instanceof"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_INSTANCEOF;
             } else if (name.compare(QLatin1String("insteadof"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_INSTEADOF;
             } else if (name.compare(QLatin1String("interface"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_INTERFACE;
             } else if (name.compare(QLatin1String("trait"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_TRAIT;
             } else if (name.compare(QLatin1String("new"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_NEW;
             } else if (name.compare(QLatin1String("private"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_PRIVATE;
             } else if (name.compare(QLatin1String("protected"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_PROTECTED;
             } else if (name.compare(QLatin1String("public"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_PUBLIC;
             } else if (name.compare(QLatin1String("return"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_RETURN;
             } else if (name.compare(QLatin1String("static"), Qt::CaseInsensitive) == 0) {
                 const QChar* lookAhead = it;
                 int pos = m_curpos;
                 while (pos < m_contentSize && lookAhead->isSpace()) {
                     ++lookAhead;
                     ++pos;
                 }
                 if (pos + 1 < m_contentSize && lookAhead->unicode() == ':' && (++lookAhead)->unicode() == ':') {
                     // PHP 5.3 - late static
                     token = Parser::Token_STRING;
                 } else {
                     token = Parser::Token_STATIC;
                 }
             } else if (name.compare(QLatin1String("switch"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_SWITCH;
             } else if (name.compare(QLatin1String("throw"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_THROW;
             } else if (name.compare(QLatin1String("try"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_TRY;
             } else if (name.compare(QLatin1String("finally"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FINALLY;
             } else if (name.compare(QLatin1String("while"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_WHILE;
             } else if (name.compare(QLatin1String("clone"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CLONE;
             } else if (name.compare(QLatin1String("exit"), Qt::CaseInsensitive) == 0 || name.compare(QLatin1String("die"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_EXIT;
             } else if (name.compare(QLatin1String("elseif"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ELSEIF;
             } else if (name.compare(QLatin1String("endif"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDIF;
             } else if (name.compare(QLatin1String("endwhile"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDWHILE;
             } else if (name.compare(QLatin1String("endfor"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDFOR;
             } else if (name.compare(QLatin1String("foreach"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FOREACH;
             } else if (name.compare(QLatin1String("endforeach"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDFOREACH;
             } else if (name.compare(QLatin1String("declare"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_DECLARE;
             } else if (name.compare(QLatin1String("enddeclare"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDDECLARE;
             } else if (name.compare(QLatin1String("as"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_AS;
             } else if (name.compare(QLatin1String("endswitch"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ENDSWITCH;
             } else if (name.compare(QLatin1String("function"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FUNCTION;
             } else if (name.compare(QLatin1String("use"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_USE;
             } else if (name.compare(QLatin1String("goto"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_GOTO;
             } else if (name.compare(QLatin1String("global"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_GLOBAL;
             } else if (name.compare(QLatin1String("var"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_VAR;
             } else if (name.compare(QLatin1String("unset"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_UNSET;
             } else if (name.compare(QLatin1String("isset"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ISSET;
             } else if (name.compare(QLatin1String("empty"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_EMPTY;
             } else if (name.compare(QLatin1String("__halt_compiler"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_HALT_COMPILER;
             } else if (name.compare(QLatin1String("list"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_LIST;
             } else if (name.compare(QLatin1String("array"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_ARRAY;
             } else if (name.compare(QLatin1String("__class__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CLASS_C;
             } else if (name.compare(QLatin1String("__method__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_METHOD_C;
             } else if (name.compare(QLatin1String("__function__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FUNC_C;
             } else if (name.compare(QLatin1String("__line__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_LINE;
             } else if (name.compare(QLatin1String("__file__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_FILE;
             } else if (name.compare(QLatin1String("or"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_LOGICAL_OR;
             } else if (name.compare(QLatin1String("and"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_LOGICAL_AND;
             } else if (name.compare(QLatin1String("xor"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_LOGICAL_XOR;
             } else if (name.compare(QLatin1String("namespace"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_NAMESPACE;
             } else if (name.compare(QLatin1String("__namespace__"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_NAMESPACE_C;
             } else if (name.compare(QLatin1String("callable"), Qt::CaseInsensitive) == 0) {
                 token = Parser::Token_CALLABLE;
+            } else if (name.compare(QLatin1String("iterable"), Qt::CaseInsensitive) == 0) {
+                token = Parser::Token_ITERABLE;
+            } else if (name.compare(QLatin1String("bool"), Qt::CaseInsensitive) == 0) {
+                token = Parser::Token_BOOL;
+            } else if (name.compare(QLatin1String("float"), Qt::CaseInsensitive) == 0) {
+                token = Parser::Token_FLOAT;
+            } else if (name.compare(QLatin1String("int"), Qt::CaseInsensitive) == 0) {
+                token = Parser::Token_INT;
+            } else if (name.compare(QLatin1String("string"), Qt::CaseInsensitive) == 0) {
+                token = Parser::Token_STRING_TYPE;
             } else {
                 token = Parser::Token_STRING;
             }
         }
         break;
     }
 
     case StringVariable:
     case String:
     case StringHeredoc:
     case StringBacktick:
         if ((state() == String || state(1) == String) && it->unicode() == '"') {
             token = Parser::Token_DOUBLE_QUOTE;
             if (state() == StringVariable) popState();
             popState();
         } else if ((state() == StringBacktick || state(1) == StringBacktick) && it->unicode() == '`') {
             token = Parser::Token_BACKTICK;
             if (state() == StringVariable) popState();
             popState();
         } else if ((state() == StringHeredoc || state(1) == StringHeredoc) && isHereNowDocEnd(it)) {
             token = Parser::Token_END_HEREDOC;
             m_curpos += m_hereNowDocIdentifier.length() - 1;
             if (state() == StringVariable) popState();
             popState();
         } else if (processVariable(it)) {
             token = Parser::Token_VARIABLE;
             if (state() != StringVariable) pushState(StringVariable);
         } else if (state() != StringVariable  && it->unicode() == '$' && (it + 1)->unicode() == '{') {
             token = Parser::Token_DOLLAR_OPEN_CURLY_BRACES;
             m_curpos++;
             it += 2;
             //check if a valid variable follows
             if ((isValidVariableIdentifier(it) && !it->isDigit())) {
                 pushState(StringVarname);
             }
 
         } else if (state() == StringVariable && it->unicode() == '[') {
             token = Parser::Token_LBRACKET;
             pushState(StringVariableBracket);
         } else if (state() != StringVariable && it->unicode() == '{' && (it + 1)->unicode() == '$'
                    && ((isValidVariableIdentifier(it + 2) && !(it + 2)->isDigit()) || (it + 2)->unicode() == '{')) {
             token = Parser::Token_CURLY_OPEN;
             pushState(StringVariableCurly);
         } else if (state() == StringVariable
                    && it->unicode() == '-' && (it + 1)->unicode() == '>'
                    && isValidVariableIdentifier(it + 2) && !(it + 2)->isDigit()) {
             token = Parser::Token_OBJECT_OPERATOR;
             m_curpos++;
             pushState(StringVariableObjectOperator);
         } else {
             if (state() == StringVariable) popState();
             token = Parser::Token_ENCAPSED_AND_WHITESPACE;
             int startPos = m_curpos;
             while (m_curpos < m_contentSize) {
                 if (!isEscapedWithBackslash(it, m_curpos, startPos) &&
                         ((it->unicode() == '$' && (it + 1)->unicode() == '{') ||
                          (it->unicode() == '{' && (it + 1)->unicode() == '$' && isValidVariableIdentifier(it + 2)) ||
                          (it->unicode() == '$' && isValidVariableIdentifier(it + 1) && !(it + 1)->isDigit()))) {
                     //variable is next ${var} or {$var}
                     break;
                 }
                 if (state() == String && it->unicode() == '"'
                         && !isEscapedWithBackslash(it, m_curpos, startPos)) {
                     //end of string
                     break;
                 }
                 if (state() == StringBacktick && it->unicode() == '`'
                         && !isEscapedWithBackslash(it, m_curpos, startPos)) {
                     //end of string
                     break;
                 }
 
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 m_curpos++;
                 it++;
 
                 if (state() == StringHeredoc && (it - 1)->unicode() == '\n') {
                     //check for end of heredoc (\nEOD;\n)
                     if (state() == StringHeredoc && isHereNowDocEnd(it)) {
                         break;
                     }
                 }
             }
             m_curpos--;
         }
         break;
     case StringNowdoc:
         if (isHereNowDocEnd(it)) {
             token = Parser::Token_END_NOWDOC;
             m_curpos += m_hereNowDocIdentifier.length() - 1;
             popState();
         } else {
             token = Parser::Token_STRING;
             while (m_curpos < m_contentSize) {
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 m_curpos++;
                 it++;
 
                 if ((it - 1)->unicode() == '\n' && isHereNowDocEnd(it)) {
                     //check for end of nowdoc (\nEOD;\n)
                     break;
                 }
             }
             m_curpos--;
         }
         break;
     case StringVariableBracket:
         if (it->unicode() == ']') {
             token = Parser::Token_RBRACKET;
             popState();
             popState();
         } else if (it->isDigit()) {
             token = Parser::Token_NUM_STRING;
             while (m_curpos < m_contentSize && it->isDigit()) {
                 it++;
                 m_curpos++;
             }
             m_curpos--;
         } else {
             token = Parser::Token_STRING;
             while (m_curpos < m_contentSize && (it->unicode() != ']')) {
                 if (it->unicode() == '\n') createNewline(m_curpos);
                 it++;
                 m_curpos++;
             }
             m_curpos--;
         }
         break;
     case StringVariableObjectOperator:
         token = Parser::Token_STRING;
         while (m_curpos < m_contentSize && isValidVariableIdentifier(it)) {
             it++;
             m_curpos++;
         }
         m_curpos--;
         popState();
         if (state() == StringVariable) popState();
         break;
     case StringVarname:
         popState();
         pushState(StringVariableCurly);
         token = Parser::Token_STRING_VARNAME;
         while (m_curpos < m_contentSize && isValidVariableIdentifier(it)) {
             it++;
             m_curpos++;
         }
         m_curpos--;
         break;
     default:
         token = Parser::Token_INVALID;
         break;
     }
     if (m_curpos > m_contentSize) {
         m_tokenBegin = -1;
         m_tokenEnd = -1;
         return 0;
     }
     m_tokenEnd = m_curpos;
     m_curpos++;
 
     if (m_haltCompiler) {
         //look for __halt_compiler(); and stop lexer there
         if (m_haltCompiler == 4) {
             token = 0; //EOF
         } else if (token == Parser::Token_WHITESPACE || token == Parser::Token_COMMENT || token == Parser::Token_DOC_COMMENT) {
             //ignore
         } else if (m_haltCompiler == 1 && token == Parser::Token_LPAREN) {
             m_haltCompiler++;
         } else if (m_haltCompiler == 2 && token == Parser::Token_RPAREN) {
             m_haltCompiler++;
         } else if (m_haltCompiler == 3 && token == Parser::Token_SEMICOLON) {
             m_haltCompiler++;
         } else {
             m_haltCompiler = 0;
         }
     }
     if (token == Parser::Token_HALT_COMPILER && !m_haltCompiler) {
         m_haltCompiler = 1;
     }
     return token;
 }
 
 qint64 Lexer::tokenBegin() const
 {
     return m_tokenBegin;
 }
 
 qint64 Lexer::tokenEnd() const
 {
     return m_tokenEnd;
 }
 
 bool Lexer::isHereNowDocEnd(const QChar* it)
 {
     int identiferLen = m_hereNowDocIdentifier.length();
     QString lineStart;
     for (int i = 0; i < identiferLen; i++) {
         if (m_curpos + i >= m_contentSize) break;
         lineStart.append(*(it + i));
     }
     if (lineStart == m_hereNowDocIdentifier &&
             ((it + identiferLen)->unicode() == '\n'
              || ((it + identiferLen)->unicode() == ';' &&
                  (it + identiferLen + 1)->unicode() == '\n'))) {
         return true;
     }
     return false;
 }
 
 //used for strings, to check if " is escaped (\" is, \\" not)
 bool Lexer::isEscapedWithBackslash(const QChar* it, int curPos, int startPos)
 {
     int cnt = 0;
     it--;
     while (curPos > startPos && it->unicode() == '\\') {
         cnt++;
         it--;
     }
     return (cnt % 2) == 1;
 }
 
 bool Lexer::processVariable(const QChar* it)
 {
     const QChar* c2 = it + 1;
     if (it->unicode() == '$' && (isValidVariableIdentifier(c2) && !c2->isDigit())) {
         it++;
         m_curpos++;
         while (m_curpos < m_contentSize
                 && (isValidVariableIdentifier(it))) {
             it++;
             m_curpos++;
         }
         m_curpos--;
         return true;
     } else {
         return false;
     }
 }
 bool Lexer::isValidVariableIdentifier(const QChar* it)
 {
     return it->isLetter() || it->isDigit() || it->unicode() == '_' || it->unicode() > 0x7f;
 }
 
 void Lexer::createNewline(int pos)
 {
     if (m_tokenStream) m_tokenStream->locationTable()->newline(pos);
 }
 
 }