diff --git a/duchain/declarationbuilder.cpp b/duchain/declarationbuilder.cpp
index e91e027b..d5a45bb3 100644
--- a/duchain/declarationbuilder.cpp
+++ b/duchain/declarationbuilder.cpp
@@ -1,1905 +1,1905 @@
 /*****************************************************************************
  * Copyright (c) 2007 Piyush verma <piyush.verma@gmail.com>                  *
  * Copyright 2007 Andreas Pakulat <apaku@gmx.de>                             *
  * Copyright 2010-2016 Sven Brauch <svenbrauch@googlemail.com>               *
  * Copyright 2016 Francis Herne <mail@flherne.uk>                            *
  *                                                                           *
  * This program is free software; you can redistribute it and/or             *
  * modify it under the terms of the GNU General Public License as            *
  * published by the Free Software Foundation; either version 2 of            *
  * the License, or (at your option) any later version.                       *
  *                                                                           *
  * This program is distributed in the hope that it will be useful,           *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************
  */
 
 #include "declarationbuilder.h"
 #include "duchain/declarations/decorator.h"
 #include "duchain/declarations/functiondeclaration.h"
 #include "duchain/declarations/classdeclaration.h"
 
 #include "types/hintedtype.h"
 #include "types/unsuretype.h"
 #include "types/indexedcontainer.h"
 #include "contextbuilder.h"
 #include "expressionvisitor.h"
 #include "pythoneditorintegrator.h"
 #include "helpers.h"
 #include "assistants/missingincludeassistant.h"
 #include "correctionhelper.h"
 
 #include <language/duchain/functiondeclaration.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/types/alltypes.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/builders/abstracttypebuilder.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/duchainutils.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/backgroundparser/parsejob.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include <QByteArray>
 #include <QtGlobal>
 
 #include <QDebug>
 #include "duchaindebug.h"
 
 #include <functional>
 
 using namespace KTextEditor;
 using namespace KDevelop;
 
 namespace Python
 {
 
 DeclarationBuilder::DeclarationBuilder(Python::PythonEditorIntegrator* editor, int ownPriority)
     : DeclarationBuilderBase()
     , m_ownPriority(ownPriority)
 {
     setEditor(editor);
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Building Declarations";
 }
 
 DeclarationBuilder:: ~DeclarationBuilder()
 {
     if ( ! m_scheduledForDeletion.isEmpty() ) {
         DUChainWriteLocker lock;
         foreach ( DUChainBase* d, m_scheduledForDeletion ) {
             delete d;
         }
         m_scheduledForDeletion.clear();
     }
 }
 
 void DeclarationBuilder::setPrebuilding(bool prebuilding)
 {
     m_prebuilding = prebuilding;
 }
 
 ReferencedTopDUContext DeclarationBuilder::build(const IndexedString& url, Ast* node, ReferencedTopDUContext updateContext)
 {
     m_correctionHelper.reset(new CorrectionHelper(url, this));
 
     // The declaration builder needs to run twice, so it can resolve uses of e.g. functions
     // which are called before they are defined (which is easily possible, due to python's dynamic nature).
     if ( ! m_prebuilding ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "building, but running pre-builder first";
         DeclarationBuilder* prebuilder = new DeclarationBuilder(editor(), m_ownPriority);
         prebuilder->m_currentlyParsedDocument = currentlyParsedDocument();
         prebuilder->setPrebuilding(true);
         prebuilder->m_futureModificationRevision = m_futureModificationRevision;
         updateContext = prebuilder->build(url, node, updateContext);
         qCDebug(KDEV_PYTHON_DUCHAIN) << "pre-builder finished";
         delete prebuilder;
     }
     else {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "prebuilding";
     }
     return DeclarationBuilderBase::build(url, node, updateContext);
 }
 
 int DeclarationBuilder::jobPriority() const
 {
     return m_ownPriority;
 }
 
 void DeclarationBuilder::closeDeclaration()
 {
     if ( lastContext() ) {
         DUChainReadLocker lock(DUChain::lock());
         currentDeclaration()->setKind(Declaration::Type);
     }
     
     Q_ASSERT(currentDeclaration()->alwaysForceDirect());
 
     eventuallyAssignInternalContext();
 
     DeclarationBuilderBase::closeDeclaration();
 }
 
 template<typename T> T* DeclarationBuilder::eventuallyReopenDeclaration(Identifier* name, Ast* range, FitDeclarationType mustFitType)
 {
     QList<Declaration*> existingDeclarations = existingDeclarationsForNode(name);
     
     Declaration* dec = 0;
     reopenFittingDeclaration<T>(existingDeclarations, mustFitType, editorFindRange(range, range), &dec);
     bool declarationOpened = (bool) dec;
     if ( ! declarationOpened ) {
         dec = openDeclaration<T>(name, range);
     }
     Q_ASSERT(dynamic_cast<T*>(dec));
     return static_cast<T*>(dec);
 }
 
 template<typename T> T* DeclarationBuilder::visitVariableDeclaration(Ast* node, Declaration* previous,
                                                                      AbstractType::Ptr type, VisitVariableFlags flags)
 {
     if ( node->astType == Ast::NameAstType ) {
         NameAst* currentVariableDefinition = static_cast<NameAst*>(node);
         // those contexts can invoke a variable declaration
         // this prevents "bar" from being declared in something like "foo = bar"
         // This is just a sanity check, the code should never request creation of a variable
         // in such cases.
         QList<ExpressionAst::Context> declaringContexts;
         declaringContexts << ExpressionAst::Store << ExpressionAst::Parameter << ExpressionAst::AugStore;
         if ( ! declaringContexts.contains(currentVariableDefinition->context) ) {
             return 0;
         }
         Identifier* id = currentVariableDefinition->identifier;
         return visitVariableDeclaration<T>(id, currentVariableDefinition, previous, type, flags);
     }
     else if ( node->astType == Ast::IdentifierAstType ) {
         return visitVariableDeclaration<T>(static_cast<Identifier*>(node), nullptr, previous, type, flags);
     }
     else {
         qCWarning(KDEV_PYTHON_DUCHAIN) << "cannot create variable declaration for non-(name|identifier) AST, this is a programming error";
         return static_cast<T*>(0);
     }
 }
 
 QList< Declaration* > DeclarationBuilder::existingDeclarationsForNode(Identifier* node)
 {
     QList<Declaration*> existingDeclarations = currentContext()->findDeclarations(
         identifierForNode(node).last(), CursorInRevision::invalid(), 0,
         (DUContext::SearchFlag) (DUContext::DontSearchInParent | DUContext::DontResolveAliases)
     );
     // append arguments context
     if ( m_mostRecentArgumentsContext ) {
         QList<Declaration*> args = m_mostRecentArgumentsContext->findDeclarations(
             identifierForNode(node).last(), CursorInRevision::invalid(), 0, DUContext::DontSearchInParent
         );
         existingDeclarations.append(args);
     }
     return existingDeclarations;
 }
 
 DeclarationBuilder::FitDeclarationType DeclarationBuilder::kindForType(AbstractType::Ptr type, bool isAlias)
 {
     if ( type ) {
         if ( type->whichType() == AbstractType::TypeFunction ) {
             return FunctionDeclarationType;
         }
     }
     if ( isAlias ) {
         return AliasDeclarationType;
     }
     return InstanceDeclarationType;
 }
 
 template<typename T> QList<Declaration*> DeclarationBuilder::reopenFittingDeclaration(
     QList<Declaration*> declarations, FitDeclarationType mustFitType,
     RangeInRevision updateRangeTo, Declaration** ok )
 {
     // Search for a declaration from a previous parse pass which should be re-used
     QList<Declaration*> remainingDeclarations;
     *ok = 0;
     foreach ( Declaration* d, declarations ) {
         Declaration* fitting = dynamic_cast<T*>(d);
         if ( ! fitting ) {
             // Only use a declaration if the type matches
             qCDebug(KDEV_PYTHON_DUCHAIN) << "skipping" << d->toString() << "which could not be cast to the requested type";
             continue;
         }
         // Do not use declarations which have been encountered previously;
         // this function only handles declarations from previous parser passes which have not
         // been encountered yet in this pass
         bool reallyEncountered = wasEncountered(d) && ! m_scheduledForDeletion.contains(d);
         bool invalidType = false;
         if ( d && d->abstractType() && mustFitType != NoTypeRequired ) {
             invalidType = ( ( d->isFunctionDeclaration() ) != ( mustFitType == FunctionDeclarationType ) );
             if ( ! invalidType ) {
                 invalidType = ( ( dynamic_cast<AliasDeclaration*>(d) != 0 ) != ( mustFitType == AliasDeclarationType ) );
             }
         }
         if ( fitting && ! reallyEncountered && ! invalidType ) {
             if ( d->topContext() == currentContext()->topContext() ) {
                 openDeclarationInternal(d);
                 d->setRange(updateRangeTo);
                 *ok = d;
                 setEncountered(d);
                 break;
             }
             else {
                 qCDebug(KDEV_PYTHON_DUCHAIN) << "Not opening previously existing declaration because it's in another top context";
             }
         }
         else if ( ! invalidType ) {
             remainingDeclarations << d;
         }
     }
     return remainingDeclarations;
 }
 
 typedef QPair<Declaration*, int> p;
 template<typename T> T* DeclarationBuilder::visitVariableDeclaration(Identifier* node, Ast* originalAst, Declaration* previous,
                                                                      AbstractType::Ptr type, VisitVariableFlags flags)
 {
     DUChainWriteLocker lock;
     Ast* rangeNode = originalAst ? originalAst : node;
     RangeInRevision range = editorFindRange(rangeNode, rangeNode);
     
     // ask the correction file library if there's a user-specified type for this object
     if ( AbstractType::Ptr hint = m_correctionHelper->hintForLocal(node->value) ) {
         type = hint;
     }
 
     // If no type is known, display "mixed".
     if ( ! type ) {
         type = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
     }
     
     QList<Declaration*> existingDeclarations;
     if ( previous ) {
         existingDeclarations << previous;
     }
     else {
         // declarations declared at an earlier range in this top-context
         existingDeclarations = existingDeclarationsForNode(node);
     }
     
     // declaration existing in a previous version of this top-context
     Declaration* dec = 0;
     existingDeclarations = reopenFittingDeclaration<T>(existingDeclarations, kindForType(type), range, &dec);
     bool declarationOpened = (bool) dec;
     if ( flags & AbortIfReopenMismatch && previous && ! declarationOpened ) {
         return nullptr;
     }
     
     // tells whether the declaration found for updating is in the same top context
     bool inSameTopContext = true;
     // tells whether there's fitting declarations to update (update is not the same as re-open! one is for
     // code which uses the same variable twice, the other is for multiple passes of the parser)
     bool haveFittingDeclaration = false;
     if ( ! existingDeclarations.isEmpty() && existingDeclarations.last() ) {
         Declaration* d = Helper::resolveAliasDeclaration(existingDeclarations.last());
         DUChainReadLocker lock;
         if ( d && d->topContext() != topContext() ) {
             inSameTopContext = false;
         }
         if ( dynamic_cast<T*>(existingDeclarations.last()) ) {
             haveFittingDeclaration = true;
         }
     }
     if ( currentContext() && currentContext()->type() == DUContext::Class && ! haveFittingDeclaration ) {
         // If the current context is a class, then this is a class member variable.
         if ( ! dec ) {
             dec = openDeclaration<ClassMemberDeclaration>(identifierForNode(node), range);
             Q_ASSERT(! declarationOpened);
             declarationOpened = true;
         }
         if ( declarationOpened ) {
             DeclarationBuilderBase::closeDeclaration();
         }
         dec->setType(AbstractType::Ptr(type));
         dec->setKind(KDevelop::Declaration::Instance);
     } else if ( ! haveFittingDeclaration ) {
         // This name did not previously appear in the user code, so a new variable is declared
         // check whether a declaration from a previous parser pass must be updated
         if ( ! dec ) {
             dec = openDeclaration<T>(identifierForNode(node), range);
             Q_ASSERT(! declarationOpened);
             declarationOpened = true;
         }
         if ( declarationOpened ) {
             DeclarationBuilderBase::closeDeclaration();
         }
         
         AbstractType::Ptr newType;
         if ( currentContext()->type() == DUContext::Function ) {
             // check for argument type hints (those are created when calling functions)
             AbstractType::Ptr hints = Helper::extractTypeHints(dec->abstractType());
             qCDebug(KDEV_PYTHON_DUCHAIN) << hints->toString();
             if ( hints.cast<IndexedContainer>() || hints.cast<ListType>() ) {
                 // This only happens when the type hint is a tuple, which means the vararg/kwarg of a function is being processed.
                 newType = hints;
             }
             else {
                 newType = Helper::mergeTypes(hints, type);
             }
         }
         else {
             newType = type;
         }
         dec->setType(newType);
         dec->setKind(KDevelop::Declaration::Instance);
     }
     else if ( inSameTopContext ) {
         // The name appeared previously in the user code, so no new variable is declared, but just
         // the type is modified accordingly.
         dec = existingDeclarations.last();
         AbstractType::Ptr currentType = dec->abstractType();
         AbstractType::Ptr newType = type;
         if ( newType ) {
             if ( currentType && currentType->indexed() != newType->indexed() ) {
                 // If the previous and new type are different, use an unsure type
                 dec->setType(Helper::mergeTypes(currentType, newType));
             }
             else {
                 // If no type was set previously, use only the new one.
                 dec->setType(AbstractType::Ptr(type));
             }
         }
     }
 
     T* result = dynamic_cast<T*>(dec);
     if ( ! result ) qCWarning(KDEV_PYTHON_DUCHAIN) << "variable declaration does not have the expected type";
     return result;
 }
 
 void DeclarationBuilder::visitCode(CodeAst* node)
 {
     Q_ASSERT(currentlyParsedDocument().toUrl().isValid());
     m_unresolvedImports.clear();
     DeclarationBuilderBase::visitCode(node);
 }
 
 void DeclarationBuilder::visitExceptionHandler(ExceptionHandlerAst* node)
 {
     if ( node->name ) {
         // Python allows to assign the caught exception to a variable; create that variable if required.
         ExpressionVisitor v(currentContext());
         v.visitNode(node->type);
         visitVariableDeclaration<Declaration>(node->name, 0, v.lastType());
     }
     DeclarationBuilderBase::visitExceptionHandler(node);
 }
 
 void DeclarationBuilder::visitWithItem(WithItemAst* node)
 {
     if ( node->optionalVars ) {
         // For statements like "with open(f) as x", a new variable must be created; do this here.
         ExpressionVisitor v(currentContext());
         v.visitNode(node->contextExpression);
         visitVariableDeclaration<Declaration>(node->optionalVars, 0, v.lastType());
     }
     Python::AstDefaultVisitor::visitWithItem(node);
 }
 
 void DeclarationBuilder::visitFor(ForAst* node)
 {
     if ( node->iterator ) {
         ExpressionVisitor v(currentContext());
         v.visitNode(node->iterator);
         assignToUnknown(node->target, Helper::contentOfIterable(v.lastType()));
     }
     Python::ContextBuilder::visitFor(node);
 }
 
 Declaration* DeclarationBuilder::findDeclarationInContext(QStringList dottedNameIdentifier, TopDUContext* ctx) const
 {
     DUChainReadLocker lock(DUChain::lock());
     DUContext* currentContext = ctx;
     // TODO make this a bit faster, it wastes time
     Declaration* lastAccessedDeclaration = 0;
     int i = 0;
     int identifierCount = dottedNameIdentifier.length();
     foreach ( const QString& currentIdentifier, dottedNameIdentifier ) {
         Q_ASSERT(currentContext);
         i++;
         QList<Declaration*> declarations = currentContext->findDeclarations(QualifiedIdentifier(currentIdentifier).first(),
                                                                             CursorInRevision::invalid(), 0, DUContext::NoFiltering);
         // break if the list of identifiers is not yet totally worked through and no
         // declaration with an internal context was found
         if ( declarations.isEmpty() || ( !declarations.last()->internalContext() && identifierCount != i ) ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Declaration not found: " << dottedNameIdentifier << "in top context" << ctx->url().toUrl().path();
             return 0;
         }
         else {
             lastAccessedDeclaration = declarations.last();
             currentContext = lastAccessedDeclaration->internalContext();
         }
     }
     return lastAccessedDeclaration;
 }
 
 QString DeclarationBuilder::buildModuleNameFromNode(ImportFromAst* node, AliasAst* alias, const QString& intermediate) const
 {
     QString moduleName = alias->name->value;
     if ( ! intermediate.isEmpty() ) {
         moduleName.prepend('.').prepend(intermediate);
     }
     if ( node->module ) {
         moduleName.prepend('.').prepend(node->module->value);
     }
     // To handle relative imports correctly, add node level in the beginning of the path
     // This will allow findModulePath to deduce module search direcotry properly
     moduleName.prepend(QString(node->level, '.'));
     return moduleName;
 }
 
 void DeclarationBuilder::visitImportFrom(ImportFromAst* node)
 {
     Python::AstDefaultVisitor::visitImportFrom(node);
     QString moduleName;
     QString declarationName;
     foreach ( AliasAst* name, node->names ) {
         // iterate over all the names that are imported, like "from foo import bar as baz, bang as asdf"
         Identifier* declarationIdentifier = 0;
         declarationName.clear();
         if ( name->asName ) {
             // use either the alias ("as foo"), or the object name itself if no "as" is given
             declarationIdentifier = name->asName;
             declarationName = name->asName->value;
         }
         else {
             declarationIdentifier = name->name;
             declarationName = name->name->value;
         }
         // This is a bit hackish, it tries to find the specified object twice twice -- once it tries to
         // import the name from a module's __init__.py file, and once from a "real" python file
         // TODO improve this code-wise
         ProblemPointer problem(0);
         QString intermediate;
         moduleName = buildModuleNameFromNode(node, name, intermediate);
         Declaration* success = createModuleImportDeclaration(moduleName, declarationName, declarationIdentifier, problem);
         if ( ! success && (node->module || node->level) ) {
             ProblemPointer problem_init(0);
             intermediate = QString("__init__");
             moduleName = buildModuleNameFromNode(node, name, intermediate);
             success = createModuleImportDeclaration(moduleName, declarationName, declarationIdentifier, problem_init);
         }
         if ( ! success && problem ) {
             DUChainWriteLocker lock;
             topContext()->addProblem(problem);
         }
     }
 }
 
 void spoofNodePosition(Ast* node, int column) {
     // Ridiculous hack, see next comment.
     node->startCol = node-> endCol = column;
     if (node->astType == Ast::TupleAstType) {
         //  Recursion to bodge all declarations, e.g.
         //  [x + y * z for x, (y, z) in foo]
         foreach(auto elem, static_cast<TupleAst*>(node)->elements) {
             spoofNodePosition(elem, column);
         }
     }
 }
 
 void DeclarationBuilder::visitComprehension(ComprehensionAst* node)
 {
     Python::AstDefaultVisitor::visitComprehension(node);
     // make the declaration zero chars long; it must appear at the beginning of the context,
     // because it is actually used *before* its real declaration: [foo for foo in bar]
     // The DUChain doesn't like this, so for now, the declaration is at the opening bracket,
     // and both other occurrences are uses of that declaration.
     // TODO add a special case to the usebuilder to display the second occurrence as a declaration
     spoofNodePosition(node->target, currentContext()->range().start.column - 1);
 
     ExpressionVisitor v(currentContext());
     v.visitNode(node->iterator);
     assignToUnknown(node->target, Helper::contentOfIterable(v.lastType()));
 }
 
 void DeclarationBuilder::visitImport(ImportAst* node)
 {
     Python::ContextBuilder::visitImport(node);
     DUChainWriteLocker lock;
     foreach ( AliasAst* name, node->names ) {
         QString moduleName = name->name->value;
         // use alias if available, name otherwise
         Identifier* declarationIdentifier = name->asName ? name->asName : name->name;
         ProblemPointer problem(0);
         createModuleImportDeclaration(moduleName, declarationIdentifier->value, declarationIdentifier, problem);
         if ( problem ) {
             DUChainWriteLocker lock;
             topContext()->addProblem(problem);
         }
     }
 }
 
 void DeclarationBuilder::scheduleForDeletion(DUChainBase* d, bool doschedule)
 {
     if ( doschedule ) {
         m_scheduledForDeletion.append(d);
     }
     else {
         m_scheduledForDeletion.removeAll(d);
     }
 }
 
 
 Declaration* DeclarationBuilder::createDeclarationTree(const QStringList& nameComponents, Identifier* declarationIdentifier,
                                        const ReferencedTopDUContext& innerCtx, Declaration* aliasDeclaration,
                                        const RangeInRevision& range)
 {
     // This actually handles two use cases which are very similar -- thus this check:
     // There might be either one declaration which should be imported from another module,
     // or there might be a whole context. In "import foo.bar", the "bar" might be either
     // a single class/function/whatever, or a whole file to import.
     // NOTE: The former case can't actually happen in python, it's not allowed. However,
     // it is still handled here, because it's very useful for documentation files (pyQt for example
     // makes heavy use of that feature).
     Q_ASSERT( ( innerCtx.data() || aliasDeclaration ) && "exactly one of innerCtx or aliasDeclaration must be provided");
     Q_ASSERT( ( !innerCtx.data() || !aliasDeclaration ) && "exactly one of innerCtx or aliasDeclaration must be provided");
     
     qCDebug(KDEV_PYTHON_DUCHAIN) << "creating declaration tree for" << nameComponents;
     
     Declaration* lastDeclaration = 0;
     int depth = 0;
     
     // check for already existing trees to update
     for ( int i = nameComponents.length() - 1; i >= 0; i-- ) {
         QStringList currentName;
         for ( int j = 0; j < i; j++ ) {
             currentName.append(nameComponents.at(j));
         }
         lastDeclaration = findDeclarationInContext(currentName, topContext());
         if ( lastDeclaration && (!range.isValid() || lastDeclaration->range() < range) ) {
             depth = i;
             break;
         }
     }
     
     DUContext* extendingPreviousImportCtx = 0;
     QStringList remainingNameComponents;
     bool injectingContext = false;
     if ( lastDeclaration && lastDeclaration->internalContext() ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Found existing import statement while creating declaration for " << declarationIdentifier->value;
         for ( int i = depth; i < nameComponents.length(); i++ ) {
             remainingNameComponents.append(nameComponents.at(i));
         }
         extendingPreviousImportCtx = lastDeclaration->internalContext();
         injectContext(extendingPreviousImportCtx);
         injectingContext = true;
         qCDebug(KDEV_PYTHON_DUCHAIN) << "remaining identifiers:" << remainingNameComponents;
     }
     else {
         remainingNameComponents = nameComponents;
         extendingPreviousImportCtx = topContext();
     }
     
     // now, proceed in creating the declaration tree with whatever context
     QList<Declaration*> openedDeclarations;
     QList<StructureType::Ptr> openedTypes;
     QList<DUContext*> openedContexts;
     
     RangeInRevision displayRange = RangeInRevision::invalid();
     
     DUChainWriteLocker lock;
     for ( int i = 0; i < remainingNameComponents.length(); i++ ) {
         // Iterate over all the names, and create a declaration + sub-context for each of them
         const QString& component = remainingNameComponents.at(i);
         Identifier temporaryIdentifier(component);
         Declaration* d = 0;
         temporaryIdentifier.copyRange(declarationIdentifier);
         temporaryIdentifier.endCol = temporaryIdentifier.startCol;
         temporaryIdentifier.startCol += 1;
         displayRange = editorFindRange(&temporaryIdentifier, &temporaryIdentifier); // TODO fixme
         
         bool done = false;
         if ( aliasDeclaration && i == remainingNameComponents.length() - 1 ) {
             // it's the last level, so if we have an alias declaration create it and stop
             if (    aliasDeclaration->isFunctionDeclaration() 
                  || dynamic_cast<ClassDeclaration*>(aliasDeclaration) 
                  || dynamic_cast<AliasDeclaration*>(aliasDeclaration) 
                ) {
                 aliasDeclaration = Helper::resolveAliasDeclaration(aliasDeclaration);
                 AliasDeclaration* adecl = eventuallyReopenDeclaration<AliasDeclaration>(&temporaryIdentifier,
                                                                                         &temporaryIdentifier,
                                                                                         AliasDeclarationType);
                 if ( adecl ) {
                     adecl->setAliasedDeclaration(aliasDeclaration);
                 }
                 d = adecl;
                 closeDeclaration();
             }
             else {
                 d = visitVariableDeclaration<Declaration>(&temporaryIdentifier);
                 d->setAbstractType(aliasDeclaration->abstractType());
             }
             openedDeclarations.append(d);
             done = true;
         }
         
         if ( ! done ) {
             // create the next level of the tree hierarchy if not done yet.
             d = visitVariableDeclaration<Declaration>(&temporaryIdentifier);
         }
         if ( d ) {
             if ( topContext() != currentContext() ) {
                 d->setRange(RangeInRevision(currentContext()->range().start, currentContext()->range().start));
             }
             else {
                 d->setRange(displayRange);
             }
             d->setAutoDeclaration(true);
             currentContext()->createUse(d->ownIndex(), d->range());
             qCDebug(KDEV_PYTHON_DUCHAIN) << "really encountered:" << d << "; scheduled:" << m_scheduledForDeletion;
             qCDebug(KDEV_PYTHON_DUCHAIN) << d->toString();
             scheduleForDeletion(d, false);
             qCDebug(KDEV_PYTHON_DUCHAIN) << "scheduled:" << m_scheduledForDeletion;
         }
         if ( done ) break;
 
         qCDebug(KDEV_PYTHON_DUCHAIN) << "creating context for " << component;
 
         // otherwise, create a new "level" entry (a pseudo type + context + declaration which contains all imported items)
         StructureType::Ptr moduleType = StructureType::Ptr(new StructureType());
         openType(moduleType);
 
         // the identifier is needed so the context does not get re-opened if
         // more contexts are opened for other files with the same range
         Python::Identifier contextIdentifier(component);
         auto moduleContext = openContext(declarationIdentifier, KDevelop::DUContext::Other, &contextIdentifier);
         openedContexts.append(moduleContext);
 
         foreach ( Declaration* local, currentContext()->localDeclarations() ) {
             // keep all the declarations until the builder finished
             // kdevelop would otherwise delete them as soon as the context is closed
             if ( ! wasEncountered(local) ) {
                 setEncountered(local);
                 scheduleForDeletion(local, true);
             }
         }
 
         openedDeclarations.append(d);
         openedTypes.append(moduleType);
         if ( i == remainingNameComponents.length() - 1 ) {
             if ( innerCtx ) {
                 qCDebug(KDEV_PYTHON_DUCHAIN) << "adding imported context to inner declaration";
                 currentContext()->addImportedParentContext(innerCtx);
             }
             else if ( aliasDeclaration ) {
                 qCDebug(KDEV_PYTHON_DUCHAIN) << "setting alias declaration on inner declaration";
             }
         }
     }
     for ( int i = openedContexts.length() - 1; i >= 0; i-- ) {
         // Close all the declarations and contexts opened previosly, and assign the types.
         qCDebug(KDEV_PYTHON_DUCHAIN) << "closing context";
         closeType();
         closeContext();
         auto d = openedDeclarations.at(i);
         // because no context will be opened for an alias declaration, this will not happen if there's one
         if ( d ) {
             openedTypes[i]->setDeclaration(d);
             d->setType(openedTypes.at(i));
             d->setInternalContext(openedContexts.at(i));
         }
     }
     
     if ( injectingContext ) {
         closeInjectedContext();
     }
     
     if ( ! openedDeclarations.isEmpty() ) {
         // return the lowest-level element in the tree, for the caller to do stuff with
         return openedDeclarations.last();
     }
     else return 0;
 }
 
 Declaration* DeclarationBuilder::createModuleImportDeclaration(QString moduleName, QString declarationName,
                                                                Identifier* declarationIdentifier,
                                                                ProblemPointer& problemEncountered, Ast* rangeNode)
 {
     // Search the disk for a python file which contains the requested declaration
     auto moduleInfo = findModulePath(moduleName, currentlyParsedDocument().toUrl());
     RangeInRevision range(RangeInRevision::invalid());
     if ( rangeNode ) {
         range = rangeForNode(rangeNode, false);
     }
     else {
         range = rangeForNode(declarationIdentifier, false);
     }
     Q_ASSERT(range.isValid());
     
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Found module path [path/path in file]: " << moduleInfo;
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Declaration identifier:" << declarationIdentifier->value;
     DUChainWriteLocker lock;
     const IndexedString modulePath = IndexedString(moduleInfo.first);
     ReferencedTopDUContext moduleContext = DUChain::self()->chainForDocument(modulePath);
     lock.unlock();
     Declaration* resultingDeclaration = 0;
     if ( ! moduleInfo.first.isValid() ) {
         // The file was not found -- this is either an error in the user's code,
         // a missing module, or a C module (.so) which is unreadable for kdevelop
         // TODO imrpove error handling in case the module exists as a shared object or .pyc file only
         qCDebug(KDEV_PYTHON_DUCHAIN) << "invalid or non-existent URL:" << moduleInfo;
         KDevelop::Problem *p = new Python::MissingIncludeProblem(moduleName, currentlyParsedDocument());
         p->setFinalLocation(DocumentRange(currentlyParsedDocument(), range.castToSimpleRange()));
         p->setSource(KDevelop::IProblem::SemanticAnalysis);
         p->setSeverity(KDevelop::IProblem::Warning);
         p->setDescription(i18n("Module \"%1\" not found", moduleName));
         m_missingModules.append(IndexedString(moduleName));
         problemEncountered = p;
         return 0;
     }
     if ( ! moduleContext ) {
         // schedule the include file for parsing, and schedule the current one for reparsing after that is done
         qCDebug(KDEV_PYTHON_DUCHAIN) << "No module context, recompiling";
         m_unresolvedImports.append(modulePath);
         Helper::scheduleDependency(modulePath, m_ownPriority);
         // parseDocuments() must *not* be called from a background thread!
         // KDevelop::ICore::self()->languageController()->backgroundParser()->parseDocuments();
         return 0;
     }
     if ( moduleInfo.second.isEmpty() ) {
         // import the whole module
         resultingDeclaration = createDeclarationTree(declarationName.split("."),
                                                      declarationIdentifier, moduleContext, 0, range);
         auto initFile = QStringLiteral("/__init__.py");
         auto path = moduleInfo.first.path();
         if ( path.endsWith(initFile) ) {
             // if the __init__ file is imported, import all the other files in that directory as well
             QDir dir(path.left(path.size() - initFile.size()));
             dir.setNameFilters({"*.py"});
             dir.setFilter(QDir::Files);
             auto files = dir.entryList();
             foreach ( const auto& file, files ) {
                 if ( file == QStringLiteral("__init__.py") ) {
                     continue;
                 }
                 const auto filePath = declarationName.split(".") << file.left(file.lastIndexOf(".py"));
                 const auto fileUrl = QUrl::fromLocalFile(dir.path() + "/" + file);
                 ReferencedTopDUContext fileContext;
                 {
                     DUChainReadLocker lock;
                     fileContext = DUChain::self()->chainForDocument(IndexedString(fileUrl));
                 }
                 if ( fileContext ) {
                     Identifier id = *declarationIdentifier;
                     id.value.append(".").append(filePath.last());
                     createDeclarationTree(filePath,
                                           &id, fileContext, 0);
                 }
                 else {
                     m_unresolvedImports.append(IndexedString(fileUrl));
                     Helper::scheduleDependency(IndexedString(fileUrl), m_ownPriority);
                 }
             }
         }
     }
     else {
         // import a specific declaration from the given file
         lock.lock();
         if ( declarationIdentifier->value == "*" ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Importing * from module";
             currentContext()->addImportedParentContext(moduleContext);
         }
         else {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Got module, importing declaration: " << moduleInfo.second;
             Declaration* originalDeclaration = findDeclarationInContext(moduleInfo.second, moduleContext);
             if ( originalDeclaration ) {
                 DUChainWriteLocker lock(DUChain::lock());
                 resultingDeclaration = createDeclarationTree(declarationName.split("."), declarationIdentifier,
                                                              ReferencedTopDUContext(0), originalDeclaration,
                                                              editorFindRange(declarationIdentifier, declarationIdentifier));
             }
             else {
                 KDevelop::Problem *p = new Python::MissingIncludeProblem(moduleName, currentlyParsedDocument());
                 p->setFinalLocation(DocumentRange(currentlyParsedDocument(), range.castToSimpleRange())); // TODO ok?
                 p->setSource(KDevelop::IProblem::SemanticAnalysis);
                 p->setSeverity(KDevelop::IProblem::Warning);
                 p->setDescription(i18n("Declaration for \"%1\" not found in specified module", moduleInfo.second.join(".")));
                 problemEncountered = p;
             }
         }
     }
     return resultingDeclaration;
 }
 
 void DeclarationBuilder::visitYield(YieldAst* node)
 {
     // Functions containing "yield" statements will return lists in our abstraction.
     // The content type of that list can be guessed from the yield statements.
     AstDefaultVisitor::visitYield(node);
     
     // Determine the type of the argument to "yield", like "int" in "yield 3"
     ExpressionVisitor v(currentContext());
     v.visitNode(node->value);
     AbstractType::Ptr encountered = v.lastType();
     
     // In some obscure (or wrong) cases, "yield" might appear outside of a function body,
     // so check for that here.
     if ( ! node->value || ! hasCurrentType() ) {
         return;
     }
 
     TypePtr<FunctionType> t = currentType<FunctionType>();
     if ( ! t ) {
         return;
     }
     if ( auto previous = t->returnType().cast<ListType>() ) {
         // If the return type of the function already is set to a list, *add* the encountered type
         // to its possible content types.
         previous->addContentType<Python::UnsureType>(encountered);
         t->setReturnType(previous.cast<AbstractType>());
     }
     else {
         // Otherwise, create a new container type, and set it as the function's return type.
         DUChainWriteLocker lock;
         auto container = ExpressionVisitor::typeObjectForIntegralType<ListType>("list");
         if ( container ) {
             openType<ListType>(container);
             container->addContentType<Python::UnsureType>(encountered);
             t->setReturnType(Helper::mergeTypes(t->returnType(), container.cast<AbstractType>()));
             closeType();
         }
     }
 }
 
 void DeclarationBuilder::visitLambda(LambdaAst* node)
 {
     Python::AstDefaultVisitor::visitLambda(node);
     DUChainWriteLocker lock;
     // A context must be opened, because the lamdba's arguments are local to the lambda:
     // d = lambda x: x*2; print x # <- gives an error
     openContext(node, editorFindRange(node, node->body), DUContext::Other);
     foreach ( ArgAst* argument, node->arguments->arguments ) {
         visitVariableDeclaration<Declaration>(argument->argumentName);
     }
     closeContext();
 }
 
 void DeclarationBuilder::applyDocstringHints(CallAst* node, FunctionDeclaration::Ptr function)
 {
     ExpressionVisitor v(currentContext());
     v.visitNode(static_cast<AttributeAst*>(node->function)->value);
 
     // Don't do anything if the object the function is being called on is not a container.
     auto container = v.lastType().cast<ListType>();
     if ( ! container || ! function ) {
         return;
     }
     // Don't do updates to pre-defined functions.
     if ( ! v.lastDeclaration() || v.lastDeclaration()->topContext()->url() == IndexedString(Helper::getDocumentationFile()) ) {
         return;
     }
     // Check for the different types of modifiers such a function can have
     QStringList args;
     QHash< QString, std::function<void()> > items;
     items["addsTypeOfArg"] = [&]() {
         const int offset = ! args.isEmpty() ? args.at(0).toInt() : 0;
         if ( node->arguments.length() <= offset ) {
             return;
         }
         // Check which type should be added to the list
         ExpressionVisitor argVisitor(currentContext());
         argVisitor.visitNode(node->arguments.at(offset));
         // Actually add that type
         if ( ! argVisitor.lastType() ) {
             return;
         }
         DUChainWriteLocker wlock;
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Adding content type: " << argVisitor.lastType()->toString();
         container->addContentType<Python::UnsureType>(argVisitor.lastType());
         v.lastDeclaration()->setType(container);
     };
     items["addsTypeOfArgContent"] = [&]() {
         const int offset = ! args.isEmpty() ? args.at(0).toInt() : 0;
         if ( node->arguments.length() <= offset ) {
             return;
         }
         ExpressionVisitor argVisitor(currentContext());
         argVisitor.visitNode(node->arguments.at(offset));
         DUChainWriteLocker wlock;
         if ( ! argVisitor.lastType() ) {
             return;
         }
         auto sources = Helper::filterType<ListType>(
             argVisitor.lastType(), [](AbstractType::Ptr type) {
                 return type.cast<ListType>();
             }
         );
         for ( auto sourceContainer : sources ) {
             if ( ! sourceContainer->contentType() ) {
                 continue;
             }
             container->addContentType<Python::UnsureType>(sourceContainer->contentType().abstractType());
             v.lastDeclaration()->setType(container);
         }
     };
 
     foreach ( const QString& key, items.keys() ) {
         if ( Helper::docstringContainsHint(function.data(), key, &args) ) {
             items[key]();
         }
     }
 }
 
 void DeclarationBuilder::addArgumentTypeHints(CallAst* node, DeclarationPointer function)
 {
     DUChainReadLocker lock;
     QPair<FunctionDeclaration::Ptr, bool> called = Helper::functionDeclarationForCalledDeclaration(function);
     FunctionDeclaration::Ptr lastFunctionDeclaration = called.first;
     bool isConstructor = called.second;
 
     if ( ! lastFunctionDeclaration ) {
         return;
     }
     if ( lastFunctionDeclaration->topContext()->url() == IndexedString(Helper::getDocumentationFile()) ) {
         return;
     }
     DUContext* args = DUChainUtils::getArgumentContext(lastFunctionDeclaration.data());
     FunctionType::Ptr functiontype = lastFunctionDeclaration->type<FunctionType>();
     if ( ! args || ! functiontype ) {
         return;
     }
     // The declaration which was found is a function declaration, and has a valid arguments list assigned.
     QVector<Declaration*> parameters = args->localDeclarations();
     const int specialParamsCount = (lastFunctionDeclaration->vararg() > 0) + (lastFunctionDeclaration->kwarg() > 0);
 
     // Look for the "self" in the argument list, the type of that should not be updated.
     bool hasSelfArgument = false;
     if ( ( lastFunctionDeclaration->context()->type() == DUContext::Class || isConstructor )
             && ! parameters.isEmpty() && ! lastFunctionDeclaration->isStatic() )
     {
         // ... unless for some reason the function only has *vararg, **kwarg as arguments
         // (this could happen for example if the method is static but kdev-python does not know,
         // or if the user just made a mistake in his code)
         if ( specialParamsCount < parameters.size() ) {
             hasSelfArgument = true;
         }
     }
     int currentParamIndex = hasSelfArgument;
     int currentArgumentIndex = 0;
     int indexInVararg = -1;
     int paramsAvailable = qMin(functiontype->arguments().length(), parameters.size());
     int argsAvailable = node->arguments.size();
     bool atVararg = false;
 
     lock.unlock();
 
     // Iterate over all the arguments, trying to guess the type of the object being
     // passed as an argument, and update the parameter accordingly.
     // Stop if more parameters supplied than possible, and we're not at the vararg.
     for ( ; ( atVararg || currentParamIndex < paramsAvailable ) && currentArgumentIndex < argsAvailable;
             currentParamIndex++, currentArgumentIndex++ )
     {
         if ( ! atVararg && currentArgumentIndex == lastFunctionDeclaration->vararg() ) {
             atVararg = true;
         }
 
         qCDebug(KDEV_PYTHON_DUCHAIN) << currentParamIndex << currentArgumentIndex << atVararg << lastFunctionDeclaration->vararg();
 
         ExpressionAst* arg = node->arguments.at(currentArgumentIndex);
 
         ExpressionVisitor argumentVisitor(currentContext());
         argumentVisitor.visitNode(arg);
         AbstractType::Ptr argumentType = argumentVisitor.lastType();
 
         // Update the parameter type: change both the type of the function argument,
         // and the type of the declaration which belongs to that argument
         HintedType::Ptr addType = HintedType::Ptr(new HintedType());
         openType(addType);
         addType->setType(argumentVisitor.lastType());
         addType->setCreatedBy(topContext(), m_futureModificationRevision);
         closeType();
 
         DUChainWriteLocker wlock;
         if ( atVararg ) {
             indexInVararg++;
             Declaration* parameter = parameters.at(lastFunctionDeclaration->vararg()+hasSelfArgument);
             IndexedContainer::Ptr varargContainer = parameter->type<IndexedContainer>();
             qCDebug(KDEV_PYTHON_DUCHAIN) << "adding" << addType->toString() << "at position" << indexInVararg;
             if ( ! varargContainer ) continue;
             if ( varargContainer->typesCount() > indexInVararg ) {
                 AbstractType::Ptr oldType = varargContainer->typeAt(indexInVararg).abstractType();
                 AbstractType::Ptr newType = Helper::mergeTypes(oldType, addType.cast<AbstractType>());
                 varargContainer->replaceType(indexInVararg, newType);
             }
             else {
                 varargContainer->addEntry(addType.cast<AbstractType>());
             }
             parameter->setAbstractType(varargContainer.cast<AbstractType>());
         }
         else {
             if ( ! argumentType ) continue;
             AbstractType::Ptr newType = Helper::mergeTypes(parameters.at(currentParamIndex)->abstractType(),
                                                            addType.cast<AbstractType>());
             // TODO this does not correctly update the types in quickopen! Investigate why.
             functiontype->removeArgument(currentArgumentIndex + hasSelfArgument);
             functiontype->addArgument(newType, currentArgumentIndex + hasSelfArgument);
             lastFunctionDeclaration->setAbstractType(functiontype.cast<AbstractType>());
             parameters.at(currentParamIndex)->setType(newType);
         }
     }
 
     lock.unlock();
     DUChainWriteLocker wlock;
     if ( lastFunctionDeclaration->kwarg() < 0 || parameters.isEmpty() ) {
         // no kwarg, stop here.
         return;
     }
     foreach ( KeywordAst* keyword, node->keywords ) {
         AbstractType::Ptr param = parameters.last()->abstractType();
         auto list = param.cast<ListType>();
         if ( ! list ) {
             continue;
         }
         wlock.unlock();
         ExpressionVisitor argumentVisitor(currentContext());
         argumentVisitor.visitNode(keyword->value);
         if ( ! argumentVisitor.lastType() ) {
             continue;
         }
         wlock.lock();
         HintedType::Ptr addType = HintedType::Ptr(new HintedType());
         openType(addType);
         addType->setType(argumentVisitor.lastType());
         addType->setCreatedBy(topContext(), m_futureModificationRevision);
         closeType();
         list->addContentType<Python::UnsureType>(addType.cast<AbstractType>());
         parameters.last()->setAbstractType(list.cast<AbstractType>());
     }
 }
 
 void DeclarationBuilder::visitCall(CallAst* node)
 {
     Python::AstDefaultVisitor::visitCall(node);
     // Find the function being called; this code also handles cases where non-names
     // are called, for example:
     //     class myclass():
     //         def myfun(self): return 3
     //     l = [myclass()]
     //     x = l[0].myfun() # the called object is actually l[0].myfun
     // In the above example, this call will be evaluated to "myclass.myfun" in the following statement.
     ExpressionVisitor functionVisitor(currentContext());
     functionVisitor.visitNode(node);
 
     if ( node->function && node->function->astType == Ast::AttributeAstType && functionVisitor.lastDeclaration() ) {
         // Some special functions, like "append", update the content of the object they operate on.
         // Find the object the function is called on, like for d = [1, 2, 3]; d.append(5), this will give "d"
         FunctionDeclaration::Ptr function = functionVisitor.lastDeclaration().dynamicCast<FunctionDeclaration>();
         applyDocstringHints(node, function);
     }
     if ( ! m_prebuilding ) {
         return;
     }
 
     // The following code will try to update types of function parameters based on what is passed
     // for those when the function is used.
     // In case of this code:
     //     def foo(arg): print arg
     //     foo(3)
     // the following will change the type of "arg" to be "int" when it processes the second line.
     addArgumentTypeHints(node, functionVisitor.lastDeclaration());
 }
 
 void DeclarationBuilder::assignToName(NameAst* target, const DeclarationBuilder::SourceType& element)
 {
     if ( element.isAlias ) {
         DUChainWriteLocker lock;
         Python::Identifier* identifier = target->identifier;
         AliasDeclaration* decl = eventuallyReopenDeclaration<AliasDeclaration>(identifier, target, AliasDeclarationType);
         decl->setAliasedDeclaration(element.declaration.data());
         closeDeclaration();
     }
     else {
         DUChainWriteLocker lock;
         Declaration* dec = visitVariableDeclaration<Declaration>(target, 0, element.type);
         if ( dec && m_lastComment && ! m_lastComment->usedAsComment ) {
             dec->setComment(m_lastComment->value);
             m_lastComment->usedAsComment = true;
         }
         /** DEBUG **/
         if ( element.type && dec ) {
             Q_ASSERT(dec->abstractType());
         }
         /** END DEBUG **/
     }
 }
 
 void DeclarationBuilder::assignToSubscript(SubscriptAst* subscript, const DeclarationBuilder::SourceType& element)
 {
     ExpressionAst* v = subscript->value;
     if ( ! element.type ) {
         return;
     }
     ExpressionVisitor targetVisitor(currentContext());
     targetVisitor.visitNode(v);
     auto list = ListType::Ptr::dynamicCast(targetVisitor.lastType());
     if ( list ) {
         list->addContentType<Python::UnsureType>(element.type);
     }
     auto map = MapType::Ptr::dynamicCast(list);
     if ( map ) {
         if ( subscript->slice && subscript->slice->astType == Ast::IndexAstType ) {
             ExpressionVisitor keyVisitor(currentContext());
             keyVisitor.visitNode(static_cast<IndexAst*>(subscript->slice)->value);
             AbstractType::Ptr key = keyVisitor.lastType();
             if ( key ) {
                 map->addKeyType<Python::UnsureType>(key);
             }
         }
     }
     DeclarationPointer lastDecl = targetVisitor.lastDeclaration();
     if ( list && lastDecl ) {
         DUChainWriteLocker lock;
         lastDecl->setAbstractType(list.cast<AbstractType>());
     }
 }
 
 void DeclarationBuilder::assignToAttribute(AttributeAst* attrib, const DeclarationBuilder::SourceType& element)
 {
     // visit the base expression before the dot
     ExpressionVisitor checkPreviousAttributes(currentContext());
     checkPreviousAttributes.visitNode(attrib->value);
     DeclarationPointer parentObjectDeclaration = checkPreviousAttributes.lastDeclaration();
 
     DUContextPointer internal(0);
 
     if ( ! parentObjectDeclaration ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "No declaration for attribute base, aborting creation of attribute";
         return;
     }
     // if foo is a class, this is like foo.bar = 3
     if ( parentObjectDeclaration->internalContext() ) {
         internal = parentObjectDeclaration->internalContext();
     }
     // while this is like A = foo(); A.bar = 3
     else {
         DUChainReadLocker lock;
         StructureType::Ptr structure(parentObjectDeclaration->abstractType().cast<StructureType>());
         if ( ! structure || ! structure->declaration(topContext()) ) {
             return;
         }
         parentObjectDeclaration = structure->declaration(topContext());
         internal = parentObjectDeclaration->internalContext();
     }
     if ( ! internal ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "No internal context for structure type, aborting creation of attribute declaration";
         return;
     }
 
     Declaration* attributeDeclaration = nullptr;
     {
         DUChainReadLocker lock;
-        attributeDeclaration = Helper::accessAttribute(parentObjectDeclaration.data(),
+        attributeDeclaration = Helper::accessAttribute(parentObjectDeclaration->abstractType(),
                                                        attrib->attribute->value, currentContext());
     }
 
     if ( ! attributeDeclaration || ! wasEncountered(attributeDeclaration) ) {
         // inject a new attribute into the class type
         DUContext* previousContext = currentContext();
         bool isAlreadyOpen = contextAlreayOpen(internal);
         if ( isAlreadyOpen ) {
             activateAlreadyOpenedContext(internal);
             visitVariableDeclaration<ClassMemberDeclaration>(
                 attrib->attribute, attrib, attributeDeclaration, element.type, AbortIfReopenMismatch
             );
             closeAlreadyOpenedContext(internal);
         }
         else {
             injectContext(internal.data());
 
             Declaration* dec = visitVariableDeclaration<ClassMemberDeclaration>(
                 attrib->attribute, attrib, attributeDeclaration, element.type, AbortIfReopenMismatch
             );
             if ( dec ) {
                 dec->setRange(RangeInRevision(internal->range().start, internal->range().start));
                 dec->setAutoDeclaration(true);
                 DUChainWriteLocker lock;
                 previousContext->createUse(dec->ownIndex(), editorFindRange(attrib, attrib));
             }
             else qCWarning(KDEV_PYTHON_DUCHAIN) << "No declaration created for " << attrib->attribute << "as parent is not a class";
 
             closeInjectedContext();
         }
     }
     else {
         DUChainWriteLocker lock;
         // the declaration is already there, just update the type
         if ( ! attributeDeclaration->type<FunctionType>() ) {
             auto newType = Helper::mergeTypes(attributeDeclaration->abstractType(), element.type);
             attributeDeclaration->setAbstractType(newType);
         }
     }
 }
 
 void tryUnpackType(AbstractType::Ptr sourceType, QVector<AbstractType::Ptr>& outTypes, int starred) {
     // Helper for assignToTuple() below.
     // If sourceType is a container that can be unpacked into outTypes, do so.
     if ( const auto indexed = sourceType.cast<IndexedContainer>() ) {
         int spare = indexed->typesCount() - outTypes.length();
         if ( spare < -1 or (starred == -1 and spare != 0) ) {
             return; // Wrong number of elements to unpack.
         }
         for ( int i_out = 0, i_in = 0; i_out < outTypes.length(); ++i_out ) {
             if ( i_out == starred ) { // PEP-3132. Made into list in assignToTuple().
                 for (; spare >= 0; --spare, ++i_in ) {
                     auto content = indexed->typeAt(i_in).abstractType();
                     outTypes[i_out] = Helper::mergeTypes(outTypes.at(i_out), content);
                 }
             } else {
                 auto content = indexed->typeAt(i_in).abstractType();
                 outTypes[i_out] = Helper::mergeTypes(outTypes.at(i_out), content);
                 ++i_in;
             }
         }
     } else {
         auto content = Helper::contentOfIterable(sourceType);
         if ( !Helper::isUsefulType(content) ) {
             return;
         }
         for (auto out = outTypes.begin(); out != outTypes.end(); ++out) {
             *out = Helper::mergeTypes(*out, content);
         }
     }
 }
 
 void DeclarationBuilder::assignToTuple(TupleAst* tuple, const SourceType& element) {
     int starred = -1;  // Index (if any) of PEP-3132 starred assignment.
     for (int ii = 0; ii < tuple->elements.length(); ++ii) {
          if (tuple->elements.at(ii)->astType == Ast::StarredAstType) {
             starred = ii;
             break;
         }
     }
 
     QVector<AbstractType::Ptr> outTypes(tuple->elements.length());
 
     if ( auto unsure = element.type.cast<UnsureType>() ) {
         FOREACH_FUNCTION ( const auto& type, unsure->types ) {
             tryUnpackType(type.abstractType(), outTypes, starred);
         }
     } else {
         tryUnpackType(element.type, outTypes, starred);
     }
 
     for (int ii = 0; ii < outTypes.length(); ++ii) {
         const auto sourceType = outTypes.at(ii);
         auto target = tuple->elements.at(ii);
         if ( target->astType == Ast::StarredAstType ) {
             DUChainReadLocker lock;
             auto listType = ExpressionVisitor::typeObjectForIntegralType<ListType>("list");
             lock.unlock();
             if (listType) {
                 listType->addContentType<Python::UnsureType>(sourceType);
                 assignToUnknown(static_cast<StarredAst*>(target)->value, listType);
             }
         } else {
             assignToUnknown(target, sourceType);
         }
     }
 }
 
 void DeclarationBuilder::assignToUnknown(ExpressionAst* target, const AbstractType::Ptr type) {
     auto source = SourceType{
         type,
         DeclarationPointer(),
         false
     };
     assignToUnknown(target, source);
 }
 
 void DeclarationBuilder::assignToUnknown(ExpressionAst* target, const DeclarationBuilder::SourceType& element) {
     // Must be a nicer way to do this.
     if ( target->astType == Ast::TupleAstType ) {
         // Assignments of the form "a, b = 1, 2" or "a, b = c"
         assignToTuple(static_cast<TupleAst*>(target), element);
     }
     else if ( target->astType == Ast::NameAstType ) {
         // Assignments of the form "a = 3"
         assignToName(static_cast<NameAst*>(target), element);
     }
     else if ( target->astType == Ast::SubscriptAstType ) {
         // Assignments of the form "a[0] = 3"
         assignToSubscript(static_cast<SubscriptAst*>(target), element);
     }
     else if ( target->astType == Ast::AttributeAstType ) {
         // Assignments of the form "a.b = 3"
         assignToAttribute(static_cast<AttributeAst*>(target), element);
     }
 }
 
 void DeclarationBuilder::visitAssignment(AssignmentAst* node)
 {
     AstDefaultVisitor::visitAssignment(node);
 
     ExpressionVisitor v(currentContext());
     v.visitNode(node->value);
     auto sourceType = SourceType{
         v.lastType(),
         DeclarationPointer(Helper::resolveAliasDeclaration(v.lastDeclaration().data())),
         v.isAlias()
     };
 
     foreach(ExpressionAst* target, node->targets) {
         assignToUnknown(target, sourceType);
     }
 }
 
 void DeclarationBuilder::visitClassDefinition( ClassDefinitionAst* node )
 {
     const CorrectionHelper::Recursion r(m_correctionHelper->enterClass(node->name->value));
 
     StructureType::Ptr type(new StructureType());
     
     DUChainWriteLocker lock;
     ClassDeclaration* dec = eventuallyReopenDeclaration<ClassDeclaration>(node->name, node->name, NoTypeRequired);
     lock.unlock();
     visitDecorators<ClassDeclaration>(node->decorators, dec);
     lock.lock();
     eventuallyAssignInternalContext();
     
     dec->setKind(KDevelop::Declaration::Type);
     dec->clearBaseClasses();
     dec->setClassType(ClassDeclarationData::Class);
 
     dec->setComment(getDocstring(node->body));
     
     // check whether this is a type container (list, dict, ...) or just a "normal" class
     if ( Helper::docstringContainsHint(dec, "TypeContainer") ) {
         ListType* container = nullptr;
         if ( Helper::docstringContainsHint(dec, "hasTypedKeys") ) {
             container = new MapType();
         }
         else {
             container = new ListType();
         }
         type = StructureType::Ptr(container);
     }
     if ( Helper::docstringContainsHint(dec, "IndexedTypeContainer") ) {
         IndexedContainer* container = new IndexedContainer();
         type = StructureType::Ptr(container);
     }
     
     lock.unlock();
     foreach ( ExpressionAst* c, node->baseClasses ) {
         // Iterate over all the base classes, and add them to the duchain.
         ExpressionVisitor v(currentContext());
         v.visitNode(c);
         if ( v.lastType() && v.lastType()->whichType() == AbstractType::TypeStructure ) {
             StructureType::Ptr baseClassType = v.lastType().cast<StructureType>();
             BaseClassInstance base;
             base.baseClass = baseClassType->indexed();
             base.access = KDevelop::Declaration::Public;
             lock.lock();
             dec->addBaseClass(base);
             lock.unlock();
         }
     }
     lock.lock();
     // every python class inherits from "object".
     // We use this to add all the __str__, __get__, ... methods.
     if ( dec->baseClassesSize() == 0 && node->name->value != "object" ) {
         DUChainWriteLocker wlock;
         ReferencedTopDUContext docContext = Helper::getDocumentationFileContext();
         if ( docContext ) {
             QList<Declaration*> object = docContext->findDeclarations(
                 QualifiedIdentifier("object")
             );
             if ( ! object.isEmpty() && object.first()->abstractType() ) {
                 Declaration* objDecl = object.first();
                 BaseClassInstance base;
                 base.baseClass = objDecl->abstractType()->indexed();
                 // this can be queried from autocompletion or elsewhere to hide the items, if required;
                 // of course, it's not private strictly speaking
                 base.access = KDevelop::Declaration::Private;
                 dec->addBaseClass(base);
             }
         }
     }
     
     type->setDeclaration(dec);
     dec->setType(type);
 
     openType(type);
     m_currentClassType = type;
 
     // needs to be done here, so the assignment of the internal context happens before visiting the body
     openContextForClassDefinition(node);
     dec->setInternalContext(currentContext());
 
     lock.unlock();
     foreach ( Ast* _node, node->body ) {
         AstDefaultVisitor::visitNode(_node);
     }
     lock.lock();
     
     closeContext();
     closeType();
     closeDeclaration();
 }
 
 template<typename T> void DeclarationBuilder::visitDecorators(QList< Python::ExpressionAst* > decorators, T* addTo) {
     foreach ( ExpressionAst* decorator, decorators ) {
         AstDefaultVisitor::visitNode(decorator);
         if ( decorator->astType == Ast::CallAstType ) {
             CallAst* call = static_cast<CallAst*>(decorator);
             Decorator d;
             if ( call->function->astType != Ast::NameAstType ) {
                 continue;
             }
             d.setName(*static_cast<NameAst*>(call->function)->identifier);
             foreach ( ExpressionAst* arg, call->arguments ) {
                 if ( arg->astType == Ast::NumberAstType ) {
                     d.setAdditionalInformation(QString::number(static_cast<NumberAst*>(arg)->value));
                 }
                 else if ( arg->astType == Ast::StringAstType ) {
                     d.setAdditionalInformation(static_cast<StringAst*>(arg)->value);
                 }
                 break; // we only need the first argument for documentation analysis
             }
             addTo->addDecorator(d);
         }
         else if ( decorator->astType == Ast::NameAstType ) {
             NameAst* name = static_cast<NameAst*>(decorator);
             Decorator d;
             d.setName(*(name->identifier));
             addTo->addDecorator(d);
         }
     }
 }
 
 void DeclarationBuilder::visitFunctionDefinition( FunctionDefinitionAst* node )
 {
     const CorrectionHelper::Recursion r(m_correctionHelper->enterFunction(node->name->value));
 
     // Search for an eventual containing class declaration;
     // if that exists, then this function is a member function
     DeclarationPointer eventualParentDeclaration(currentDeclaration());
     FunctionType::Ptr type(new FunctionType());
 
     DUChainWriteLocker lock;
     FunctionDeclaration* dec = eventuallyReopenDeclaration<FunctionDeclaration>(node->name, node->name,
                                                                                 FunctionDeclarationType);
 
     Q_ASSERT(dec->isFunctionDeclaration());
     
     // check for documentation
     dec->setComment(getDocstring(node->body));
     
     openType(type);
     dec->setInSymbolTable(false);
     dec->setType(type);
     
     lock.unlock();
     visitDecorators<FunctionDeclaration>(node->decorators, dec);
     visitFunctionArguments(node);
     
     lock.lock();
     const bool isStatic = Helper::findDecoratorByName<FunctionDeclaration>(dec, "staticmethod");
     const bool isClassMethod = Helper::findDecoratorByName<FunctionDeclaration>(dec, "classmethod");
     dec->setStatic(isStatic);
     
     // If this is a member function, set the type of the first argument (the "self") to be
     // an instance of the class.
     // this must be done here, because the type of self must be known when parsing the body
     if ( eventualParentDeclaration && currentType<FunctionType>()->arguments().length()
             && currentContext()->type() == DUContext::Class && ! isStatic )
     {
         if ( dec->vararg() != -1 ) {
             dec->setVararg(dec->vararg() - 1);
         }
         if ( dec->kwarg() != -1 ) {
             dec->setKwarg(dec->kwarg() - 1);
         }
     }
 
     lock.unlock();
     visitFunctionBody(node);
     lock.lock();
     
     closeDeclaration();
     eventuallyAssignInternalContext();
     
     closeType();
     
     // python methods don't have their parents attributes directly inside them
     if ( eventualParentDeclaration && eventualParentDeclaration->internalContext() && dec->internalContext() ) {
         dec->internalContext()->removeImportedParentContext(eventualParentDeclaration->internalContext());
     }
     
     {
         static IndexedString constructorName("__init__");
         DUChainWriteLocker lock(DUChain::lock());
         if ( dec->identifier().identifier() == constructorName ) {
             // the constructor returns an instance of the object,
             // nice to display it in tooltips etc.
             type->setReturnType(currentType<AbstractType>());
         }
         if ( ! type->returnType() ) {
             type->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
         }
         dec->setType(type);
     }
 
     if ( ! isStatic ) {
         DUContext* args = DUChainUtils::getArgumentContext(dec);
         if ( args )  {
             QVector<Declaration*> parameters = args->localDeclarations();
             static IndexedString newMethodName("__new__");
             static IndexedString selfArgumentName("self");
             static IndexedString clsArgumentName("cls");
             if ( currentContext()->type() == DUContext::Class && ! parameters.isEmpty() && ! isClassMethod ) {
                 QString description;
                 if ( dec->identifier().identifier() == newMethodName
                      && parameters[0]->identifier().identifier() != clsArgumentName )
                 {
                     description = i18n("First argument of __new__ method is not called cls, this is deprecated");
                 }
                 else if ( dec->identifier().identifier() != newMethodName
                           && parameters[0]->identifier().identifier() != selfArgumentName )
                 {
                     description = i18n("First argument of class method is not called self, this is deprecated");
                 }
                 if ( ! description.isEmpty() ) {
                     DUChainWriteLocker lock;
                     KDevelop::Problem *p = new KDevelop::Problem();
                     p->setDescription(description);
                     p->setFinalLocation(DocumentRange(currentlyParsedDocument(), parameters[0]->range().castToSimpleRange()));
                     p->setSource(KDevelop::IProblem::SemanticAnalysis);
                     p->setSeverity(KDevelop::IProblem::Warning);
                     ProblemPointer ptr(p);
                     topContext()->addProblem(ptr);
                 }
             }
             else if ( currentContext()->type() == DUContext::Class && parameters.isEmpty() ) {
                 DUChainWriteLocker lock;
                 KDevelop::Problem *p = new KDevelop::Problem();
                  // only mark first line
                 p->setFinalLocation(DocumentRange(currentlyParsedDocument(), KTextEditor::Range(node->startLine, node->startCol, node->startLine, 10000)));
                 p->setSource(KDevelop::IProblem::SemanticAnalysis);
                 p->setSeverity(KDevelop::IProblem::Warning);
                 p->setDescription(i18n("Non-static class method without arguments, must have at least one (self)"));
                 ProblemPointer ptr(p);
                 topContext()->addProblem(ptr);
             }
         }
     }
 
     if ( AbstractType::Ptr hint = m_correctionHelper->returnTypeHint() ) {
         type->setReturnType(hint);
         dec->setType<FunctionType>(type);
     }
     
     // check for (python3) function annotations
     if ( node->returns ) {
         lock.unlock();
         ExpressionVisitor v(currentContext());
         v.visitNode(node->returns);
         lock.lock();
         if ( v.lastType() && v.isAlias() ) {
             type->setReturnType(Helper::mergeTypes(type->returnType(), v.lastType()));
             qCDebug(KDEV_PYTHON_DUCHAIN) << "updated function return type to " << type->toString();
             dec->setType(type);
         }
         else if ( ! v.isAlias()) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "not updating function return type because expression is not a type object";
         }
     }
     
     lock.lock();
     dec->setInSymbolTable(true);
 }
 
 QString DeclarationBuilder::getDocstring(QList< Python::Ast* > body) const
 {
     if ( ! body.isEmpty() && body.first()->astType == Ast::ExpressionAstType 
             && static_cast<ExpressionAst*>(body.first())->value->astType == Ast::StringAstType )
     {
         // If the first statement in a function/class body is a string, then that is the docstring.
         StringAst* docstring = static_cast<StringAst*>(static_cast<ExpressionAst*>(body.first())->value);
         docstring->usedAsComment = true;
         return docstring->value.trimmed();
     }
     return QString();
 }
 
 void DeclarationBuilder::visitAssertion(AssertionAst* node)
 {
     adjustForTypecheck(node->condition, false);
     Python::AstDefaultVisitor::visitAssertion(node);
 }
 
 void DeclarationBuilder::visitIf(IfAst* node)
 {
     adjustForTypecheck(node->condition, true);
     Python::AstDefaultVisitor::visitIf(node);
 }
 
 void DeclarationBuilder::adjustForTypecheck(Python::ExpressionAst* check, bool useUnsure)
 {
     if ( ! check ) return;
     if ( check->astType == Ast::UnaryOperationAstType
          && static_cast<UnaryOperationAst*>(check)->type == Ast::UnaryOperatorNot )
     {
         // It could be something like " if not isinstance(foo, Bar): return None ".
         check = static_cast<UnaryOperationAst*>(check)->operand;
     }
     if ( check->astType == Ast::CallAstType ) {
         // Is this a call of the form "isinstance(foo, bar)"?
         CallAst* call = static_cast<CallAst*>(check);
         if ( ! call->function ) {
             return;
         }
         if ( call->function->astType != Ast::NameAstType ) {
             return;
         }
         const QString functionName = static_cast<Python::NameAst*>(call->function)->identifier->value;
         if ( functionName != QLatin1String("isinstance") ) {
             return;
         }
         if ( call->arguments.length() != 2 ) {
             return;
         }
         adjustExpressionsForTypecheck(call->arguments.at(0), call->arguments.at(1), useUnsure);
     }
     else if ( check->astType == Ast::CompareAstType ) {
         // Is this a call of the form "type(ainstance) == a"?
         CompareAst* compare = static_cast<CompareAst*>(check);
         if ( compare->operators.size() != 1 || compare->comparands.size() != 1 ) {
             return;
         }
         if ( compare->operators.first() != Ast::ComparisonOperatorEquals ) {
             return;
         }
         ExpressionAst* c1 = compare->comparands.first();
         ExpressionAst* c2 = compare->leftmostElement;
         if ( ! ( (c1->astType == Ast::CallAstType) ^ (c2->astType == Ast::CallAstType) ) ) {
             // Exactly one of the two must be a call. TODO: support adjusting function return types
             return;
         }
         CallAst* typecall = static_cast<CallAst*>(c1->astType == Ast::CallAstType ? c1 : c2);
         if ( ! typecall->function || typecall->function->astType != Ast::NameAstType || typecall->arguments.length() != 1 ) {
             return;
         }
         const QString functionName = static_cast<Python::NameAst*>(typecall->function)->identifier->value;
         if ( functionName != QLatin1String("type") ) {
             return;
         }
         adjustExpressionsForTypecheck(typecall->arguments.at(0), c1->astType == Ast::CallAstType ? c2 : c1, useUnsure);
     }
 }
 
 void DeclarationBuilder::adjustExpressionsForTypecheck(Python::ExpressionAst* adjustExpr, Python::ExpressionAst* from, bool useUnsure)
 {
     // Find types of the two arguments
     ExpressionVisitor first(currentContext());
     ExpressionVisitor second(currentContext());
     first.visitNode(adjustExpr);
     second.visitNode(from);
     AbstractType::Ptr hint;
     DeclarationPointer adjust;
     if ( second.isAlias() && second.lastType() ) {
         hint = second.lastType();
         adjust = first.lastDeclaration();
     }
     if ( ! adjust || adjust->isFunctionDeclaration() ) {
         // no declaration for the thing to verify, can't adjust it.
         return;
     }
     else if ( adjust->topContext() == Helper::getDocumentationFileContext() ) {
         // do not motify types in the doc context
         return;
     }
     DUChainWriteLocker lock;
     if ( useUnsure ) {
         adjust->setAbstractType(Helper::mergeTypes(adjust->abstractType(), hint));
     }
     else {
         adjust->setAbstractType(hint);
     }
 }
 
 void DeclarationBuilder::visitReturn(ReturnAst* node)
 {
     // Find the type of the object being "return"ed
     ExpressionVisitor v(currentContext());
     v.visitNode(node->value);
     
     if ( node->value ) {
         if ( ! hasCurrentType() ) {
             DUChainWriteLocker lock;
             KDevelop::Problem *p = new KDevelop::Problem();
             p->setFinalLocation(DocumentRange(currentlyParsedDocument(), node->range())); // only mark first line
             p->setSource(KDevelop::IProblem::SemanticAnalysis);
             p->setDescription(i18n("Return statement not within function declaration"));
             ProblemPointer ptr(p);
             topContext()->addProblem(ptr);
         }
         else {
             TypePtr<FunctionType> t = currentType<FunctionType>();
             AbstractType::Ptr encountered = v.lastType();
             DUChainWriteLocker lock;
             if ( t ) {
                 // Update the containing function's return type
                 t->setReturnType(Helper::mergeTypes(t->returnType(), encountered));
             }
         }
     }
     DeclarationBuilderBase::visitReturn(node);
 }
 
 void DeclarationBuilder::visitArguments( ArgumentsAst* node )
 {
     if ( ! currentDeclaration() || ! currentDeclaration()->isFunctionDeclaration() ) {
         return;
     }
     FunctionDeclaration* workingOnDeclaration = static_cast<FunctionDeclaration*>(Helper::resolveAliasDeclaration(currentDeclaration()));
     workingOnDeclaration->clearDefaultParameters();
     const bool isClassMethod = Helper::findDecoratorByName<FunctionDeclaration>(workingOnDeclaration, "classmethod");
     if ( ! hasCurrentType() || ! currentType<FunctionType>() ) {
         return;
     }
     FunctionType::Ptr type = currentType<FunctionType>();
     bool isFirst = true;
     int defaultParametersCount = node->defaultValues.length();
     int parametersCount = node->arguments.length();
     int firstDefaultParameterOffset = parametersCount - defaultParametersCount;
     int currentIndex = 0;
     qCDebug(KDEV_PYTHON_DUCHAIN) << "arguments:" << node->arguments.size();
     foreach ( ArgAst* arg, node->arguments + node->kwonlyargs ) {
         // Iterate over all the function's arguments, create declarations, and add the arguments
         // to the functions FunctionType.
         currentIndex += 1;
 
         if ( ! arg->argumentName ) {
             continue;
         }
 
         qCDebug(KDEV_PYTHON_DUCHAIN) << "visiting argument:" << arg->argumentName->value;
 
         // Create a variable declaration for the parameter, to be used in the function body.
         Declaration* paramDeclaration = nullptr;
         if ( currentIndex == 1 && isClassMethod ) {
             DUChainWriteLocker lock;
             AliasDeclaration* decl = eventuallyReopenDeclaration<AliasDeclaration>(arg->argumentName,
                                                                                    arg, AliasDeclarationType);
             if ( m_currentClassType ) {
                 qCDebug(KDEV_PYTHON_DUCHAIN) << "setting declaration:" << m_currentClassType->declaration(topContext())->toString();
                 decl->setAliasedDeclaration(m_currentClassType->declaration(currentContext()->topContext()));
             }
             paramDeclaration = decl;
         }
         else {
             paramDeclaration = visitVariableDeclaration<Declaration>(arg->argumentName);
         }
         if ( ! paramDeclaration ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "could not create parameter declaration!";
             continue;
         }
 
         AbstractType::Ptr argumentType(new IntegralType(IntegralType::TypeMixed));
         if ( arg->annotation ) {
             ExpressionVisitor v(currentContext());
             v.visitNode(arg->annotation);
             if ( v.lastType() && v.isAlias() ) {
                 DUChainWriteLocker lock;
                 argumentType = Helper::mergeTypes(paramDeclaration->abstractType(), v.lastType());
             }
         }
         else if ( currentIndex > firstDefaultParameterOffset && currentIndex <= node->arguments.size() ) {
             // Handle arguments with default values, like def foo(bar = 3): pass
             // Find type of given default value, and assign it to the declaration
             ExpressionVisitor v(currentContext());
             v.visitNode(node->defaultValues.at(currentIndex - firstDefaultParameterOffset - 1));
             if ( v.lastType() ) {
                 argumentType = v.lastType();
             }
             // TODO add the real expression from the document here as default value
             workingOnDeclaration->addDefaultParameter(IndexedString("..."));
         }
 
         qCDebug(KDEV_PYTHON_DUCHAIN) << "is first:" << isFirst << hasCurrentDeclaration() << currentDeclaration();
         if ( isFirst && hasCurrentDeclaration() && currentContext() && currentContext()->parentContext() ) {
             DUChainReadLocker lock;
             if ( currentContext()->parentContext()->type() == DUContext::Class ) {
                 argumentType = m_currentClassType.cast<AbstractType>();
                 isFirst = false;
             }
         }
 
         DUChainWriteLocker lock;
         paramDeclaration->setAbstractType(Helper::mergeTypes(paramDeclaration->abstractType(), argumentType));
         type->addArgument(argumentType);
         if ( argumentType ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "creating argument with type" << argumentType->toString();
         }
     }
     // Handle *args, **kwargs, and assign them a list / dictionary type.
     if ( node->vararg ) {
         // inject the vararg at the correct place
         int atIndex = 0;
         int useIndex = -1;
         foreach ( ArgAst* arg, node->arguments ) {
             if ( node->vararg && workingOnDeclaration->vararg() == -1 && node->vararg->appearsBefore(arg) ) {
                 useIndex = atIndex;
             }
             atIndex += 1;
         }
         if ( useIndex == -1 ) {
             // if the vararg does not appear in the middle of the params, place it at the end.
             // this is new in python3, you can do like def fun(a, b, *c, z): pass
             useIndex = type->arguments().size();
         }
         DUChainReadLocker lock;
         IndexedContainer::Ptr tupleType = ExpressionVisitor::typeObjectForIntegralType<IndexedContainer>("tuple");
         lock.unlock();
         if ( tupleType ) {
             visitVariableDeclaration<Declaration>(node->vararg->argumentName, 0, tupleType.cast<AbstractType>());
             workingOnDeclaration->setVararg(atIndex);
             type->addArgument(tupleType.cast<AbstractType>(), useIndex);
         }
     }
 
     if ( node->kwarg ) {
         DUChainReadLocker lock;
         AbstractType::Ptr stringType = ExpressionVisitor::typeObjectForIntegralType<AbstractType>("str");
         auto dictType = ExpressionVisitor::typeObjectForIntegralType<MapType>("dict");
         lock.unlock();
         if ( dictType && stringType ) {
             dictType->addKeyType<Python::UnsureType>(stringType);
             visitVariableDeclaration<Declaration>(node->kwarg->argumentName, 0, dictType.cast<AbstractType>());
             type->addArgument(dictType.cast<AbstractType>());
             workingOnDeclaration->setKwarg(type->arguments().size() - 1);
         }
     }
 }
 
 void DeclarationBuilder::visitString(StringAst* node) {
     if ( node->parent && node->parent->astType == Ast::ExpressionAstType ) {
         m_lastComment = node;
     }
     DeclarationBuilderBase::visitString(node);
 }
 
 void DeclarationBuilder::visitNode(Ast* node) {
     DeclarationBuilderBase::visitNode(node);
     if ( node && node->astType >= Ast::StatementAstType && node->astType <= Ast::LastStatementType) {
         m_lastComment = nullptr;
     }
 }
 
 void DeclarationBuilder::visitGlobal(GlobalAst* node)
 {
     TopDUContext* top = topContext();
     foreach ( Identifier *id, node->names ) {
         QualifiedIdentifier qid = identifierForNode(id);
         DUChainWriteLocker lock;
         QList< Declaration* > existing = top->findLocalDeclarations(qid.first());
         if ( ! existing.empty() ) {
             AliasDeclaration* ndec = openDeclaration<AliasDeclaration>(id, node);
             ndec->setAliasedDeclaration(existing.first());
             closeDeclaration();
         }
         else {
             injectContext(top);
             Declaration* dec = visitVariableDeclaration<Declaration>(id);
             dec->setRange(editorFindRange(id, id));
             dec->setAutoDeclaration(true);
             closeContext();
             AliasDeclaration* ndec = openDeclaration<AliasDeclaration>(id, node);
             ndec->setAliasedDeclaration(dec);
             closeDeclaration();
         }
     }
 }
 
 }
 
 
diff --git a/duchain/expressionvisitor.cpp b/duchain/expressionvisitor.cpp
index 7ad603d3..1ddcafe6 100644
--- a/duchain/expressionvisitor.cpp
+++ b/duchain/expressionvisitor.cpp
@@ -1,747 +1,744 @@
 /*****************************************************************************
  * This file is part of KDevelop                                             *
  * Copyright 2010 Miquel Canes Gonzalez <miquelcanes@gmail.com>              *
  * Copyright 2011-2013 by Sven Brauch <svenbrauch@googlemail.com>            *
  *                                                                           *
  * This program is free software; you can redistribute it and/or             *
  * modify it under the terms of the GNU General Public License as            *
  * published by the Free Software Foundation; either version 2 of            *
  * the License, or (at your option) any later version.                       *
  *                                                                           *
  * This program is distributed in the hope that it will be useful,           *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************
  */
 
 #include "expressionvisitor.h"
 #include "types/indexedcontainer.h"
 #include "declarations/functiondeclaration.h"
 #include "pythonduchainexport.h"
 #include "pythoneditorintegrator.h"
 #include "helpers.h"
 
 #include <language/duchain/types/containertypes.h>
 #include <language/duchain/types/unsuretype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/typeregister.h>
 #include <language/duchain/types/typesystemdata.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/functiondeclaration.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/ducontext.h>
 
 #include <QDebug>
 #include "duchaindebug.h"
 
 #include <KLocalizedString>
 
 #include <functional>
 
 using namespace KDevelop;
 using namespace Python;
 using namespace KTextEditor;
 
 namespace Python {
 
 QHash<NameConstantAst::NameConstantTypes, KDevelop::AbstractType::Ptr> ExpressionVisitor::m_defaultTypes;
 
 AbstractType::Ptr ExpressionVisitor::encounterPreprocess(AbstractType::Ptr type)
 {
     return Helper::resolveAliasType(type);
 }
 
 ExpressionVisitor::ExpressionVisitor(const DUContext* ctx)
     : DynamicLanguageExpressionVisitor(ctx)
 {
     ENSURE_CHAIN_NOT_LOCKED
     if ( m_defaultTypes.isEmpty() ) {
         m_defaultTypes.insert(NameConstantAst::True, AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean)));
         m_defaultTypes.insert(NameConstantAst::False, AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean)));
         m_defaultTypes.insert(NameConstantAst::None, AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
     }
     Q_ASSERT(context());
     Q_ASSERT(context()->topContext());
 }
 
 ExpressionVisitor::ExpressionVisitor(ExpressionVisitor* parent, const DUContext* overrideContext)
     : DynamicLanguageExpressionVisitor(parent)
     , m_forceGlobalSearching(parent->m_forceGlobalSearching)
     , m_reportUnknownNames(parent->m_reportUnknownNames)
     , m_scanUntilCursor(parent->m_scanUntilCursor)
 {
     ENSURE_CHAIN_NOT_LOCKED
     if ( overrideContext ) {
         m_context = overrideContext;
     }
     Q_ASSERT(context());
 }
 
 void ExpressionVisitor::encounter(AbstractType::Ptr type, DeclarationPointer declaration, bool alias)
 {
     setLastIsAlias(alias);
     DynamicLanguageExpressionVisitor::encounter(type, declaration);
 }
 
 void ExpressionVisitor::visitAttribute(AttributeAst* node)
 {
     ExpressionAst* accessingAttributeOf = node->value;
 
     ExpressionVisitor v(this);
     v.visitNode(accessingAttributeOf);
     AbstractType::Ptr accessedType = v.lastType();
     QList<StructureType::Ptr> accessingAttributeOfType = Helper::filterType<StructureType>(accessedType,
         [](AbstractType::Ptr type) {
             auto resolved = Helper::resolveAliasType(type);
             return resolved && resolved->whichType() == AbstractType::TypeStructure;
         },
         [](AbstractType::Ptr type) {
             return Helper::resolveAliasType(type).cast<StructureType>();
         }
     );
 
     // Step 1: Find all matching declarations which are made inside the type of which the accessed object is.
     // Like, for A.B.C where B is an instance of foo, when processing C, find all properties of foo which are called C.
     bool haveOneUsefulType = false;
     Declaration* foundDeclaration = nullptr;
     DUChainReadLocker lock;
     foreach ( StructureType::Ptr current, accessingAttributeOfType ) {
         if ( Helper::isUsefulType(current.cast<AbstractType>()) ) {
             haveOneUsefulType = true;
         }
-        foundDeclaration = Helper::accessAttribute(current->declaration(context()->topContext()),
-                                                   node->attribute->value, context());
+        foundDeclaration = Helper::accessAttribute(current, node->attribute->value, context());
         if ( foundDeclaration ) {
             break;
         }
     }
     if ( ! haveOneUsefulType ) {
         setConfident(false);
     }
 
     // Step 2: Construct the type of the declaration which was found.
     if ( foundDeclaration ) {
         auto d = Helper::resolveAliasDeclaration(foundDeclaration);
         if ( ! d ) {
             return encounterUnknown();
         }
         bool isAlias =     dynamic_cast<AliasDeclaration*>(foundDeclaration) || d->isFunctionDeclaration()
                         || dynamic_cast<ClassDeclaration*>(d);
         encounter(foundDeclaration->abstractType(), DeclarationPointer(foundDeclaration));
         setLastIsAlias(isAlias);
     }
     else {
         return encounterUnknown();
     }
 }
 
 void ExpressionVisitor::visitCall(CallAst* node)
 {
     foreach ( ExpressionAst* c, node->arguments ) {
         AstDefaultVisitor::visitNode(c);
     }
     
     ExpressionVisitor v(this);
     v.visitNode(node->function);
     Declaration* actualDeclaration = 0;
     FunctionType::Ptr unidentifiedFunctionType;
     if ( ! v.m_isAlias && v.lastType() && v.lastType()->whichType() == AbstractType::TypeFunction ) {
         unidentifiedFunctionType = v.lastType().cast<FunctionType>();
     }
     else if ( ! v.m_isAlias && v.lastType() && v.lastType()->whichType() == AbstractType::TypeStructure ) {
         // use __call__
         DUChainReadLocker lock;
         auto c = v.lastType().cast<StructureType>()->internalContext(topContext());
         if ( c ) {
             auto decls = c->findDeclarations(QualifiedIdentifier("__call__"));
             if ( ! decls.isEmpty() ) {
                 auto decl = dynamic_cast<FunctionDeclaration*>(decls.first());
                 if ( decl ) {
                     unidentifiedFunctionType = decl->abstractType().cast<FunctionType>();
                 }
             }
         }
     }
     else {
         actualDeclaration = v.lastDeclaration().data();
     }
     
     if ( unidentifiedFunctionType ) {
         encounter(unidentifiedFunctionType->returnType());
         return;
     }
     else if ( !actualDeclaration ) {
         setConfident(false);
         return encounterUnknown();
     }
 
     DUChainReadLocker lock;
     actualDeclaration = Helper::resolveAliasDeclaration(actualDeclaration);
     ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration*>(actualDeclaration);
     QPair<FunctionDeclarationPointer, bool> d = Helper::functionDeclarationForCalledDeclaration(
                                                 DeclarationPointer(actualDeclaration));
     FunctionDeclaration* funcDecl = d.first.data();
     bool isConstructor = d.second;
     lock.unlock();
 
     if ( funcDecl && funcDecl->type<FunctionType>() ) {
         // try to deduce type from a decorator
         checkForDecorators(node, funcDecl, classDecl, isConstructor);
     }
     else if ( classDecl ) {
         return encounter(classDecl->abstractType(), DeclarationPointer(classDecl));
     }
     else {
         if ( actualDeclaration ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Declaraton is not a class or function declaration";
         }
         return encounterUnknown();
     }
 }
 
 void ExpressionVisitor::checkForDecorators(CallAst* node, FunctionDeclaration* funcDecl, ClassDeclaration* classDecl, bool isConstructor)
 {
     AbstractType::Ptr type;
     Declaration* useDeclaration = nullptr;
     if ( isConstructor && classDecl ) {
         type = classDecl->abstractType();
         useDeclaration = classDecl;
     }
     else {
         type = funcDecl->type<FunctionType>()->returnType();
         useDeclaration = funcDecl;
     }
 
     auto listOfTuples = [&](AbstractType::Ptr key, AbstractType::Ptr value) {
         auto newType = typeObjectForIntegralType<ListType>("list");
         IndexedContainer::Ptr newContents = typeObjectForIntegralType<IndexedContainer>("tuple");
         if ( ! newType || ! newContents ) {
             return AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
         }
         if ( ! key ) {
             key = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
         }
         if ( ! value ) {
             value = AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed));
         }
         newContents->addEntry(key);
         newContents->addEntry(value);
         newType->addContentType<Python::UnsureType>(AbstractType::Ptr::staticCast(newContents));
         AbstractType::Ptr resultingType = AbstractType::Ptr::staticCast(newType);
         return resultingType;
     };
 
     QHash< QString, std::function<bool(QStringList, QString)> > knownDecoratorHints;
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Got function declaration with decorators, checking for list content type...";
     knownDecoratorHints["getsType"] = [&](QStringList /*arguments*/, QString /*currentHint*/) {
         if ( node->function->astType != Ast::AttributeAstType ) {
             return false;
         }
         ExpressionVisitor baseTypeVisitor(this);
         // when calling foo.bar[3].baz.iteritems(), find the type of "foo.bar[3].baz"
         baseTypeVisitor.visitNode(static_cast<AttributeAst*>(node->function)->value);
         if ( auto t = baseTypeVisitor.lastType().cast<ListType>() ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Found container, using type";
             AbstractType::Ptr newType = t->contentType().abstractType();
             encounter(newType, DeclarationPointer(useDeclaration));
             return true;
         }
         return false;
     };
 
     knownDecoratorHints["getsList"] = [&](QStringList /*arguments*/, QString currentHint) {
         if ( node->function->astType != Ast::AttributeAstType ) {
             return false;
         }
         ExpressionVisitor baseTypeVisitor(this);
         // when calling foo.bar[3].baz.iteritems(), find the type of "foo.bar[3].baz"
         baseTypeVisitor.visitNode(static_cast<AttributeAst*>(node->function)->value);
         DUChainWriteLocker lock;
         if ( auto t = baseTypeVisitor.lastType().cast<ListType>() ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Got container:" << t->toString();
             auto newType = typeObjectForIntegralType<ListType>("list");
             if ( ! newType ) {
                 return false;
             }
             AbstractType::Ptr contentType;
             if ( currentHint == "getsList" ) {
                 contentType = t->contentType().abstractType();
             }
             else if ( auto map = MapType::Ptr::dynamicCast(t) ) {
                 contentType = map->keyType().abstractType();
             }
             newType->addContentType<Python::UnsureType>(contentType);
             AbstractType::Ptr resultingType = newType.cast<AbstractType>();
             encounter(resultingType, DeclarationPointer(useDeclaration));
             return true;
         }
         return false;
     };
     knownDecoratorHints["getListOfKeys"] = knownDecoratorHints["getsList"];
 
     knownDecoratorHints["enumerate"] = [&](QStringList /*arguments*/, QString /*currentHint*/) {
         if ( node->function->astType != Ast::NameAstType || node->arguments.size() < 1 ) {
             return false;
         }
         ExpressionVisitor enumeratedTypeVisitor(this);
         enumeratedTypeVisitor.visitNode(node->arguments.first());
 
         DUChainWriteLocker lock;
         auto intType = typeObjectForIntegralType<AbstractType>("int");
         auto enumerated = enumeratedTypeVisitor.lastType();
         auto result = listOfTuples(intType, Helper::contentOfIterable(enumerated));
         encounter(result, DeclarationPointer(useDeclaration));
         return true;
     };
 
     knownDecoratorHints["getsListOfBoth"] = [&](QStringList /*arguments*/, QString /*currentHint*/) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Got getsListOfBoth decorator, checking container";
         if ( node->function->astType != Ast::AttributeAstType ) {
             return false;
         }
         ExpressionVisitor baseTypeVisitor(this);
         // when calling foo.bar[3].baz.iteritems(), find the type of "foo.bar[3].baz"
         baseTypeVisitor.visitNode(static_cast<AttributeAst*>(node->function)->value);
         DUChainWriteLocker lock;
         if ( auto t = baseTypeVisitor.lastType().cast<MapType>() ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Got container:" << t->toString();
             auto resultingType = listOfTuples(t->keyType().abstractType(), t->contentType().abstractType());
             encounter(resultingType, DeclarationPointer(useDeclaration));
             return true;
         }
         return false;
     };
 
     knownDecoratorHints["returnContentEqualsContentOf"] = [&](QStringList arguments, QString /*currentHint*/) {
         int argNum = ! arguments.isEmpty() ? arguments.at(0).toInt() : 0;
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Found argument dependent decorator, checking argument type" << argNum;
         if ( argNum >= node->arguments.length() ) {
             return false;
         }
         ExpressionAst* relevantArgument = node->arguments.at(argNum);
         ExpressionVisitor v(this);
         v.visitNode(relevantArgument);
         if ( ! v.lastType() ) {
             return false;
         }
         ListType::Ptr realTarget;
         if ( auto target = ListType::Ptr::dynamicCast(type) ) {
             realTarget = target;
         }
         if ( auto source = ListType::Ptr::dynamicCast(v.lastType()) ) {
             if ( ! realTarget ) {
                 // if the function does not force a return type, just copy the source (like for reversed())
                 realTarget = source;
             }
             auto newType = ListType::Ptr::staticCast(AbstractType::Ptr(realTarget->clone()));
             Q_ASSERT(newType);
             newType->addContentType<Python::UnsureType>(source->contentType().abstractType());
             encounter(AbstractType::Ptr::staticCast(newType), DeclarationPointer(useDeclaration));
             return true;
         }
         return false;
     };
 
     foreach ( const QString& currentHint, knownDecoratorHints.keys() ) {
         QStringList arguments;
         if ( ! Helper::docstringContainsHint(funcDecl, currentHint, &arguments) ) {
             continue;
         }
         // If the hint word appears in the docstring, run the evaluation function.
         if ( knownDecoratorHints[currentHint](arguments, currentHint) ) {
             // We indeed found something, so we're done.
             return;
         }
     }
 
     // if none of the above decorator-finding methods worked, just use the ordinary return type.
     return encounter(type, DeclarationPointer(useDeclaration));
 }
 
 void ExpressionVisitor::visitSubscript(SubscriptAst* node)
 {
     AstDefaultVisitor::visitNode(node->value);
     if ( node->slice && node->slice->astType == Ast::IndexAstType ) {
         DUChainReadLocker lock;
         auto indexedTypes = Helper::filterType<IndexedContainer>(lastType(), [](AbstractType::Ptr toFilter) {
             return toFilter.cast<IndexedContainer>();
         });
         for ( IndexedContainer::Ptr indexed: indexedTypes ) {
             // TODO This loop currently only uses the first result, it could construct
             // an unsure from all the matches.
             IndexAst* sliceIndexAst = static_cast<IndexAst*>(node->slice);
             NumberAst* number = nullptr;
             bool invert = false;
             if ( sliceIndexAst->value && sliceIndexAst->value->astType == Ast::UnaryOperationAstType ) {
                 // might be -3
                 UnaryOperationAst* unary = static_cast<UnaryOperationAst*>(sliceIndexAst->value);
                 if ( unary->type == Ast::UnaryOperatorSub && unary->operand->astType == Ast::NumberAstType ) {
                     number = static_cast<NumberAst*>(unary->operand);
                     invert = true;
                 }
             }
             else if ( sliceIndexAst->value->astType == Ast::NumberAstType ) {
                 number = static_cast<NumberAst*>(sliceIndexAst->value);
             }
             if ( number ) {
                 int sliceIndex = number->value * ( invert ? -1 : 1 );
                 if ( sliceIndex < 0 && sliceIndex + indexed->typesCount() > 0 ) {
                     sliceIndex += indexed->typesCount();
                 }
                 if ( sliceIndex < indexed->typesCount() && sliceIndex >= 0 ) {
                     return encounter(indexed->typeAt(sliceIndex).abstractType());
                 }
             }
             // the exact index is unknown, use unsure
             return encounter(indexed->asUnsureType().cast<AbstractType>());
         }
         auto variableTypes = Helper::filterType<ListType>(lastType(), [](AbstractType::Ptr toFilter) {
             return toFilter.cast<ListType>();
         });
         if ( ! variableTypes.isEmpty() ) {
             AbstractType::Ptr result(new IntegralType(IntegralType::TypeMixed));
             for ( auto variable: variableTypes ) {
                 result = Helper::mergeTypes(result, variable->contentType().abstractType());
             }
             return encounter(result);
         }
     }
 
     // If that does not work and we have a slice like [3:5], guess it will remain the same type.
     // That is an approximation we have to make now, should optimally be corrected later.
     // The reason is that we'd need to parse decorators from the __getitem__ method to support
     // list/dict/etc properly otherwise, which requires a bit of refactoring first. TODO do this
     if ( node->slice && node->slice->astType != Ast::IndexAstType ) {
         return;
     }
 
     // Otherwise, try to use __getitem__.
-    ExpressionVisitor v(context());
-    v.visitNode(node->value);
     DUChainReadLocker lock;
-    Declaration* function = Helper::accessAttribute(v.lastDeclaration().data(), "__getitem__", context());
+    Declaration* function = Helper::accessAttribute(lastType(), "__getitem__", context());
     if ( function && function->isFunctionDeclaration() ) {
         if ( FunctionType::Ptr functionType = function->type<FunctionType>() ) {
             return encounter(functionType->returnType());
         }
     }
 
     // Otherwise, give up
     return encounterUnknown();
 }
 
 void ExpressionVisitor::visitList(ListAst* node)
 {
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<ListType>("list");
     lock.unlock();
     ExpressionVisitor contentVisitor(this);
     if ( type ) {
         foreach ( ExpressionAst* content, node->elements ) {
             contentVisitor.visitNode(content);
             type->addContentType<Python::UnsureType>(contentVisitor.lastType());
         }
     }
     else {
         encounterUnknown();
         qCWarning(KDEV_PYTHON_DUCHAIN) << " [ !!! ] did not get a typetrack container object when expecting one! Fix code / setup.";
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitDictionaryComprehension(DictionaryComprehensionAst* node)
 {
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<MapType>("dict");
     if ( type ) {
         DUContext* comprehensionContext = context()->findContextAt(CursorInRevision(node->startLine, node->startCol));
         lock.unlock();
         Q_ASSERT(comprehensionContext);
         DUContext* ctx = m_forceGlobalSearching ? context()->topContext() : comprehensionContext;
         ExpressionVisitor v(this, ctx);
         v.visitNode(node->value);
         if ( v.lastType() ) {
             type->addContentType<Python::UnsureType>(v.lastType());
         }
         ExpressionVisitor k(this, ctx);
         k.visitNode(node->key);
         if ( k.lastType() ) {
             type->addKeyType<Python::UnsureType>(k.lastType());
         }
     }
     else {
         return encounterUnknown();
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitSetComprehension(SetComprehensionAst* node)
 {
     Python::AstDefaultVisitor::visitSetComprehension(node);
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<ListType>("set");
     if ( type ) {
         DUContext* comprehensionContext = context()->findContextAt(CursorInRevision(node->startLine, node->startCol), true);
         lock.unlock();
         auto ctx = m_forceGlobalSearching ? context()->topContext() : comprehensionContext;
         ExpressionVisitor v(this, ctx);
         v.visitNode(node->element);
         if ( v.lastType() ) {
             type->addContentType<Python::UnsureType>(v.lastType());
         }
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitListComprehension(ListComprehensionAst* node)
 {
     AstDefaultVisitor::visitListComprehension(node);
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<ListType>("list");
     if ( type && ! m_forceGlobalSearching ) { // TODO fixme
         DUContext* comprehensionContext = context()->findContextAt(CursorInRevision(node->startLine, node->startCol), true);
         lock.unlock();
         ExpressionVisitor v(this, comprehensionContext);
         Q_ASSERT(comprehensionContext);
         v.visitNode(node->element);
         if ( v.lastType() ) {
             type->addContentType<Python::UnsureType>(v.lastType());
         }
     }
     else {
         return encounterUnknown();
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitTuple(TupleAst* node) {
     DUChainReadLocker lock;
     IndexedContainer::Ptr type = typeObjectForIntegralType<IndexedContainer>("tuple");
     if ( type ) {
         lock.unlock();
         foreach ( ExpressionAst* expr, node->elements ) {
             ExpressionVisitor v(this);
             v.visitNode(expr);
             if ( v.lastType() ) {
                 type->addEntry(v.lastType());
             }
             else {
                 type->addEntry(AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed)));
             }
         }
         encounter(AbstractType::Ptr::staticCast(type));
     }
     else {
         qCWarning(KDEV_PYTHON_DUCHAIN) << "tuple type object is not available";
         return encounterUnknown();
     }
 }
 
 void ExpressionVisitor::visitIfExpression(IfExpressionAst* node)
 {
     AstDefaultVisitor::visitIfExpression(node);
     if ( node->body && node->orelse ) {
         ExpressionVisitor v(this);
         v.visitNode(node->body);
         AbstractType::Ptr first = v.lastType();
         v.visitNode(node->orelse);
         AbstractType::Ptr second = v.lastType();
         encounter(Helper::mergeTypes(first, second));
     }
 }
 
 void ExpressionVisitor::visitSet(SetAst* node)
 {
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<ListType>("set");
     lock.unlock();
     ExpressionVisitor contentVisitor(this);
     if ( type ) {
         foreach ( ExpressionAst* content, node->elements ) {
             contentVisitor.visitNode(content);
             type->addContentType<Python::UnsureType>(contentVisitor.lastType());
         }
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitDict(DictAst* node)
 {
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<MapType>("dict");
     lock.unlock();
     ExpressionVisitor contentVisitor(this);
     ExpressionVisitor keyVisitor(this);
     if ( type ) {
         foreach ( ExpressionAst* content, node->values ) {
             contentVisitor.visitNode(content);
             type->addContentType<Python::UnsureType>(contentVisitor.lastType());
         }
         foreach ( ExpressionAst* key, node->keys ) {
             keyVisitor.visitNode(key);
             type->addKeyType<Python::UnsureType>(keyVisitor.lastType());
         }
     }
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitNumber(Python::NumberAst* number)
 {
     AbstractType::Ptr type;
     DUChainReadLocker lock;
     if ( number->isInt ) {
         type = typeObjectForIntegralType<AbstractType>("int");
     }
     else {
         type = typeObjectForIntegralType<AbstractType>("float");
     }
     encounter(type);
 }
 
 void ExpressionVisitor::visitString(Python::StringAst* )
 {
     DUChainReadLocker lock;
     StructureType::Ptr type = typeObjectForIntegralType<StructureType>("str");
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 void ExpressionVisitor::visitBytes(Python::BytesAst* ) {
     DUChainReadLocker lock;
     auto type = typeObjectForIntegralType<StructureType>("bytes");
     encounter(AbstractType::Ptr::staticCast(type));
 }
 
 RangeInRevision nodeRange(Python::Ast* node)
 {
     return RangeInRevision(node->startLine, node->startCol, node->endLine,node->endCol);
 }
 
 void ExpressionVisitor::addUnknownName(const QString& name)
 {
     if ( m_parentVisitor ) {
         static_cast<ExpressionVisitor*>(m_parentVisitor)->addUnknownName(name);
     }
     else if ( ! m_unknownNames.contains(name) ) {
         m_unknownNames.insert(name);
     }
 }
 
 void ExpressionVisitor::visitNameConstant(NameConstantAst* node)
 {
     // handles "True", "False", "None"
     auto defId = m_defaultTypes.constFind(node->value);
     if ( defId != m_defaultTypes.constEnd() ) {
         return encounter(*defId);
     }
 }
 
 void ExpressionVisitor::visitName(Python::NameAst* node)
 {
     RangeInRevision range;
     if ( m_scanUntilCursor.isValid() ) {
         range = RangeInRevision(CursorInRevision(0, 0), m_scanUntilCursor);
     }
     else if ( m_forceGlobalSearching ) {
         range = RangeInRevision::invalid();
     }
     else {
         range = RangeInRevision(0, 0, node->endLine, node->endCol);
     }
     DUChainReadLocker lock;
     Declaration* d = Helper::declarationForName(QualifiedIdentifier(node->identifier->value),
                                                 range, DUChainPointer<const DUContext>(context()));
 
     if ( d ) {
         bool isAlias = dynamic_cast<AliasDeclaration*>(d) || d->isFunctionDeclaration() || dynamic_cast<ClassDeclaration*>(d);
         return encounter(d->abstractType(), DeclarationPointer(d), isAlias);
     }
     else {
         if ( m_reportUnknownNames ) {
             addUnknownName(node->identifier->value);
         }
         return encounterUnknown();
     }
 }
 
 void ExpressionVisitor::visitCompare(CompareAst* node)
 {
     Python::AstDefaultVisitor::visitCompare(node);
     encounter(AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean)));
 }
 
 AbstractType::Ptr ExpressionVisitor::fromBinaryOperator(AbstractType::Ptr lhs, AbstractType::Ptr rhs, const QString& op) {
     DUChainReadLocker lock;
     auto operatorReturnType = [&op, this](const AbstractType::Ptr& p) {
         StructureType::Ptr type = p.cast<StructureType>();
         if ( ! type ) {
             return AbstractType::Ptr();
         }
-        Declaration* func = Helper::accessAttribute(type->declaration(context()->topContext()), op, context());
+        Declaration* func = Helper::accessAttribute(type, op, context());
         if ( ! func ) {
             return AbstractType::Ptr();
         }
         auto operatorFunctionType = func->type<FunctionType>();
         DUChainReadLocker lock;
         auto context = Helper::getDocumentationFileContext();
         if ( context ) {
             auto object_decl = context->findDeclarations(QualifiedIdentifier("object"));
             if ( ! object_decl.isEmpty() && object_decl.first()->internalContext() == func->context() ) {
                 // if the operator is only declared in object(), do not include its type (which is void).
                 return AbstractType::Ptr();
             }
         }
         return operatorFunctionType ? operatorFunctionType->returnType() : AbstractType::Ptr();
     };
 
     return Helper::mergeTypes(operatorReturnType(lhs), operatorReturnType(rhs));
 }
 
 void ExpressionVisitor::visitBinaryOperation(Python::BinaryOperationAst* node)
 {
     ExpressionVisitor lhsVisitor(this);
     ExpressionVisitor rhsVisitor(this);
     AbstractType::Ptr result;
 
     lhsVisitor.visitNode(node->lhs);
     rhsVisitor.visitNode(node->rhs);
 
     if ( lhsVisitor.lastType() && lhsVisitor.lastType()->whichType() == AbstractType::TypeUnsure ) {
         KDevelop::UnsureType::Ptr unsure = lhsVisitor.lastType().cast<KDevelop::UnsureType>();
         const IndexedType* types = unsure->types();
         for( uint i = 0; i < unsure->typesSize(); i++ ) {
             result = Helper::mergeTypes(result, fromBinaryOperator(types[i].abstractType(),
                                                                    rhsVisitor.lastType(), node->methodName()));
         }
     } else {
         result = fromBinaryOperator(lhsVisitor.lastType(), rhsVisitor.lastType(), node->methodName());
     }
     if ( ! Helper::isUsefulType(result) ) {
         result = Helper::mergeTypes(lhsVisitor.lastType(), rhsVisitor.lastType());
     }
     return encounter(result);
 }
 
 void ExpressionVisitor::visitUnaryOperation(Python::UnaryOperationAst* node)
 {
     // Only visit the value, and use that as the result. Unary operators usually
     // don't change the type of the object (i.e. -a has the same type as a)
     visitNode(node->operand);
 }
 
 void ExpressionVisitor::visitBooleanOperation(Python::BooleanOperationAst* node)
 {
     foreach (ExpressionAst* expression, node->values) {
         visitNode(expression);
     }
 
     encounter(AbstractType::Ptr(new IntegralType(IntegralType::TypeBoolean)));
 }
 
 }
 
diff --git a/duchain/helpers.cpp b/duchain/helpers.cpp
index 9a825690..6296eead 100644
--- a/duchain/helpers.cpp
+++ b/duchain/helpers.cpp
@@ -1,542 +1,542 @@
 /*****************************************************************************
  * This file is part of KDevelop                                             *
  * Copyright 2011-2013 Sven Brauch <svenbrauch@googlemail.com>               *
  *                                                                           *
  * This program is free software; you can redistribute it and/or             *
  * modify it under the terms of the GNU General Public License as            *
  * published by the Free Software Foundation; either version 2 of            *
  * the License, or (at your option) any later version.                       *
  *                                                                           *
  * This program is distributed in the hope that it will be useful,           *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************
  */
 
 #include "helpers.h"
 
 #include <QList>
 #include <QProcess>
 #include <QSettings>
 #include <QStandardPaths>
 
 #include <QDebug>
 #include "duchaindebug.h"
 
 #include <language/duchain/types/unsuretype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/containertypes.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/types/typeutils.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ipartcontroller.h>
 #include <util/path.h>
 
 #include <shell/partcontroller.h>
 
 #include <KTextEditor/View>
 #include <KConfigGroup>
 
 #include "ast.h"
 #include "types/hintedtype.h"
 #include "types/unsuretype.h"
 #include "types/indexedcontainer.h"
 #include "kdevpythonversion.h"
 #include "expressionvisitor.h"
 
 using namespace KDevelop;
 
 namespace Python {
 
 QMap<IProject*, QVector<QUrl>> Helper::cachedCustomIncludes;
 QMap<IProject*, QVector<QUrl>> Helper::cachedSearchPaths;
 QVector<QUrl> Helper::projectSearchPaths;
 QStringList Helper::dataDirs;
 QString Helper::documentationFile;
 DUChainPointer<TopDUContext> Helper::documentationFileContext = DUChainPointer<TopDUContext>(0);
 QStringList Helper::correctionFileDirs;
 QString Helper::localCorrectionFileDir;
 QMutex Helper::cacheMutex;
 QMutex Helper::projectPathLock;
 
 void Helper::scheduleDependency(const IndexedString& dependency, int betterThanPriority)
 {
     BackgroundParser* bgparser = KDevelop::ICore::self()->languageController()->backgroundParser();
     bool needsReschedule = true;
     if ( bgparser->isQueued(dependency) ) {
         const auto priority= bgparser->priorityForDocument(dependency);
         if ( priority > betterThanPriority - 1 ) {
             bgparser->removeDocument(dependency);
         }
         else {
             needsReschedule = false;
         }
     }
     if ( needsReschedule ) {
         bgparser->addDocument(dependency, TopDUContext::ForceUpdate, betterThanPriority - 1,
                               0, ParseJob::FullSequentialProcessing);
     }
 }
 
 IndexedDeclaration Helper::declarationUnderCursor(bool allowUse)
 {
     KDevelop::IDocument* doc = ICore::self()->documentController()->activeDocument();
     const auto view = static_cast<KDevelop::PartController*>(ICore::self()->partController())->activeView();
     if ( doc && doc->textDocument() && view ) {
         DUChainReadLocker lock;
         const auto cursor = view->cursorPosition();
         if ( allowUse ) {
             return IndexedDeclaration(DUChainUtils::itemUnderCursor(doc->url(), cursor).declaration);
         }
         else {
             return DUChainUtils::declarationInLine(cursor, DUChainUtils::standardContextForUrl(doc->url()));
         }
     }
 
     return KDevelop::IndexedDeclaration();
 }
 
-Declaration* Helper::accessAttribute(Declaration* accessed, const QString& attribute, const DUContext* current)
+Declaration* Helper::accessAttribute(const AbstractType::Ptr accessed, const QString& attribute, const DUContext* current)
 {
-    if ( ! accessed || ! accessed->abstractType() ) {
+    if ( ! accessed ) {
         return 0;
     }
     // if the type is unsure, search all the possibilities
-    auto structureTypes = Helper::filterType<StructureType>(accessed->abstractType(),
+    auto structureTypes = Helper::filterType<StructureType>(accessed,
         [](AbstractType::Ptr toFilter) {
             auto type = Helper::resolveAliasType(toFilter);
             return type && type->whichType() == AbstractType::TypeStructure;
         }
     );
     for ( auto type: structureTypes ) {
         QList<DUContext*> searchContexts = Helper::internalContextsForClass(type, current->topContext());
         for ( DUContext* c: searchContexts ) {
             auto found = c->findDeclarations(KDevelop::Identifier(attribute),
                                              CursorInRevision::invalid(),
                                              current->topContext(), DUContext::DontSearchInParent);
             std::reverse(found.begin(), found.end());
             // never consider decls from the builtins
             if ( ! found.isEmpty() && (
                    found.first()->topContext() != Helper::getDocumentationFileContext() ||
                    c->topContext() == Helper::getDocumentationFileContext() ) )
             {
                 return found.first();
             }
         }
     }
     return nullptr;
 }
 
 AbstractType::Ptr Helper::resolveAliasType(const AbstractType::Ptr eventualAlias)
 {
     return TypeUtils::resolveAliasType(eventualAlias);
 }
 
 AbstractType::Ptr Helper::extractTypeHints(AbstractType::Ptr type)
 {
     return Helper::foldTypes(Helper::filterType<AbstractType>(type, [](AbstractType::Ptr t) -> bool {
         auto hint = t.cast<HintedType>();
         return !hint || hint->isValid();
     }));
 }
 
 Helper::FuncInfo Helper::functionDeclarationForCalledDeclaration(DeclarationPointer ptr)
 {
     if ( ! ptr ) {
         return FuncInfo();
     }
     bool isConstructor = false;
     DeclarationPointer calledDeclaration = ptr;
     if ( ! calledDeclaration->isFunctionDeclaration() ) {
         // not a function -- try looking for a constructor
         StructureType::Ptr classType = calledDeclaration->type<StructureType>();
         auto contexts = Helper::internalContextsForClass(classType, ptr->topContext());
         for ( DUContext* context: contexts ) {
             static KDevelop::Identifier initIdentifier("__init__");
             QList<Declaration*> constructors = context->findDeclarations(initIdentifier);
             if ( ! constructors.isEmpty() ) {
                 calledDeclaration = dynamic_cast<FunctionDeclaration*>(constructors.first());
                 isConstructor = true;
                 break;
             }
         }
     }
     FunctionDeclarationPointer lastFunctionDeclaration;
     if ( calledDeclaration ) {
         // It was a class -- use the constructor
         lastFunctionDeclaration = calledDeclaration.dynamicCast<FunctionDeclaration>();
     }
     else {
         // Use the original declaration
         lastFunctionDeclaration = ptr.dynamicCast<FunctionDeclaration>();
     }
     return QPair<FunctionDeclarationPointer, bool>(lastFunctionDeclaration, isConstructor);
 }
 
 Declaration* Helper::declarationForName(const QualifiedIdentifier& identifier, const RangeInRevision& nodeRange,
                                         KDevelop::DUChainPointer<const DUContext> context)
 {
     QList<Declaration*> declarations;
     QList<Declaration*> localDeclarations;
     QList<Declaration*> importedLocalDeclarations;
     {
         DUChainReadLocker lock(DUChain::lock());
         if ( context.data() == context->topContext() && nodeRange.isValid() ) {
             declarations = context->topContext()->findDeclarations(identifier, nodeRange.end);
         }
         else {
             declarations = context->topContext()->findDeclarations(identifier, CursorInRevision::invalid());
         }
         localDeclarations = context->findLocalDeclarations(identifier.last(), nodeRange.end, 0,
                                                            AbstractType::Ptr(0), DUContext::DontResolveAliases);
         importedLocalDeclarations = context->findDeclarations(identifier.last(), nodeRange.end);
     }
     Declaration* declaration = 0;
     if ( localDeclarations.length() ) {
         declaration = localDeclarations.last();
     }
     else if ( importedLocalDeclarations.length() ) {
         // don't use declarations from class decls, they must be referenced through "self.<foo>"
         do {
             declaration = importedLocalDeclarations.last();
             importedLocalDeclarations.pop_back();
             if ( !declaration || (declaration->context()->type() == DUContext::Class && context->type() != DUContext::Function) ) {
                 declaration = 0;
             }
             if ( importedLocalDeclarations.isEmpty() ) {
                 break;
             }
         } while ( ! importedLocalDeclarations.isEmpty() );
     }
 
     if ( !declaration && declarations.length() ) {
         declaration = declarations.last();
     }
     return declaration;
 }
 
 QList< DUContext* > Helper::internalContextsForClass(StructureType::Ptr klassType, TopDUContext* context, ContextSearchFlags flags, int depth)
 {
     QList<DUContext*> searchContexts;
     if ( ! klassType ) {
         return searchContexts;
     }
     if ( auto c = klassType->internalContext(context) ) {
         searchContexts << c;
     }
     Declaration* decl = Helper::resolveAliasDeclaration(klassType->declaration(context));
     ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>(decl);
     if ( klass ) {
         FOREACH_FUNCTION ( const BaseClassInstance& base, klass->baseClasses ) {
             if ( flags == PublicOnly && base.access == KDevelop::Declaration::Private ) {
                 continue;
             }
             StructureType::Ptr baseClassType = base.baseClass.type<StructureType>();
             // recursive call, because the base class will have more base classes eventually
             if ( depth < 10 ) {
                 searchContexts.append(Helper::internalContextsForClass(baseClassType, context, flags, depth + 1));
             }
         }
     }
     return searchContexts;
 }
 
 Declaration* Helper::resolveAliasDeclaration(Declaration* decl)
 {
     AliasDeclaration* alias = dynamic_cast<AliasDeclaration*>(decl);
     if ( alias ) {
         DUChainReadLocker lock;
         return alias->aliasedDeclaration().data();
     }
     else
         return decl;
 }
 
 QStringList Helper::getDataDirs() {
     if ( Helper::dataDirs.isEmpty() ) {
         Helper::dataDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "kdevpythonsupport/documentation_files", QStandardPaths::LocateDirectory);
     }
     return Helper::dataDirs;
 }
 
 QString Helper::getDocumentationFile() {
     if ( Helper::documentationFile.isNull() ) {
         Helper::documentationFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kdevpythonsupport/documentation_files/builtindocumentation.py");
     }
     return Helper::documentationFile;
 }
 
 ReferencedTopDUContext Helper::getDocumentationFileContext()
 {
     if ( Helper::documentationFileContext ) {
         return ReferencedTopDUContext(Helper::documentationFileContext.data());
     }
     else {
         DUChainReadLocker lock;
         auto file = IndexedString(Helper::getDocumentationFile());
         ReferencedTopDUContext ctx = ReferencedTopDUContext(DUChain::self()->chainForDocument(file));
         Helper::documentationFileContext = DUChainPointer<TopDUContext>(ctx.data());
         return ctx;
     }
     return ReferencedTopDUContext(0); // c++...
 }
 
 // stolen from KUrl. duh.
 static QString _relativePath(const QString &base_dir, const QString &path)
 {
    QString _base_dir(QDir::cleanPath(base_dir));
    QString _path(QDir::cleanPath(path.isEmpty() || QDir::isRelativePath(path) ? _base_dir+QLatin1Char('/')+path : path));
 
    if (_base_dir.isEmpty())
       return _path;
 
    if (_base_dir[_base_dir.length()-1] != QLatin1Char('/'))
       _base_dir.append(QLatin1Char('/') );
 
    const QStringList list1 = _base_dir.split(QLatin1Char('/'), QString::SkipEmptyParts);
    const QStringList list2 = _path.split(QLatin1Char('/'), QString::SkipEmptyParts);
 
    // Find where they meet
    int level = 0;
    int maxLevel = qMin(list1.count(), list2.count());
    while((level < maxLevel) && (list1[level] == list2[level])) level++;
 
    QString result;
    // Need to go down out of the first path to the common branch.
    for(int i = level; i < list1.count(); i++)
       result.append(QLatin1String("../"));
 
    // Now up up from the common branch to the second path.
    for(int i = level; i < list2.count(); i++)
       result.append(list2[i]).append(QLatin1Char('/'));
 
    if ((level < list2.count()) && (path[path.length()-1] != QLatin1Char('/')))
       result.truncate(result.length()-1);
 
    return result;
 }
 
 QUrl Helper::getCorrectionFile(const QUrl& document)
 {
     if ( Helper::correctionFileDirs.isEmpty() ) {
         Helper::correctionFileDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
                                                                "kdevpythonsupport/correction_files/",
                                                                QStandardPaths::LocateDirectory);
     }
 
     foreach (QString correctionFileDir, correctionFileDirs) {
         foreach ( const QUrl& basePath, Helper::getSearchPaths(QUrl()) ) {
             if ( ! basePath.isParentOf(document) ) {
                 continue;
             }
             auto base = basePath.path();
             auto doc = document.path();
             auto relative = _relativePath(base, doc);
             auto fullPath = correctionFileDir + "/" + relative;
             if ( QFile::exists(fullPath) ) {
                 return QUrl::fromLocalFile(fullPath).adjusted(QUrl::NormalizePathSegments);
             }
         }
     }
     return {};
 }
 
 QUrl Helper::getLocalCorrectionFile(const QUrl& document)
 {
     if ( Helper::localCorrectionFileDir.isNull() ) {
         Helper::localCorrectionFileDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "kdevpythonsupport/correction_files/";
     }
 
     auto absolutePath = QUrl();
     foreach ( const auto& basePath, Helper::getSearchPaths(QUrl()) ) {
         if ( ! basePath.isParentOf(document) ) {
             continue;
         }
         auto path = QDir(basePath.path()).relativeFilePath(document.path());
         absolutePath = QUrl::fromLocalFile(Helper::localCorrectionFileDir + path);
         break;
     }
     return absolutePath;
 }
 
 QString getPythonExecutablePath(IProject* project)
 {
     if ( project ) {
         auto interpreter = project->projectConfiguration()->group("pythonsupport").readEntry("interpreter");
         if ( !interpreter.isEmpty() ) {
             // we have a user-configured interpreter, try using it
             QFile f(interpreter);
             if ( f.exists() ) {
                 return interpreter;
             }
             qCWarning(KDEV_PYTHON_DUCHAIN) << "Custom python interpreter" << interpreter << "configured for project" << project->name() << "is invalid, using default";
         }
     }
 
     // Find python 3 (https://www.python.org/dev/peps/pep-0394/)
     auto result = QStandardPaths::findExecutable("python" PYTHON_VERSION_MAJOR "." PYTHON_VERSION_MINOR);
     if ( ! result.isEmpty() ) {
         return result;
     }
     result = QStandardPaths::findExecutable("python" PYTHON_VERSION_MAJOR);
     if ( ! result.isEmpty() ) {
         return result;
     }
     result = QStandardPaths::findExecutable("python");
     if ( ! result.isEmpty() ) {
         return result;
     }
 
 #ifdef Q_OS_WIN
     QStringList extraPaths;
     // Check for default CPython installation path, because the
     // installer does not add the path to $PATH.
     QStringList keys = {
         "HKEY_LOCAL_MACHINE\\Software\\Python\\PythonCore\\PYTHON_VERSION\\InstallPath",
         "HKEY_LOCAL_MACHINE\\Software\\Python\\PythonCore\\PYTHON_VERSION-32\\InstallPath",
         "HKEY_CURRENT_USER\\Software\\Python\\PythonCore\\PYTHON_VERSION\\InstallPath",
         "HKEY_CURRENT_USER\\Software\\Python\\PythonCore\\PYTHON_VERSION-32\\InstallPath"
     };
     auto version = QString(PYTHON_VERSION_MAJOR) + "." + PYTHON_VERSION_MINOR;
     foreach ( QString key, keys ) {
         key.replace("PYTHON_VERSION", version);
         QSettings base(key.left(key.indexOf("Python")), QSettings::NativeFormat);
         if ( ! base.childGroups().contains("Python") ) {
             continue;
         }
         QSettings keySettings(key, QSettings::NativeFormat);
         auto path = keySettings.value("Default").toString();
         if ( ! path.isEmpty() ) {
             extraPaths << path;
             break;
         }
     }
     result = QStandardPaths::findExecutable("python", extraPaths);
     if ( ! result.isEmpty() ) {
         return result;
     }
 #endif
     // fallback
     return PYTHON_EXECUTABLE;
 }
 
 QVector<QUrl> Helper::getSearchPaths(const QUrl& workingOnDocument)
 {
     QMutexLocker lock(&Helper::cacheMutex);
     QVector<QUrl> searchPaths;
     // search in the projects, as they're packages and likely to be installed or added to PYTHONPATH later
     // and also add custom include paths that are defined in the projects
 
     auto project = ICore::self()->projectController()->findProjectForUrl(workingOnDocument);
     {
         QMutexLocker lock(&Helper::projectPathLock);
         searchPaths << Helper::projectSearchPaths;
         searchPaths << Helper::cachedCustomIncludes.value(project);
     }
     
     foreach ( const QString& path, getDataDirs() ) {
         searchPaths.append(QUrl::fromLocalFile(path));
     }
 
     if ( !cachedSearchPaths.contains(project) ) {
         QVector<QUrl> cachedForProject;
         qCDebug(KDEV_PYTHON_DUCHAIN) << "*** Collecting search paths...";
         QStringList getpath;
         getpath << "-c" << "import sys; sys.stdout.write('$|$'.join(sys.path))";
         
         QProcess python;
         python.start(getPythonExecutablePath(project), getpath);
         python.waitForFinished(1000);
         QString pythonpath = QString::fromUtf8(python.readAllStandardOutput());
         auto paths = pythonpath.split("$|$");
         paths.removeAll("");
         
         if ( ! pythonpath.isEmpty() ) {
             foreach ( const QString& path, paths ) {
                 cachedForProject.append(QUrl::fromLocalFile(path));
             }
         }
         else {
             qCWarning(KDEV_PYTHON_DUCHAIN) << "Could not get search paths! Defaulting to stupid stuff.";
             searchPaths.append(QUrl::fromLocalFile("/usr/lib/python3.5"));
             searchPaths.append(QUrl::fromLocalFile("/usr/lib/python3.5/site-packages"));
             QString path = qgetenv("PYTHONPATH");
             QStringList paths = path.split(':');
             foreach ( const QString& path, paths ) {
                 cachedForProject.append(QUrl::fromLocalFile(path));
             }
         }
         qCDebug(KDEV_PYTHON_DUCHAIN) << " *** Done. Got search paths: " << cachedSearchPaths;
         cachedSearchPaths.insert(project, cachedForProject);
     }
     else {
         qCDebug(KDEV_PYTHON_DUCHAIN) << " --- Search paths from cache: " << cachedSearchPaths;
     }
     
     searchPaths.append(cachedSearchPaths.value(project));
     
     auto dir = workingOnDocument.adjusted(QUrl::RemoveFilename);
     if ( ! dir.isEmpty() ) {
         // search in the current packages
         searchPaths.append(dir);
     }
     
     return searchPaths;
 }
 
 bool Helper::isUsefulType(AbstractType::Ptr type)
 {
     return TypeUtils::isUsefulType(type);
 }
 
 AbstractType::Ptr Helper::contentOfIterable(const AbstractType::Ptr iterable)
 {
     auto items = filterType<AbstractType>(iterable,
         [](AbstractType::Ptr t) {
             return ListType::Ptr::dynamicCast(t) || IndexedContainer::Ptr::dynamicCast(t);
         },
         [](AbstractType::Ptr t) {
             if (auto map = MapType::Ptr::dynamicCast(t)) {
                 // Iterating over dicts gets keys, not values
                 return map->keyType().abstractType();
             }
             else if ( auto variable = ListType::Ptr::dynamicCast(t) ) {
                 return AbstractType::Ptr(variable->contentType().abstractType());
             }
             else {
                 auto indexed = t.cast<IndexedContainer>();
                 return indexed->asUnsureType();
             }
         }
     );
 
     if ( items.size() == 1 ) {
         return items.first();
     }
     auto unsure = AbstractType::Ptr(new UnsureType);
     for ( auto type: items ) {
         Helper::mergeTypes(unsure, type);
     }
     return unsure;
 }
 
 AbstractType::Ptr Helper::mergeTypes(AbstractType::Ptr type, const AbstractType::Ptr newType)
 {
     UnsureType::Ptr ret;
     return TypeUtils::mergeTypes<Python::UnsureType>(type, newType);
 }
 
 }
diff --git a/duchain/helpers.h b/duchain/helpers.h
index 8a5d1132..0c9226b5 100644
--- a/duchain/helpers.h
+++ b/duchain/helpers.h
@@ -1,216 +1,216 @@
 /*****************************************************************************
  * This file is part of KDevelop                                             *
  * Copyright 2011-2012 Sven Brauch <svenbrauch@googlemail.com>               *
  *                                                                           *
  * This program is free software; you can redistribute it and/or             *
  * modify it under the terms of the GNU General Public License as            *
  * published by the Free Software Foundation; either version 2 of            *
  * the License, or (at your option) any later version.                       *
  *                                                                           *
  * This program is distributed in the hope that it will be useful,           *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************
  */
 
 #ifndef GLOBALHELPERS_H
 #define GLOBALHELPERS_H
 
 #include "declarations/classdeclaration.h"
 #include "pythonduchainexport.h"
 #include "types/unsuretype.h"
 #include "ast.h"
 
 #include <interfaces/iproject.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/unsuretype.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/functiondeclaration.h>
 #include <duchain/declarations/decorator.h>
 
 #include <QList>
 
 #include <functional>
 
 #include "pythonduchainexport.h"
 #include "types/unsuretype.h"
 #include "declarations/functiondeclaration.h"
 #include "ast.h"
 
 using namespace KDevelop;
 
 namespace Python {
 
 class KDEVPYTHONDUCHAIN_EXPORT Helper {
 public:
     /** get search paths for python files **/
     static QVector<QUrl> getSearchPaths(const QUrl& workingOnDocument);
     static QStringList dataDirs;
     static QString documentationFile;
     static QStringList correctionFileDirs;
     static QString localCorrectionFileDir;
     static DUChainPointer<TopDUContext> documentationFileContext;
 
     static QStringList getDataDirs();
     static QString getDocumentationFile();
     static ReferencedTopDUContext getDocumentationFileContext();
 
     static QUrl getCorrectionFile(const QUrl& document);
     static QUrl getLocalCorrectionFile(const QUrl& document);
 
     static QMutex cacheMutex;
     static QMap<IProject*, QVector<QUrl>> cachedCustomIncludes;
     static QMap<IProject*, QVector<QUrl>> cachedSearchPaths;
 
     static QMutex projectPathLock;
     static QVector<QUrl> projectSearchPaths;
 
     static AbstractType::Ptr extractTypeHints(AbstractType::Ptr type);
 
-    static Declaration* accessAttribute(Declaration* accessed, const QString& attribute, const DUContext* current);
+    static Declaration* accessAttribute(const AbstractType::Ptr accessed, const QString& attribute, const DUContext* current);
 
     static AbstractType::Ptr resolveAliasType(const AbstractType::Ptr eventualAlias);
 
     /**
      * @brief Get the content type(s) of something that is an iterable.
      *
      * @param iterable Type to get the contents of. Can be an unsure.
      * @return KDevelop::AbstractType::Ptr Content type. Might be an unsure.
      */
     static AbstractType::Ptr contentOfIterable(const AbstractType::Ptr iterable);
 
     /**
      * @brief Get a list of types inside the passed type which match the specified filter.
      * The filter will be matched against the type only if it is not an unsure type,
      * or else against all types inside that unsure type.
      * @param type The type to search
      * @param accept Filter function, return true if you want the type.
      * @return QList< KDevelop::AbstractType::Ptr > list of types accepted by the filter.
      */
     template <typename T>
     static QList<typename T::Ptr> filterType(AbstractType::Ptr type, std::function<bool(AbstractType::Ptr)> accept,
                                              std::function<typename T::Ptr(AbstractType::Ptr)> map =
                                              std::function<typename T::Ptr(AbstractType::Ptr)>())
     {
         QList<typename T::Ptr> types;
         if ( ! type ) {
             return types;
         }
         if ( type->whichType() == KDevelop::AbstractType::TypeUnsure ) {
             UnsureType::Ptr unsure(type.cast<UnsureType>());
             for ( unsigned int i = 0; i < unsure->typesSize(); i++ ) {
                 AbstractType::Ptr t = unsure->types()[i].abstractType();
                 if ( accept(t) ) {
                     types << ( map ? map(t) : t.cast<T>() );
                 }
             }
         }
         else if ( accept(type) ) {
             types << ( map ? map(type) : type.cast<T>() );
         }
         return types;
     }
 
     static void scheduleDependency(const IndexedString& dependency, int betterThanPriority);
 
     static KDevelop::IndexedDeclaration declarationUnderCursor(bool allowUse = true);
 
     /**
      * @brief Finds whether the specified called declaration is a function declaration, and if not,
      *        checks for a class declaration; then returns the constructor
      *
      * @param ptr the declaration to check
      * @return the function pointer which was found, or an invalid pointer, and a bool
      *         which is true when it is a constructor
      **/
     using FuncInfo = QPair<Python::FunctionDeclarationPointer, bool>;
     static FuncInfo functionDeclarationForCalledDeclaration(DeclarationPointer ptr);
 
     template<typename T> static const Decorator* findDecoratorByName(T* inDeclaration, const QString& name) {
         const int count = inDeclaration->decoratorsSize();
         const IndexedString indexedName = IndexedString(name);
         for ( int i = 0; i < count; i++ ) {
             if ( inDeclaration->decorators()[i].fastName() == indexedName )
                 return &(inDeclaration->decorators()[i]);
         }
         return 0;
     };
 
     static bool docstringContainsHint(Declaration* declaration, const QString& hintName, QStringList* args = 0) {
         // TODO cache types! this is horribly inefficient
         const QString& comment = declaration->comment();
         const QString search = "! " + hintName + " !";
         int index = comment.indexOf(search);
         if ( index >= 0 ) {
             if ( args ) {
                 int eol = comment.indexOf('\n', index);
                 int start = index+search.size()+1;
                 QString decl = comment.mid(start, eol-start);
                 *args = decl.split(' ');
             }
             return true;
         }
         return false;
     }
 
     /**
      * @copydoc TypeUtils::mergeTypes
      */
     static AbstractType::Ptr mergeTypes(AbstractType::Ptr type, const AbstractType::Ptr newType);
 
     /**
      * @brief Like mergeTypes(), but merges a list of types into a newly allocated type.
      * Returns mixed if the list is empty.
      * @return KDevelop::AbstractType::Ptr an unsure type consisting of all types in the list.
      */
     template <typename T>
     static AbstractType::Ptr foldTypes(QList<T> types, std::function<AbstractType::Ptr(const T&)> transform
                                                      = std::function<AbstractType::Ptr(const T&)>())
     {
         AbstractType::Ptr result(new IntegralType(IntegralType::TypeMixed));
         for ( T type : types ) {
             result = Helper::mergeTypes(result, transform ? transform(type) : AbstractType::Ptr::staticCast(type));
         }
         return result;
     };
 
     /** check whether the argument is a null, mixed, or none integral type **/
     static bool isUsefulType(AbstractType::Ptr type);
 
     enum ContextSearchFlags {
         NoFlags,
         PublicOnly
     };
 
     /**
     * @brief Find all internal contexts for this class and its base classes recursively
     *
     * @param klass Type object for the class to search contexts
     * @param context TopContext for finding the declarations for types
     * @return list of contexts which were found
     **/
     static QList<DUContext*> internalContextsForClass(KDevelop::StructureType::Ptr klassType,
                                                       TopDUContext* context, ContextSearchFlags flags = NoFlags, int depth = 0);
     /**
       * @brief Resolve the given declaration if it is an alias declaration.
       *
       * @param decl the declaration to resolve
       * @return :Declaration* decl if not an alias declaration, decl->aliasedDeclaration().data otherwise
       * DUChain must be read locked
       **/
     static Declaration* resolveAliasDeclaration(Declaration* decl);
 
     static Declaration* declarationForName(const QualifiedIdentifier& identifier, const RangeInRevision& nodeRange,
                                            DUChainPointer<const DUContext> context);
 };
 
 }
 
 #endif
 
diff --git a/duchain/tests/pyduchaintest.cpp b/duchain/tests/pyduchaintest.cpp
index 50ca117e..62545e40 100644
--- a/duchain/tests/pyduchaintest.cpp
+++ b/duchain/tests/pyduchaintest.cpp
@@ -1,1481 +1,1490 @@
 /*****************************************************************************
  * Copyright 2010 (c) Miquel Canes Gonzalez <miquelcanes@gmail.com>          *
  * Copyright 2012 (c) Sven Brauch <svenbrauch@googlemail.com>                *
  *                                                                           *
  * Permission is hereby granted, free of charge, to any person obtaining     *
  * a copy of this software and associated documentation files (the           *
  * "Software"), to deal in the Software without restriction, including       *
  * without limitation the rights to use, copy, modify, merge, publish,       *
  * distribute, sublicense, and/or sell copies of the Software, and to        *
  * permit persons to whom the Software is furnished to do so, subject to     *
  * the following conditions:                                                 *
  *                                                                           *
  * The above copyright notice and this permission notice shall be            *
  * included in all copies or substantial portions of the Software.           *
  *                                                                           *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,           *
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF        *
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                     *
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE    *
  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION    *
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION     *
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.           *
  *****************************************************************************/
 
 #include <QDebug>
 #include "duchaindebug.h"
 
 #include "pyduchaintest.h"
 
 #include <stdlib.h>
 
 #include <language/duchain/topducontext.h>
 #include <language/codegen/coderepresentation.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <language/duchain/duchain.h>
 #include <QtTest/QtTest>
 #include <QtWidgets/QApplication>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/containertypes.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/interfaces/iastcontainer.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <tests/testfile.h>
 
 #include <KTextEditor/Range>
 
 #include "parsesession.h"
 #include "pythoneditorintegrator.h"
 #include "declarationbuilder.h"
 #include "usebuilder.h"
 #include "astdefaultvisitor.h"
 #include "expressionvisitor.h"
 #include "contextbuilder.h"
 #include "astbuilder.h"
 
 #include "duchain/helpers.h"
 
 QTEST_MAIN(PyDUChainTest)
 
 using namespace KDevelop;
 using namespace Python;
 
 
 PyDUChainTest::PyDUChainTest(QObject* parent): QObject(parent)
 {
     assetsDir = QDir(DUCHAIN_PY_DATA_DIR);
     if (!assetsDir.cd("data")) {
         qFatal("Failed find data directory for test files. Aborting");
     }
 
     testDir = QDir(testDirOwner.path());
 
     qputenv("PYTHONPATH", assetsDir.absolutePath().toUtf8());
 
     initShell();
 }
 
 QList<QString> PyDUChainTest::FindPyFiles(QDir& rootDir)
 {
     QList<QString> foundfiles;
     rootDir.setFilter(QDir::Files | QDir::Dirs | QDir::NoDot | QDir::NoDotDot);
     rootDir.setNameFilters(QStringList() << "*.py"); // We only want .py files
     
     QDirIterator it(rootDir, QDirIterator::Subdirectories);
     while(it.hasNext()) {
         foundfiles.append(it.next());
     }
     return foundfiles;
 }
 
 void PyDUChainTest::init()
 {
     QString currentTest = QString(QTest::currentTestFunction());
     if (lastTest == currentTest) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Already prepared assets for " << currentTest << ", skipping";
         return;
     } else {
         lastTest = currentTest;
     }
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Preparing assets for test " << currentTest;
     
     QDir assetModuleDir = QDir(assetsDir.absolutePath());
     
     if (!assetModuleDir.cd(currentTest)) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "Asset directory " << currentTest
                  <<  " does not exist under " << assetModuleDir.absolutePath() << ". Skipping it.";
         return;
     }
     
     qCDebug(KDEV_PYTHON_DUCHAIN) << "Searching for python files in " << assetModuleDir.absolutePath();
     
     QList<QString> foundfiles = FindPyFiles(assetModuleDir);
 
     QString correctionFileDir = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kdevpythonsupport/correction_files", QStandardPaths::LocateDirectory);
     auto correctionFileUrl = QUrl(QDir::cleanPath(correctionFileDir + "/testCorrectionFiles/example.py"));
     foundfiles.prepend(correctionFileUrl.path());
 
     for ( int i = 0; i < 2; i++ ) {
         // Parse each file twice, to ensure no parsing-order related bugs appear.
         // Such bugs will need separate unit tests and should not influence these.
         foreach(const QString filename, foundfiles) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Parsing asset: " << filename;
             DUChain::self()->updateContextForUrl(IndexedString(filename), KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
             ICore::self()->languageController()->backgroundParser()->parseDocuments();
         }
         foreach(const QString filename, foundfiles) {
             DUChain::self()->waitForUpdate(IndexedString(filename), KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
         }
         while ( ICore::self()->languageController()->backgroundParser()->queuedCount() > 0 ) {
             // make sure to wait for all parsejobs to finish
             QTest::qWait(10);
         }
     }
 }
     
 
 void PyDUChainTest::initShell()
 {
     AutoTestShell::init();
     TestCore* core = new TestCore();
     core->initialize(KDevelop::Core::NoUi);
     
     auto doc_url = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                           "kdevpythonsupport/documentation_files/builtindocumentation.py");
     
     qCDebug(KDEV_PYTHON_DUCHAIN) << doc_url;
 
     DUChain::self()->updateContextForUrl(IndexedString(doc_url), KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
     ICore::self()->languageController()->backgroundParser()->parseDocuments();
     DUChain::self()->waitForUpdate(IndexedString(doc_url), KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
     
     DUChain::self()->disablePersistentStorage();
     KDevelop::CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 ReferencedTopDUContext PyDUChainTest::parse(const QString& code)
 {
     TestFile* testfile = new TestFile(code + "\n", "py", 0, testDir.absolutePath().append("/"));
     createdFiles << testfile;
 
     testfile->parse((TopDUContext::Features) (TopDUContext::ForceUpdate | TopDUContext::AST) );
     testfile->waitForParsed(2000);
     
     if ( testfile->isReady() ) {
         Q_ASSERT(testfile->topContext());
         m_ast = static_cast<Python::ParseSession*>(testfile->topContext()->ast().data())->ast;
         return testfile->topContext();
     }
     else Q_ASSERT(false && "Timed out waiting for parser results, aborting all tests");
     return 0;
 }
 
 PyDUChainTest::~PyDUChainTest()
 {
     foreach ( TestFile* f, createdFiles ) {
         delete f;
     }
     testDir.rmdir(testDir.absolutePath());
 }
 
 void PyDUChainTest::testMultiFromImport()
 {
     QFETCH(QString, code);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainReadLocker lock;
     QList<Declaration*> a = ctx->findDeclarations(QualifiedIdentifier("a"));
     QList<Declaration*> b = ctx->findDeclarations(QualifiedIdentifier("b"));
     QVERIFY(! a.isEmpty());
     QVERIFY(! b.isEmpty());
     QVERIFY(a.first()->abstractType()->toString().endsWith("int"));
     QVERIFY(b.first()->abstractType()->toString().endsWith("int"));
 }
 
 void PyDUChainTest::testMultiFromImport_data() {
     QTest::addColumn<QString>("code");
     QTest::newRow("multiimport") << "import testMultiFromImport.i.localvar1\n"
                                     "import testMultiFromImport.i.localvar2\n"
                                     "a = testMultiFromImport.i.localvar1\n"
                                     "b = testMultiFromImport.i.localvar2\n";
 }
 
 void PyDUChainTest::testRelativeImport()
 {
     QFETCH(QString, code);
     QFETCH(QString, token);
     QFETCH(QString, type);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainReadLocker lock;
     QList<Declaration*> t = ctx->findDeclarations(QualifiedIdentifier(token));
     QVERIFY(! t.isEmpty());
     QVERIFY(t.first()->abstractType()->toString().endsWith(type));
 }
 
 void PyDUChainTest::testRelativeImport_data() {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("token");
     QTest::addColumn<QString>("type");
     QTest::newRow(".local") << "from testRelativeImport.m.sm1.go import i1" << "i1" << "int";
     QTest::newRow(".init") << "from testRelativeImport.m.sm1.go import i2" << "i2" << "int";
     QTest::newRow("..local") << "from testRelativeImport.m.sm1.go import i3" << "i3" << "int";
     QTest::newRow("..init") << "from testRelativeImport.m.sm1.go import i4" << "i4" << "int";
     QTest::newRow("..sub.local") << "from testRelativeImport.m.sm1.go import i5" << "i5" << "int";
     QTest::newRow("..sub.init") << "from testRelativeImport.m.sm1.go import i6" << "i6" << "int";
 }
 
 void PyDUChainTest::testImportFiles() {
     QString code = "import testImportFiles\nk = testImportFiles.fromInit()\np = testImportFiles.other.fromOther()";
     ReferencedTopDUContext ctx = parse(code.toUtf8());
     DUChainReadLocker lock;
     QVERIFY(ctx);
 
     auto k = ctx->findDeclarations(QualifiedIdentifier("k"));
     auto p = ctx->findDeclarations(QualifiedIdentifier("p"));
     QCOMPARE(k.size(), 1);
     QCOMPARE(p.size(), 1);
     QVERIFY(k.first()->abstractType());
     QCOMPARE(k.first()->abstractType()->toString(), QString("fromInit"));
     QCOMPARE(p.first()->abstractType()->toString(), QString("fromOther"));
 }
 
 void PyDUChainTest::testCrashes() {
     QFETCH(QString, code);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     QVERIFY(m_ast);
     QVERIFY(! m_ast->body.isEmpty());
 }
 
 void PyDUChainTest::testCrashes_data() {
     QTest::addColumn<QString>("code");
     
     QTest::newRow("unicode_char") << "a = \"í\"";
     QTest::newRow("unicode escape char") << "print(\"\\xe9\")";
     QTest::newRow("augassign") << "a = 3\na += 5";
     QTest::newRow("delete") << "a = 3\ndel a";
     QTest::newRow("double_comprehension") << "q = [[x for x in a] + [x for x in a] for y in b]";
     QTest::newRow("for_else") << "for i in range(3): pass\nelse: pass";
     QTest::newRow("for_while") << "while i < 4: pass\nelse: pass";
     QTest::newRow("ellipsis") << "a[...]";
     QTest::newRow("tuple_assign_unknown") << "foo = (unknown, unknown, unknown)";
     QTest::newRow("for_assign_unknown") << "for foo, bar, baz in unknown: pass";
     QTest::newRow("negative slice index") << "t = (1, 2, 3)\nd = t[-1]";
     QTest::newRow("decorator_with_args") << "@foo('bar', 'baz')\ndef myfunc(): pass";
     QTest::newRow("non_name_decorator") << "@foo.crazy_decorators\ndef myfunc(): pass";
     QTest::newRow("static_method") << "class c:\n @staticmethod\n def method(): pass";
     QTest::newRow("vararg_in_middle") << "def func(a, *b, c): pass\nfunc(1, 2, 3, 4, 5)";
     QTest::newRow("whatever") << "for attr in updated:\n    "
                                  "    getattr.update";
     QTest::newRow("return_outside_function") << "return 3";
     QTest::newRow("return_context_outside_function") << "return [x for x in range(3)]";
     QTest::newRow("paren_attrib_access") << "a = (xxx or yyy).zzz";
     QTest::newRow("func_call") << "a = xxx.func(yyy.zzz)";
     QTest::newRow("comprehension_attrib") << "a = [foo for foo in bar].baz";
     QTest::newRow("comprehension_attrib2") << "a = [foo.bar for foo in bar]";
     QTest::newRow("attrib") << "(sep or ' ').join(xxxx.capitalize() for xxxx in ssss.split(sep))";
     QTest::newRow("attrib2") << "(sep or ' ').join(x.capitalize() for x in s.split(sep))";
     QTest::newRow("attrib3") << "known_threads = {line.strip()}";
     QTest::newRow("attrib4") << "known_threads = {line.strip() for line  in [\"foo\"] if line.strip()}";
     QTest::newRow("stacked_lambdas") << "l4 = lambda x = lambda y = lambda z=1 : z : y() : x()";
     QTest::newRow("newline_attrib2") << "raise TypeError(\"argument should be a bound method, not {}\"\n"
                                         ".format(type(meth))) from None";
     QTest::newRow("newline_attrib") << "some_instance \\\n"
                 ".   attr1 \\\n"
                 ".funcfunc(argarg, arg2arg) \\\n"
                 ".foo";
     QTest::newRow("fancy generator context range") << "c1_list = sorted(letter for (letter, meanings) \\\n"
                "in ambiguous_nucleotide_values.iteritems() \\\n"
                "if set([codon[0] for codon in codons]).issuperset(set(meanings)))";
     QTest::newRow("fancy class range") << "class SchemeLexer(RegexLexer):\n"
                                           "  valid_name = r'[a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+'\n"
                                           "\n"
                                           "  tokens = {\n"
                                           "      'root' : [\n"
                                           "          # the comments - always starting with semicolon\n"
                                           "          # and going to the end of the line\n"
                                           "          (r';.*$', Comment.Single),\n"
                                           "\n"
                                           "          # whitespaces - usually not relevant\n"
                                           "          (r'\\s+', Text),\n"
                                           "\n"
                                           "          # numbers\n"
                                           "          (r'-?\\d+\\.\\d+', Number.Float),\n"
                                           "          (r'-?\\d+', Number.Integer)\n"
                                           "      ],\n"
                                           "  }\n";
     QTest::newRow("another fancy range") << "setup_args['data_files'] = [\n"
                                           "     (os.path.dirname(os.path.join(install_base_dir, pattern)),\n"
                                           "     [ f for f in glob.glob(pattern) ])\n"
                                           "        for pattern in patterns\n"
                                           "]\n";
     QTest::newRow("kwarg_empty_crash") << "def myfun(): return\ncheckme = myfun(kw=something)";
     QTest::newRow("stacked_tuple_hang") << "tree = (1,(2,(3,(4,(5,'Foo')))))";
     QTest::newRow("stacked_tuple_hang2") << "tree = (257,"
          "(264,"
           "(285,"
            "(259,"
             "(272,"
               "(275,"
                "(1, 'return')))))))";
     QTest::newRow("very_large_tuple_hang") << "tree = "
         "(257,"
          "(264,"
           "(285,"
            "(259,"
             "(1, 'def'),"
             "(1, 'f'),"
             "(260, (7, '('), (8, ')')),"
             "(11, ':'),"
             "(291,"
              "(4, ''),"
              "(5, ''),"
              "(264,"
               "(265,"
                "(266,"
                 "(272,"
                  "(275,"
                   "(1, 'return'),"
                   "(313,"
                    "(292,"
                     "(293,"
                      "(294,"
                       "(295,"
                        "(297,"
                         "(298,"
                          "(299,"
                           "(300,"
                            "(301,"
                             "(302, (303, (304, (305, (2, '1')))))))))))))))))),"
                "(264,"
                 "(265,"
                  "(266,"
                   "(272,"
                    "(276,"
                    "(1, 'yield'),"
                     "(313,"
                      "(292,"
                       "(293,"
                        "(294,"
                         "(295,"
                          "(297,"
                           "(298,"
                            "(299,"
                             "(300,"
                              "(301,"
                               "(302,"
                                "(303, (304, (305, (2, '1')))))))))))))))))),"
                  "(4, ''))),"
                "(6, ''))))),"
            "(4, ''),"
            "(0, ''))))";
     QTest::newRow("attribute_hang") << "s = \"123\"\n"
             "s = s.replace(u'ł', 'l').\\\n"
             "replace(u'ó', 'o').\\\n"
             "replace(u'ą', 'a').\\\n"
             "replace(u'ę', 'e').\\\n"
             "replace(u'ś', 's').\\\n"
             "replace(u'ż', 'z').\\\n"
             "replace(u'ź', 'z').\\\n"
             "replace(u'ć', 'c').\\\n"
             "replace(u'ń', 'n').\\\n"
             "replace(u'б', 'b').\\\n"
             "replace(u'в', 'v').\\\n"
             "replace(u'г', 'g').\\\n"
             "replace(u'д', 'd').\\\n"
             "replace(u'ё', 'yo').\\\n"
             "replace(u'ć', 'c').\\\n"
             "replace(u'ń', 'n').\\\n"
             "replace(u'б', 'b').\\\n"
             "replace(u'в', 'v').\\\n"
             "replace(u'г', 'g').\\\n"
             "replace(u'д', 'd').\\\n"
             "replace(u'ё', 'yo').\\\n"
             "replace(u'ć', 'c').\\\n"
             "replace(u'ń', 'n').\\\n"
             "replace(u'б', 'b').\\\n"
             "replace(u'в', 'v').\\\n"
             "replace(u'г', 'g').\\\n"
             "replace(u'д', 'd').\\\n"
             "replace(u'ё', 'yo')\n";
     QTest::newRow("function context range crash") << "def myfunc(arg):\n foo = 3 + \\\n[x for x in range(20)]";
     QTest::newRow("decorator comprehension crash") << "@implementer_only(interfaces.ISSLTransport,\n"
                  "                   *[i for i in implementedBy(tcp.Client)\n"
                  "                     if i != interfaces.ITLSTransport])\n"
                  "class Client(tcp.Client):\n"
                  "  pass\n";
     QTest::newRow("comprehension_as_default_crash") << "def foo(bar = [item for (_, item) in items()]):\n return";
     QTest::newRow("try_except") << "try: pass\nexcept: pass";
     QTest::newRow("try_except_type") << "try: pass\nexcept FooException: pass";
     QTest::newRow("try_except_type_as") << "try: pass\nexcept FooException as bar: pass";
     QTest::newRow("import_missing") << "from this_does_not_exist import nor_does_this";
 
     QTest::newRow("list_append_missing") << "foo = []\nfoo.append(missing)";
     QTest::newRow("list_append_missing_arg") << "foo = []\nfoo.append()";
 
     QTest::newRow("list_extend_missing") << "foo = []\nfoo.extend(missing)";
     QTest::newRow("list_extend_missing_arg") << "foo = []\nfoo.extend()";
 }
 
 void PyDUChainTest::testClassVariables()
 {
     ReferencedTopDUContext ctx = parse("class c():\n myvar = 3;\n def meth(self):\n  print(myvar)");
     QVERIFY(ctx.data());
     DUChainWriteLocker lock(DUChain::lock());
     CursorInRevision relevantPosition(3, 10);
     DUContext* c = ctx->findContextAt(relevantPosition);
     QVERIFY(c);
     int useIndex = c->findUseAt(relevantPosition);
     if ( useIndex != -1 ) {
         QVERIFY(useIndex < c->usesCount());
         const Use* u = &(c->uses()[useIndex]);
         QVERIFY(!u->usedDeclaration(c->topContext()));
     }
 }
 
 void PyDUChainTest::testWarnNewNotCls()
 {
     QFETCH(QString, code);
     QFETCH(int, probs);
 
     ReferencedTopDUContext ctx = parse(code);
     DUChainReadLocker lock;
     QCOMPARE(ctx->problems().count(), probs);
 }
 
 void PyDUChainTest::testWarnNewNotCls_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("probs");
 
     QTest::newRow("check_for_new_first_arg_cls") << "class c():\n def __new__(clf, other):\n  pass" << 1;
     QTest::newRow("check_for_new_first_arg_cls_0") << "class c():\n def __new__(cls, other):\n  pass" << 0;
     QTest::newRow("check_first_arg_class_self") << "class c():\n def test(seff, masik):\n  pass" << 1;
     QTest::newRow("check_first_arg_class_self_0") << "class c():\n def test(self, masik):\n  pass" << 0;
 }
 
 void PyDUChainTest::testBinaryOperatorsUnsure()
 {
     QFETCH(QString, code);
     QFETCH(QString, type);
 
     ReferencedTopDUContext ctx = parse(code);
     DUChainWriteLocker lock;
     QList<Declaration*> ds = ctx->findDeclarations(QualifiedIdentifier("checkme"));
     QVERIFY(!ds.isEmpty());
     Declaration* d = ds.first();
     QVERIFY(d);
     QVERIFY(d->abstractType());
     QCOMPARE(d->abstractType()->toString(), type);
 }
 
 void PyDUChainTest::testBinaryOperatorsUnsure_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("type");
 
     QTest::newRow("check_unsure_type_0") << "class c():\n def __mul__(self, other):\n  return int();\nx = c();\nx = 3.5;\ny = 3;\ncheckme = x * y;" << "unsure (float, int)";
     QTest::newRow("check_unsure_type_1") << "class c():\n def __mul__(self, other):\n  return int();\nx = c();\nx = 3;\ny = 3;\ncheckme = x * y;" << "int";
     QTest::newRow("check_unsure_type_2") << "class c():\n pass;\nx = c();\nx = 3;\ny = 3;\ncheckme = x * y;" << "int";
     QTest::newRow("check_unsure_type_3") << "class c():\n pass;\nclass d():\n pass;\nx = c();\nx = d();\ny = 3;\ncheckme = x * y;" << "int";
 }
 
 
 void PyDUChainTest::testFlickering()
 {
     QFETCH(QStringList, code);
     QFETCH(int, before);
     QFETCH(int, after);
     
     TestFile f(code[0], "py");
     f.parse(TopDUContext::ForceUpdate);
     f.waitForParsed(500);
     
     ReferencedTopDUContext ctx = f.topContext();
     QVERIFY(ctx);
     
     DUChainWriteLocker lock(DUChain::lock());
     int count = ctx->localDeclarations().size();
     qDebug() << "Declaration count before: " << count;
     QVERIFY(count == before);
     lock.unlock();
     
     f.setFileContents(code[1]);
     f.parse(TopDUContext::ForceUpdate);
     f.waitForParsed(500);
     ctx = f.topContext();
     QVERIFY(ctx);
     
     lock.lock();
     count = ctx->localDeclarations().size();
     qDebug() << "Declaration count afterwards: " << count;
     QVERIFY(count == after);
     
     foreach(Declaration* dec, ctx->localDeclarations()) {
         qDebug() << dec->toString() << dec->range();
         qDebug() << dec->uses().size();
     }
 }
 
 void PyDUChainTest::testFlickering_data()
 {
     QTest::addColumn<QStringList>("code");
     QTest::addColumn<int>("before");
     QTest::addColumn<int>("after");
     
     QTest::newRow("declaration_flicker") << ( QStringList() << "a=2\n" << "b=3\na=2\n" ) << 1 << 2;
 }
 
 void PyDUChainTest::testCannotOverwriteBuiltins()
 {
     QFETCH(QString, code);
     QFETCH(QString, expectedType);
 
     ReferencedTopDUContext ctx = parse(code);
     DUChainWriteLocker lock;
     QList<Declaration*> ds = ctx->findDeclarations(QualifiedIdentifier("checkme"));
     QVERIFY(!ds.isEmpty());
     Declaration* d = ds.first();
     QVERIFY(d);
     QVERIFY(d->abstractType());
     QCOMPARE(d->abstractType()->toString(), expectedType);
 }
 
 void PyDUChainTest::testCannotOverwriteBuiltins_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("expectedType");
 
     QTest::newRow("list_assign") << "class list(): pass\ncheckme = []\ncheckme.append(3)" << "list of int";
     QTest::newRow("str_assign") << "str = 5; checkme = 'Foo'" << "str";
     QTest::newRow("str_assign2") << "class Foo: pass\nstr = Foo; checkme = 'Foo'" << "str";
     QTest::newRow("str_assign3") << "from testCannotOverwriteBuiltins.i import Foo as str\ncheckme = 'Foo'" << "str";
     QTest::newRow("for") << "for str in [1, 2, 3]: pass\ncheckme = 'Foo'" << "str";
     QTest::newRow("assert") << "assert isinstance(str, int)\ncheckme = 'Foo'" << "str";
     QTest::newRow("assert2") << "assert isinstance(str, int)\ncheckme = 3" << "int";
     QTest::newRow("can_have_custom") << "from testCannotOverwriteBuiltins import mod\ncheckme = mod.open()" << "int";
     QTest::newRow("can_have_custom2") << "from testCannotOverwriteBuiltins import mod\ncheckme = open().read()" << "str";
     QTest::newRow("can_have_custom3") << "from testCannotOverwriteBuiltins import mod\ncheckme = mod.open().read()" << "mixed";
 }
 
 void PyDUChainTest::testVarKWArgs()
 {
     ReferencedTopDUContext ctx = parse("def myfun(arg, *vararg, **kwarg):\n pass\n pass");
     DUChainWriteLocker lock;
     QVERIFY(ctx);
     DUContext* func = ctx->findContextAt(CursorInRevision(1, 0));
     QVERIFY(func);
     QVERIFY(! func->findDeclarations(QualifiedIdentifier("arg")).isEmpty());
     QVERIFY(! func->findDeclarations(QualifiedIdentifier("vararg")).isEmpty());
     QVERIFY(! func->findDeclarations(QualifiedIdentifier("kwarg")).isEmpty());
     QVERIFY(func->findDeclarations(QualifiedIdentifier("vararg")).first()->abstractType()->toString().startsWith("tuple"));
     QCOMPARE(func->findDeclarations(QualifiedIdentifier("kwarg")).first()->abstractType()->toString(),
              QString("dict of str : unknown"));
 }
 
 void PyDUChainTest::testSimple()
 {
     QFETCH(QString, code);
     QFETCH(int, decls);
     QFETCH(int, uses);
     
     ReferencedTopDUContext ctx = parse(code);
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(ctx);
     
     QVector< Declaration* > declarations = ctx->localDeclarations();
     
     QCOMPARE(declarations.size(), decls);
     
     int usesCount = 0;
     foreach(Declaration* d, declarations) {
         usesCount += d->uses().size();
         
         QVERIFY(d->abstractType());
     }
     
     QCOMPARE(usesCount, uses);
 }
 
 void PyDUChainTest::testSimple_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("decls");
     QTest::addColumn<int>("uses");
     
     QTest::newRow("assign") << "b = 2;" << 1 << 0;
     QTest::newRow("assign_str") << "b = 'hola';" << 1 << 0;
     QTest::newRow("op") << "a = 3; b = a+2;" << 2 << 1;
     QTest::newRow("bool") << "a = True" << 1 << 0;
     QTest::newRow("op") << "a = True and True;" << 1 << 0;
 }
 
 class AttributeRangeTestVisitor : public AstDefaultVisitor {
 public:
     bool found;
     KTextEditor::Range searchingForRange;
     QString searchingForIdentifier;
     void visitAttribute(AttributeAst* node) override {
         auto r = KTextEditor::Range(0, node->startCol, 0, node->endCol);
         qDebug() << "Found attr: " << r << node->attribute->value << ", looking for: " << searchingForRange << searchingForIdentifier;
         if ( r == searchingForRange && node->attribute->value == searchingForIdentifier ) {
             found = true;
             return;
         }
         AstDefaultVisitor::visitAttribute(node);
     }
     void visitFunctionDefinition(FunctionDefinitionAst* node) override {
         auto r = KTextEditor::Range(0, node->name->startCol, 0, node->name->endCol);
         qDebug() << "Found func: " << r << node->name->value << ", looking for: " << searchingForRange << searchingForIdentifier;
         qDebug() << node->arguments->vararg << node->arguments->kwarg;
         if ( r == searchingForRange && node->name->value == searchingForIdentifier ) {
             found = true;
             return;
         }
         if ( node->arguments->vararg ) {
             auto r = KTextEditor::Range(0, node->arguments->vararg->startCol, 0, node->arguments->vararg->startCol+node->arguments->vararg->argumentName->value.length());
             qDebug() << "Found vararg: " << node->arguments->vararg->argumentName->value << r;
             if ( r == searchingForRange && node->arguments->vararg->argumentName->value == searchingForIdentifier ) {
                 found = true;
                 return;
             }
         }
         if ( node->arguments->kwarg ) {
             auto r = KTextEditor::Range(0, node->arguments->kwarg->startCol, 0, node->arguments->kwarg->startCol+node->arguments->kwarg->argumentName->value.length());
             qDebug() << "Found kwarg: " << node->arguments->kwarg->argumentName->value << r;
             if ( r == searchingForRange && node->arguments->kwarg->argumentName->value == searchingForIdentifier ) {
                 found = true;
                 return;
             }
         }
         AstDefaultVisitor::visitFunctionDefinition(node);
     }
     void visitClassDefinition(ClassDefinitionAst* node) override {
         auto r = KTextEditor::Range(0, node->name->startCol, 0, node->name->endCol);
         qDebug() << "Found cls: " << r << node->name->value << ", looking for: " << searchingForRange << searchingForIdentifier;
         if ( r == searchingForRange && node->name->value == searchingForIdentifier ) {
             found = true;
             return;
         }
         AstDefaultVisitor::visitClassDefinition(node);
     }
     void visitImport(ImportAst* node) override {
         foreach ( const AliasAst* name, node->names ) {
             if ( name->name ) {
                 qDebug() << "found import" << name->name->value << name->name->range();
             }
             if ( name->name && name->name->value == searchingForIdentifier && name->name->range() == searchingForRange ) {
                 found = true;
                 return;
             }
             if ( name->asName ) {
                 qDebug() << "found import" << name->asName->value << name->asName->range();
             }
             if ( name->asName && name->asName->value == searchingForIdentifier && name->asName->range() == searchingForRange ) {
                 found = true;
                 return;
             }
         }
     }
 };
 
 void PyDUChainTest::testRanges()
 {
     QFETCH(QString, code);
     QFETCH(int, expected_amount_of_variables); Q_UNUSED(expected_amount_of_variables);
     QFETCH(QStringList, column_ranges);
 
 
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
 
     QVERIFY(m_ast);
 
     for ( int i = 0; i < column_ranges.length(); i++ ) {
         int scol = column_ranges.at(i).split(",")[0].toInt();
         int ecol = column_ranges.at(i).split(",")[1].toInt();
         QString identifier = column_ranges.at(i).split(",")[2];
         auto r = KTextEditor::Range(0, scol, 0, ecol);
 
         AttributeRangeTestVisitor* visitor = new AttributeRangeTestVisitor();
         visitor->searchingForRange = r;
         visitor->searchingForIdentifier = identifier;
         visitor->visitCode(m_ast.data());
 
         QCOMPARE(visitor->found, true);
         delete visitor;
     }
 }
 
 void PyDUChainTest::testRanges_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("expected_amount_of_variables");
     QTest::addColumn<QStringList>("column_ranges");
 
     QTest::newRow("attr_two_attributes") << "base.attr" << 2 << ( QStringList() << "5,8,attr" );
     QTest::newRow("attr_binary") << "base.attr + base.attr" << 4 << ( QStringList() << "5,8,attr" << "17,20,attr" );
     QTest::newRow("attr_same") << "aaa.aaa.aaa + aaa.aaa.aaa" << 6 << ( QStringList() << "4,6,aaa" << "8,10,aaa" << "18,20,aaa" << "22,24,aaa" );
     QTest::newRow("attr_three_attributes") << "base.attr.subattr" << 3 << ( QStringList() << "5,8,attr" << "10,16,subattr" );
     QTest::newRow("attr_functionCall") << "base.attr().subattr" << 3 << ( QStringList() << "5,8,attr" << "12,18,subattr" );
     QTest::newRow("attr_stringSubscript") << "base.attr[\"a.b.c..de\"].subattr" << 3 << ( QStringList() << "5,8,attr" << "23,29,subattr" );
     QTest::newRow("attr_functionCallWithArguments") << "base.attr(arg1, arg2).subattr" << 5 << ( QStringList() << "5,8,attr" << "22,28,subattr" );
     QTest::newRow("attr_functionCallWithArgument_withInner") << "base.attr(arg1.parg2).subattr" << 5 << ( QStringList() << "5,8,attr" << "22,28,subattr" << "15,19,parg2" );
     QTest::newRow("attr_complicated") << "base.attr(arg1.arg2(arg4.arg5, [func(a.b)]).arg3(arg6.arg7)).subattr" << 5 << ( QStringList() << "5,8,attr" << "15,18,arg2" <<
                                                             "25,28,arg5" << "39,39,b" << "44,47,arg3" << "54,57,arg7" << "61,67,subattr");
     QTest::newRow("attr_two_in_call") << "func(inst.aaa, inst.bbbb)" << 2 << ( QStringList() << "10,12,aaa" << "20,23,bbbb" );
     QTest::newRow("attr_two_in_call_same") << "func(inst.aaa, inst.aaaa)" << 2 << ( QStringList() << "10,12,aaa" << "20,23,aaaa" );
     QTest::newRow("attr_two_in_call_same2") << "func(inst.aaa, inst.aaa)" << 2 << ( QStringList() << "10,12,aaa" << "20,22,aaa" );
     QTest::newRow("attr_of_string_slash") << "'/'.join(a)" << 1 << ( QStringList() << "4,7,join" );
     QTest::newRow("attr_of_string_in_list") << "[\"*{0}*\".format(foo)]" << 1 << ( QStringList() << "9,14,format" );
     QTest::newRow("attr_of_call_in_list") << "[foo().format(foo)]" << 1 << ( QStringList() << "7,12,format" );
     QTest::newRow("attr_parentheses") << "(\"foo\" + \"foo\").capitalize()" << 1 << ( QStringList() << "16,25,capitalize" );
     QTest::newRow("string_parentheses") << "(\"asdf\".join())" << 1 << ( QStringList() << "8,11,join" );
     QTest::newRow("string_parentheses2") << "(\"asdf\").join()" << 1 << ( QStringList() << "9,12,join" );
     QTest::newRow("string_parentheses3") << "(\"asdf\".join()).join()" << 2 << ( QStringList() << "8,11,join" << "16,19,join" );
     QTest::newRow("string_parentheses4") << "(\"asdf\".join()+2).join()" << 2 << ( QStringList() << "8,11,join" << "18,21,join" );
     QTest::newRow("string_parentheses_call") << "f(\"asdf\".join())" << 1 << ( QStringList() << "9,12,join" );
 
     QTest::newRow("funcrange_def") << "def func(): pass" << 1 << ( QStringList() << "4,7,func" );
     QTest::newRow("funcrange_spaces_def") << "def    func(): pass" << 1 << ( QStringList() << "7,10,func" );
     QTest::newRow("classdef_range") << "class cls(): pass" << 1 << ( QStringList() << "6,8,cls" );
     QTest::newRow("classdef_range_inheritance") << "class cls(parent1, parent2): pass" << 1 << ( QStringList() << "6,8,cls" );
     QTest::newRow("classdef_range_inheritance_spaces") << "class       cls(  parent1,    parent2     ):pass" << 1 << ( QStringList() << "12,14,cls" );
     QTest::newRow("vararg_kwarg") << "def func(*vararg, **kwargs): pass" << 2 << ( QStringList() << "10,16,vararg" << "20,26,kwargs" );
 
     QTest::newRow("import") << "import sys" << 1 << ( QStringList() << "7,10,sys" );
     QTest::newRow("import2") << "import i.localvar1" << 1 << ( QStringList() << "7,18,i.localvar1" );
     QTest::newRow("import3") << "import sys as a" << 1 << ( QStringList() << "13,14,a" );
 }
 
 class TypeTestVisitor : public AstDefaultVisitor {
 public:
     QString searchingForType;
     TopDUContextPointer ctx;
     bool found;
     void visitName(NameAst* node) override {
         if ( node->identifier->value != "checkme" ) return;
         QList<Declaration*> decls = ctx->findDeclarations(QualifiedIdentifier(node->identifier->value));
         if ( ! decls.length() ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << "No declaration found for " << node->identifier->value;
             return;
         }
         Declaration* d = decls.last();
         QVERIFY(d->abstractType());
         qCDebug(KDEV_PYTHON_DUCHAIN) << "found: " << node->identifier->value << "is" << d->abstractType()->toString() << "should be" << searchingForType;
         if ( d->abstractType()->toString().replace("__kdevpythondocumentation_builtin_", "").startsWith(searchingForType) ) {
             found = true;
             return;
         }
     };
 };
 
 void PyDUChainTest::testTypes()
 {
     
     QFETCH(QString, code);
     QFETCH(QString, expectedType);
     
     ReferencedTopDUContext ctx = parse(code.toUtf8());
     QVERIFY(ctx);
     QVERIFY(m_ast);
     
     DUChainReadLocker lock(DUChain::lock());
     TypeTestVisitor* visitor = new TypeTestVisitor();
     visitor->ctx = TopDUContextPointer(ctx.data());
     visitor->searchingForType = expectedType;
     visitor->visitCode(m_ast.data());
     QEXPECT_FAIL("lambda", "not implemented: aliasing lambdas", Continue);
     QCOMPARE(visitor->found, true);
 }
 
 void PyDUChainTest::testTypes_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("expectedType");
     
     QTest::newRow("listtype") << "checkme = []" << "list";
     QTest::newRow("listtype_func") << "checkme = list()" << "list";
     QTest::newRow("listtype_with_contents") << "checkme = [1, 2, 3, 4, 5]" << "list of int";
     QTest::newRow("listtype_extended") << "some_misc_var = []; checkme = some_misc_var" << "list";
     QTest::newRow("dicttype") << "checkme = {}" << "dict";
     QTest::newRow("dicttype_get") << "d = {0.4:5}; checkme = d.get(0)" << "int";
     QTest::newRow("dicttype_func") << "checkme = dict()" << "dict";
     QTest::newRow("dicttype_extended") << "some_misc_var = {}; checkme = some_misc_var" << "dict";
     QTest::newRow("bool") << "checkme = True" << "bool";
     QTest::newRow("float") << "checkme = 3.7" << "float";
     QTest::newRow("int") << "checkme = 3" << "int";
     QTest::newRow("str") << "checkme = \"foo\"" << "str";
     QTest::newRow("bytes") << "checkme = b\"foo\"" << "bytes";
 
     QTest::newRow("function_arg_scope") <<  "class Foo:\n"
                                             "    a = 3\n"
                                             "    def func(self, x=a):\n"
                                             "        return x\n"
                                             "f = Foo()\n"
                                             "checkme = f.func()" << "int";
     QTest::newRow("with") << "with open('foo') as f: checkme = f.read()" << "str";
     QTest::newRow("arg_after_vararg") << "def func(x, y, *, z:int): return z\ncheckme = func()" << "int";
     QTest::newRow("arg_after_vararg_with_default") << "def func(x=5, y=3, *, z:int): return z\ncheckme = func()" << "int";
 
     QTest::newRow("list_access_right_open_slice") << "some_list = []; checkme = some_list[2:]" << "list";
     QTest::newRow("list_access_left_open_slice") << "some_list = []; checkme = some_list[:2]" << "list";
     QTest::newRow("list_access_closed_slice") << "some_list = []; checkme = some_list[2:17]" << "list";
     QTest::newRow("list_access_step") << "some_list = []; checkme = some_list[::2]" << "list";
     QTest::newRow("list_access_singleItem") << "some_list = []; checkme = some_list[42]" << "mixed";
     
     QTest::newRow("funccall_number") << "def foo(): return 3; \ncheckme = foo();" << "int";
     QTest::newRow("funccall_string") << "def foo(): return 'a'; \ncheckme = foo();" << "str";
     QTest::newRow("funccall_list") << "def foo(): return []; \ncheckme = foo();" << "list";
     QTest::newRow("funccall_dict") << "def foo(): return {}; \ncheckme = foo();" << "dict";
     
     QTest::newRow("tuple1") << "checkme, foo = 3, \"str\"" << "int";
     QTest::newRow("tuple2") << "foo, checkme = 3, \"str\"" << "str";
     QTest::newRow("tuple2_negative_index") << "foo = (1, 2, 'foo')\ncheckme = foo[-1]" << "str";
     QTest::newRow("tuple_type") << "checkme = 1, 2" << "tuple";
     
     QTest::newRow("dict_iteritems") << "d = {1:2, 3:4}\nfor checkme, k in d.iteritems(): pass" << "int";
     QTest::newRow("enumerate_key") << "d = [str(), str()]\nfor checkme, value in enumerate(d): pass" << "int";
     QTest::newRow("enumerate_value") << "d = [str(), str()]\nfor key, checkme in enumerate(d): pass" << "str";
     QTest::newRow("dict_enumerate") << "d = {1:2, 3:4}\nfor key, checkme in enumerate(d.values()): pass" << "int";
 
     QTest::newRow("dict_assign_twice") << "d = dict(); d[''] = 0; d = dict(); d[''] = 0; checkme = d"
                                        << "unsure (dict of str : int, dict)";
     
     QTest::newRow("class_method_import") << "class c:\n attr = \"foo\"\n def m():\n  return attr;\n  return 3;\ni=c()\ncheckme=i.m()" << "int";
     QTest::newRow("getsListDecorator") << "foo = [1, 2, 3]\ncheckme = foo.reverse()" << "list of int";
 
     QTest::newRow("fromAssertIsinstance") << "class c(): pass\ncheckme = mixed()\nassert isinstance(checkme, c)\n" << "c";
     QTest::newRow("fromAssertIsinstanceInvalid") << "class c(): pass\ncheckme = mixed()\nassert isinstance(c, checkme)\n" << "mixed";
     QTest::newRow("fromAssertIsinstanceInvalid2") << "class c(): pass\ncheckme = mixed()\nassert isinstance(D, c)\n" << "mixed";
     QTest::newRow("fromAssertIsinstanceInvalid3") << "checkme = int()\nassert isinstance(checkme, X)\n" << "int";
     QTest::newRow("fromAssertIsinstanceInvalid4") << "checkme = int()\nassert isinstance(checkme)\n" << "int";
     QTest::newRow("fromAssertType") << "class c(): pass\ncheckme = mixed()\nassert type(checkme) == c\n" << "c";
     QTest::newRow("fromIfType") << "class c(): pass\ncheckme = mixed()\nif type(checkme) == c: pass\n" << "c";
     QTest::newRow("fromIfIsinstance") << "class c(): pass\ncheckme = mixed()\nif isinstance(checkme, c): pass\n" << "c";
     
     QTest::newRow("diff_local_classattr") << "class c(): attr = 1\ninst=c()\ncheckme = c.attr" << "int";
     QTest::newRow("diff_local_classattr2") << "local=3\nclass c(): attr = 1\ninst=c()\ncheckme = c.local" << "mixed";
     QTest::newRow("diff_local_classattr3") << "attr=3.5\nclass c(): attr = 1\ninst=c()\ncheckme = c.attr" << "int";
 //     QTest::newRow("class_method_self") << "class c:\n def func(checkme, arg, arg2):\n  pass\n" << "c";
 //    QTest::newRow("funccall_dict") << "def foo(): return foo; checkme = foo();" << (uint) IntegralType::TypeFunction;
     
     QTest::newRow("tuple_simple") << "mytuple = 3, 5.5\ncheckme, foobar = mytuple" << "int";
     QTest::newRow("tuple_simple2") << "mytuple = 3, 5.5\nfoobar, checkme = mytuple" << "float";
     QTest::newRow("tuple_simple3") << "mytuple = 3, 5.5, \"str\", 3, \"str\"\na, b, c, d, checkme = mytuple" << "str";
 
     QTest::newRow("tuple_single") << "checkme = 4," << "tuple";
     QTest::newRow("tuple_single2") << "checkme, = 4," << "int";
     QTest::newRow("tuple_single3") << "mytuple = 4,\ncheckme, = mytuple" << "int";
 
     QTest::newRow("tuple_ext_unpack") << "mytuple = 3, 5.5\nfoobar, *starred, checkme = mytuple" << "float";
     QTest::newRow("tuple_ext_unpack2") << "mytuple = 3, 5.5\nfoobar, *checkme, another = mytuple" << "list";
     QTest::newRow("tuple_ext_unpack3") << "mytuple = 3, 5.5\nfoobar, *checkme = mytuple" << "list of float";
     QTest::newRow("tuple_ext_unpack4") << "mytuple = 3, 5.5\n*checkme, = mytuple" << "list of unsure (int, float)";
 
     QTest::newRow("tuple_nested") << "mytuple = 3, ('foo', 5.5)\ncheckme, foobar = mytuple" << "int";
     QTest::newRow("tuple_nested2") << "mytuple = 3, ('foo', 5.5)\nfoobar, (checkme, other) = mytuple" << "str";
     QTest::newRow("tuple_nested3") << "mytuple = ((7, 'foo'), 5.5), 3\n((baz, checkme), other), foo = mytuple" << "str";
 
     QTest::newRow("tuple_nested_ext") << "mytuple = (2, ('foo', 'bar', 6), 7)\na, (b, *checkme, c), *d = mytuple" << "list of str";
 
     QTest::newRow("tuple_multi_assign") << "mytuple = 2, 'foo'\ncheckme = a = mytuple" << "tuple";
     QTest::newRow("tuple_multi_assign2") << "mytuple = 2, 'foo'\ncheckme, a = b = mytuple" << "int";
 
     QTest::newRow("list_unpack") << "mylist = [1, 2, 3]\ncheckme, b, c = mylist" << "int";
     QTest::newRow("list_unpack2") << "mylist = [1, 'x', 3]\ncheckme, b, c = mylist" << "unsure (int, str)";
 
     QTest::newRow("list_ext_unpack") << "mylist = [1, 2, 3]\n*checkme, foo = mylist" << "list of int";
     QTest::newRow("list_ext_unpack2") << "mylist = [1, 'x', 3]\n*checkme, foo = mylist" << "list of unsure (int, str)";
 
     QTest::newRow("if_expr_sure") << "checkme = 3 if 7 > 9 else 5" << "int";
 
     QTest::newRow("unary_op") << "checkme = -42" << "int";
     
     QTest::newRow("tuple_funcret") << "def myfun(): return 3, 5\ncheckme, a = myfun()" << "int";
     QTest::newRow("tuple_funcret2") << "def myfun():\n t = 3, 5\n return t\ncheckme, a = myfun()" << "int";
     
     QTest::newRow("yield") << "def myfun():\n yield 3\ncheckme = myfun()" << "list of int";
     QTest::newRow("yield_twice") << "def myfun():\n yield 3\n yield 'foo'\ncheckme = myfun()" << "list of unsure (int, str)";
     // this is mostly a check that it doesn't crash
     QTest::newRow("yield_return") << "def myfun():\n return 3\n yield 'foo'\ncheckme = myfun()" << "unsure (int, list of str)";
 
     QTest::newRow("lambda") << "x = lambda t: 3\ncheckme = x()" << "int";
     QTest::newRow("lambda_failure") << "x = lambda t: 3\ncheckme = t" << "mixed";
 
     QTest::newRow("function_arg_tuple") << "def func(*arg):\n foo, bar = arg\n return bar\ncheckme = func(3, 5)" << "int";
     QTest::newRow("function_arg_tuple2") << "def func(*arg):\n return arg[-1]\ncheckme = func(3, \"Foo\")" << "str";
 
     QTest::newRow("tuple_indexaccess") << "t = 3, 5.5\ncheckme = t[0]" << "int";
     QTest::newRow("tuple_indexaccess2") << "t = 3, 5.5\ncheckme = t[1]" << "float";
     QTest::newRow("tuple_indexaccess3") << "t = 3, 4\ncheckme = t[1]" << "int";
 
     QTest::newRow("dict_unsure") << "t = dict(); t = {3: str()}\ncheckme = t[1].capitalize()" << "str";
     QTest::newRow("unsure_attr_access") << "d = str(); d = 3; checkme = d.capitalize()" << "str";
 
     QTest::newRow("class_create_var") << "class c: pass\nd = c()\nd.foo = 3\ncheckme = d.foo" << "int";
     
     QTest::newRow("tuple_loop") << "t = [(1, \"str\")]\nfor checkme, a in t: pass" << "int";
     
     QTest::newRow("no_hints_type") << "def myfun(arg): arg = 3; return arg\ncheckme = myfun(3)" << "int";
     QTest::newRow("hints_type") << "def myfun(arg): return arg\ncheckme = myfun(3)" << "int";
     QTest::newRow("args_type") << "def myfun(*args): return args[0]\ncheckme = myfun(3)" << "int";
     QTest::newRow("kwarg_type") << "def myfun(**args): return args[0]\ncheckme = myfun(a=3)" << "int";
 
     QTest::newRow("tuple_unsure") << "q = (3, str())\nq=(str(), 3)\ncheckme, _ = q" << "unsure (int, str)";
 
     QTest::newRow("call_class") << "class Foo:\n"
                                     "    def __call__(self):\n"
                                     "         return 0\n"
                                     "f = Foo()\n"
                                     "checkme = f()\n" << "int";
     QTest::newRow("classmethod") << "class Foo:\n"
                                     "    @classmethod\n"
                                     "    def foo(cls):\n"
                                     "         k = cls()\n"
                                     "         return k\n"
                                     "f = Foo.foo()\n"
                                     "checkme = f\n" << "Foo";
 
     QTest::newRow("tuple_listof") << "l = [(1, 2), (3, 4)]\ncheckme = l[1][0]" << "int";
 
     QTest::newRow("getitem") << "class c:\n def __getitem__(self, slice): return 3.14\na = c()\ncheckme = a[2]" << "float";
     
     QTest::newRow("constructor_type_deduction") << "class myclass:\n"
                                                    "\tdef __init__(self, param): self.foo=param\n"
                                                    "checkme = myclass(3).foo" << "int";
     QTest::newRow("simpe_type_deduction") << "def myfunc(arg): return arg\n"
                                              "checkme = myfunc(3)" << "int";
     QTest::newRow("functionCall_functionArg_part1") << "def getstr(): return \"foo\"\n"
                                                  "def identity(f): return f\n"
                                                  "f1 = getstr\n"
                                                  "checkme = f1()" << "str";
     QTest::newRow("functionCall_functionArg_part2") << "def getstr(): return \"foo\"\n"
                                                  "def identity(f): return f\n"
                                                  "f1 = identity(getstr)\n"
                                                  "checkme = f1()\n" << "str";
     QTest::newRow("functionCall_functionArg_full") << "def getstr(): return \"foo\"\n"
                                                  "def identity(f): return f\n"
                                                  "f1 = getstr\n"
                                                  "f2 = identity(getstr)\n"
                                                  "a = getstr()\n"
                                                  "b = f1()\n"
                                                  "checkme = f2()\n" << "str";
     QTest::newRow("vararg_before_other_args") << "def myfun(a, b, *z, x): return z[0]\n"
                                                  "checkme = myfun(False, False, 1, x = False)" << "int";
     QTest::newRow("vararg_before_other_args2") << "def myfun(a, b, *z, x): return z[3]\n"
                                                   "checkme = myfun(False, False, 1, 2, 3, \"str\", x = False)" << "str";
     QTest::newRow("vararg_constructor") << "class myclass():\n"
                                            "  def __init__(self, *arg): self.prop = arg[0]\n"
                                            "obj = myclass(3, 5); checkme = obj.prop" << "int";
     QTest::newRow("global_variable") << "a = 3\n"
                                         "def f1():\n"
                                         "  global a\n"
                                         "  return a\n"
                                         "checkme = f1()\n" << "int";
     QTest::newRow("global_variable2") << "a = 3\n"
                                         "def f1():\n"
                                         "  global a\n"
                                         "  a = \"str\"\n"
                                         "  return a\n"
                                         "checkme = f1()\n" << "str";
     QTest::newRow("global_scope_variable") << "a = 3\n"
                                         "def f1():\n"
                                         "  return a\n"
                                         "checkme = f1()\n" << "int";
     QTest::newRow("global_no_toplevel_dec") << "def f1():\n"
                                         "  global a\n  a = 3\n"
                                         "  return a\n"
                                         "checkme = f1()\n" << "int";
 
     QTest::newRow("top_level_vs_class_member") << "var = 3\n"
                                                   "class myclass:\n"
                                                   "  def __init__(self): self.var = \"str\"\n"
                                                   "  def f1(): return var\n"
                                                   "checkme = myclass.f1()" << "int";
 }
 
 typedef QPair<Declaration*, int> pair;
 
 void PyDUChainTest::testImportDeclarations() {
     QFETCH(QString, code);
     QFETCH(QStringList, expectedDecls);
     QFETCH(bool, shouldBeAliased);
     
     ReferencedTopDUContext ctx = parse(code.toUtf8());
     QVERIFY(ctx);
     QVERIFY(m_ast);
     
     DUChainReadLocker lock(DUChain::lock());
     foreach ( const QString& expected, expectedDecls ) {
         bool found = false;
         QString name = expected;
         QList<pair> decls = ctx->allDeclarations(CursorInRevision::invalid(), ctx->topContext(), false);
         qCDebug(KDEV_PYTHON_DUCHAIN) << "FOUND DECLARATIONS:";
         foreach ( const pair& current, decls ) {
             qCDebug(KDEV_PYTHON_DUCHAIN) << current.first->toString() << current.first->identifier().identifier().byteArray() << name;
         }
         foreach ( const pair& current, decls ) {
             if ( ! ( current.first->identifier().identifier().byteArray() == name ) ) continue;
             qCDebug(KDEV_PYTHON_DUCHAIN) << "Found: " << current.first->toString() << " for " << name;
             AliasDeclaration* isAliased = dynamic_cast<AliasDeclaration*>(current.first);
             if ( isAliased && shouldBeAliased ) {
                 found = true; // TODO fixme
             }
             else if ( ! isAliased  && ! shouldBeAliased ) {
                 found = true;
             }
         }
         QVERIFY(found);
     }
 }
 
 void PyDUChainTest::testProblemCount()
 {
     QFETCH(QString, code);
     QFETCH(int, problemsCount);
 
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
 
     DUChainReadLocker lock;
     QCOMPARE(ctx->problems().size(), problemsCount);
 }
 
 void PyDUChainTest::testProblemCount_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("problemsCount");
 
     QTest::newRow("list_comp") << "[foo for foo in range(3)]" << 0;
     QTest::newRow("list_comp_wrong") << "[bar for foo in range(3)]" << 1;
     QTest::newRow("list_comp_staticmethod") << "class A:\n @staticmethod\n def func(cls):\n"
                                         "  [a for a in [1, 2, 3]]" << 0;
     QTest::newRow("list_comp_other_decorator") << "def decorate(): pass\nclass A:\n @decorate\n def func(self):\n"
                                         "  [a for a in [1, 2, 3]]" << 0;
     QTest::newRow("list_comp_other_wrong") << "def decorate(): pass\nclass A:\n @decorate\n def func(self):\n"
                                         "  [x for a in [1, 2, 3]]" << 1;
     QTest::newRow("list_comp_staticmethod_wrong") << "class A:\n @staticmethod\n def func(cls):\n"
                                         "  [x for a in [1, 2, 3]]" << 1;
 }
 
 void PyDUChainTest::testImportDeclarations_data() {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QStringList>("expectedDecls");
     QTest::addColumn<bool>("shouldBeAliased");
     
     QTest::newRow("from_import") << "from testImportDeclarations.i import checkme" << ( QStringList() << "checkme" ) << true;
     QTest::newRow("import") << "import testImportDeclarations.i" << ( QStringList() << "testImportDeclarations" ) << false;
     QTest::newRow("import_as") << "import testImportDeclarations.i as checkme" << ( QStringList() << "checkme" ) << false;
     QTest::newRow("from_import_as") << "from testImportDeclarations.i import checkme as checkme" << ( QStringList() << "checkme" ) << true;
     QTest::newRow("from_import_missing") << "from testImportDeclarations.i import missing as checkme" << ( QStringList() ) << true;
 }
 
 typedef QPair<Declaration*, int> p;
 
 void PyDUChainTest::testAutocompletionFlickering()
 {
     TestFile f("foo = 3\nfoo2 = 2\nfo", "py");
     f.parse(TopDUContext::ForceUpdate);
     f.waitForParsed(500);
     
     ReferencedTopDUContext ctx1 = f.topContext();
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(ctx1);
     QList<p> decls1 = ctx1->allDeclarations(CursorInRevision::invalid(), ctx1->topContext());
     QList<DeclarationId> declIds;
     foreach ( p d, decls1 ) {
         declIds << d.first->id();
     }
     lock.unlock();
     
     f.setFileContents("foo = 3\nfoo2 = 2\nfoo");
     f.parse(TopDUContext::ForceUpdate);
     f.waitForParsed(500);
     
     ReferencedTopDUContext ctx2 = f.topContext();
     QVERIFY(ctx2);
     lock.lock();
     QList<p> decls2 = ctx2->allDeclarations(CursorInRevision::invalid(), ctx2->topContext());
     foreach ( p d2, decls2 ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "@1: " << d2.first->toString() << "::" << d2.first->id().hash() << "<>" << declIds.first().hash();
         QVERIFY(d2.first->id() == declIds.first());
         declIds.removeFirst();
     }
     lock.unlock();
     
     qDebug() << "=========================";
     
     TestFile g("def func():\n\tfoo = 3\n\tfoo2 = 2\n\tfo", "py");
     g.parse(TopDUContext::ForceUpdate);
     g.waitForParsed(500);
     
     ctx1 = g.topContext();
     lock.lock();
     QVERIFY(ctx1);
     decls1 = ctx1->allDeclarations(CursorInRevision::invalid(), ctx1->topContext(), false).first().first->internalContext()
                  ->allDeclarations(CursorInRevision::invalid(), ctx1->topContext());
     declIds.clear();
     foreach ( p d, decls1 ) {
         declIds << d.first->id();
     }
     lock.unlock();
     
     g.setFileContents("def func():\n\tfoo = 3\n\tfoo2 = 2\n\tfoo");
     g.parse(TopDUContext::ForceUpdate);
     g.waitForParsed(500);
     
     ctx2 = g.topContext();
     QVERIFY(ctx2);
     lock.lock();
     decls2 = ctx2->allDeclarations(CursorInRevision::invalid(), ctx2->topContext(), false).first().first->internalContext()
                  ->allDeclarations(CursorInRevision::invalid(), ctx2->topContext());
     foreach ( p d2, decls2 ) {
         qCDebug(KDEV_PYTHON_DUCHAIN) << "@2: " << d2.first->toString() << "::" << d2.first->id().hash() << "<>" << declIds.first().hash();
         QVERIFY(d2.first->id() == declIds.first());
         declIds.removeFirst();
     }
     lock.unlock();
 }
 
 void PyDUChainTest::testFunctionHints()
 {
     QFETCH(QString, code);
     QFETCH(QString, expectedType);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainWriteLocker lock;
     QList< Declaration* > decls = ctx->findDeclarations(KDevelop::Identifier("checkme"));
     QVERIFY(! decls.isEmpty());
     Declaration* d = decls.first();
     QVERIFY(d->abstractType());
     QCOMPARE(d->abstractType()->toString(), expectedType);
 }
 
 void PyDUChainTest::testFunctionHints_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("expectedType");
     
     QTest::newRow("func_return_type") << "def myfun(arg) -> int: pass\ncheckme = myfun(\"3\")" << "unsure (void, int)";
     QTest::newRow("argument_type") << "def myfun(arg : int): return arg\ncheckme = myfun(foobar)" << "int";
     QTest::newRow("argument_type_only_if_typeof") << "def myfun(arg : 3): return arg\ncheckme = myfun(foobar)" << "mixed";
 }
 
 void PyDUChainTest::testHintedTypes()
 {
     QFETCH(QString, code);
     QFETCH(QString, expectedType);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainWriteLocker lock;
     QList< Declaration* > decls = ctx->findDeclarations(KDevelop::Identifier("checkme"));
     QVERIFY(! decls.isEmpty());
     Declaration* d = decls.first();
     QVERIFY(d->abstractType());
     QCOMPARE(d->abstractType()->toString(), expectedType);
 }
 
 void PyDUChainTest::testHintedTypes_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("expectedType");
 
     QTest::newRow("simple_hint") << "def myfunc(x): return x\ncheckme = myfunc(3)" << "int";
     QTest::newRow("hint_unsure") << "def myfunc(x): return x\nmyfunc(3.5)\ncheckme = myfunc(3)" << "unsure (float, int)";
     QTest::newRow("unsure_attribute") << "def myfunc(x): return x.capitalize()\nmyfunc(3.5)\ncheckme = myfunc(str())" << "str";
 }
 
 void PyDUChainTest::testDecorators()
 {
     QFETCH(QString, code);
 //     QFETCH(int, amountOfDecorators);
     QFETCH(QStringList, names);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainReadLocker lock(DUChain::lock());
     Python::FunctionDeclaration* decl = dynamic_cast<Python::FunctionDeclaration*>(
         ctx->allDeclarations(CursorInRevision::invalid(), ctx->topContext()).first().first);
     QVERIFY(decl);
     foreach ( const QString& decoratorName, names ) {
         QVERIFY(Helper::findDecoratorByName<Python::FunctionDeclaration>(decl, decoratorName));
     }
 }
 
 void PyDUChainTest::testDecorators_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("amountOfDecorators");
     QTest::addColumn<QStringList>("names");
     
     QTest::newRow("one_decorator") << "@foo\ndef func(): pass" << 1 << ( QStringList() << "foo" );
     QTest::newRow("decorator_with_args") << "@foo(2, \"bar\")\ndef func(): pass" << 1 << ( QStringList() << "foo");
     QTest::newRow("two_decorators") << "@foo\n@bar(17)\ndef func(): pass" << 2 << ( QStringList() << "foo" << "bar" );
 }
 
 void PyDUChainTest::testOperators()
 {
     QFETCH(QString, code);
     QFETCH(QString, expectedType);
     code.prepend("from testOperators.example import *\n\n");
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
 
     DUChainReadLocker lock(DUChain::lock());
     TypeTestVisitor* visitor = new TypeTestVisitor();
     visitor->ctx = TopDUContextPointer(ctx.data());
     visitor->searchingForType = expectedType;
     visitor->visitCode(m_ast.data());
 
     QVERIFY(visitor->found);
 }
 
 void PyDUChainTest::testOperators_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("expectedType");
 
     QTest::newRow("add") << "checkme = Example() + Example()" << "Add";
     QTest::newRow("sub") << "checkme = Example() - Example()" << "Sub";
     QTest::newRow("mul") << "checkme = Example() * Example()" << "Mul";
     QTest::newRow("floordiv") << "checkme = Example() // Example()" << "Floordiv";
     QTest::newRow("mod") << "checkme = Example() % Example()" << "Mod";
     QTest::newRow("pow") << "checkme = Example() ** Example()" << "Pow";
     QTest::newRow("lshift") << "checkme = Example() << Example()" << "Lshift";
     QTest::newRow("rshift") << "checkme = Example() >> Example()" << "Rshift";
     QTest::newRow("and") << "checkme = Example() & Example()" << "And";
     QTest::newRow("xor") << "checkme = Example() ^ Example()" << "Xor";
     QTest::newRow("or") << "checkme = Example() | Example()" << "Or";
 }
 
 void PyDUChainTest::testFunctionArgs()
 {
     ReferencedTopDUContext ctx = parse("def ASDF(arg1, arg2):\n"
                                        "  arg1 = arg2");
     DUChainWriteLocker lock(DUChain::lock());
     QVERIFY(ctx);
     QVERIFY(m_ast);
 //     dumpDUContext(ctx);
 
     QCOMPARE(ctx->childContexts().size(), 2);
     DUContext* funcArgCtx = ctx->childContexts().first();
     QCOMPARE(funcArgCtx->type(), DUContext::Function);
     QCOMPARE(funcArgCtx->localDeclarations().size(), 2);
     QVERIFY(!funcArgCtx->owner());
     
     Python::FunctionDeclaration* decl = dynamic_cast<Python::FunctionDeclaration*>(
                                     ctx->allDeclarations(CursorInRevision::invalid(), ctx->topContext()).first().first);
     QVERIFY(decl);
     QCOMPARE(decl->type<FunctionType>()->arguments().length(), 2);
     qDebug() << decl->type<FunctionType>()->arguments().length() << 2;
 
     DUContext* funcBodyCtx = ctx->childContexts().last();
     QCOMPARE(funcBodyCtx->type(), DUContext::Other);
     QVERIFY(funcBodyCtx->owner());
     QVERIFY(funcBodyCtx->localDeclarations().isEmpty());
 }
 
 void PyDUChainTest::testInheritance()
 {
     QFETCH(QString, code);
     QFETCH(int, expectedBaseClasses);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     DUChainReadLocker lock(DUChain::lock());
     QList<p> decls = ctx->allDeclarations(CursorInRevision::invalid(), ctx->topContext(), false);
     bool found = false;
     bool classDeclFound = false;
     foreach ( const p& item, decls ) {
         if ( item.first->identifier().toString() == "B" ) {
             auto klass = dynamic_cast<Python::ClassDeclaration*>(item.first);
             QVERIFY(klass);
             QCOMPARE(klass->baseClassesSize(), static_cast<unsigned int>(expectedBaseClasses));
             classDeclFound = true;
         }
         if ( item.first->identifier().toString() == "checkme" ) {
             QCOMPARE(item.first->abstractType()->toString(), QString("int"));
             found = true;
         }
     }
     QVERIFY(found);
     QVERIFY(classDeclFound);
 }
 
 void PyDUChainTest::testInheritance_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<int>("expectedBaseClasses");
     
     QTest::newRow("simple") << "class A():\n\tattr = 3\n\nclass B(A):\n\tpass\n\ninst=B()\ncheckme = inst.attr" << 1;
     QTest::newRow("context_import_prereq") << "import testInheritance.i\ninst=testInheritance.i.testclass()\n"
                                               "checkme = inst.attr\nclass B(): pass" << 1; // 1 because object
     QTest::newRow("context_import") << "import testInheritance.i\n\nclass B(testInheritance.i.testclass):\n"
                                        "\ti = 4\n\ninst=B()\ncheckme = inst.attr" << 1;
 }
 
 void PyDUChainTest::testClassContextRanges()
 {
     QString code = "class my_class():\n pass\n \n \n \n \n";
     ReferencedTopDUContext ctx = parse(code);
     DUChainWriteLocker lock;
     DUContext* classContext = ctx->findContextAt(CursorInRevision(5, 0));
     QVERIFY(classContext);
     QVERIFY(classContext->type() == DUContext::Class);
 }
 
 void PyDUChainTest::testContainerTypes()
 {
     QFETCH(QString, code);
     QFETCH(QString, contenttype);
     QFETCH(bool, use_type);
     ReferencedTopDUContext ctx = parse(code);
     QVERIFY(ctx);
     
     DUChainReadLocker lock(DUChain::lock());
     QList<Declaration*> decls = ctx->findDeclarations(QualifiedIdentifier("checkme"));
     QVERIFY(decls.length() > 0);
     QVERIFY(decls.first()->abstractType());
     if ( ! use_type ) {
         auto type = ListType::Ptr::dynamicCast(decls.first()->abstractType());
         QVERIFY(type);
         QVERIFY(type->contentType());
         QCOMPARE(type->contentType().abstractType()->toString(), contenttype);
     }
     else {
         QVERIFY(decls.first()->abstractType());
         QCOMPARE(decls.first()->abstractType()->toString(), contenttype);
     }
 }
 
 void PyDUChainTest::testContainerTypes_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QString>("contenttype");
     QTest::addColumn<bool>("use_type");
     
     QTest::newRow("list_of_int") << "checkme = [1, 2, 3]" << "int" << false;
     QTest::newRow("list_of_int_call") << "checkme = list([1, 2, 3])" << "int" << false;
     QTest::newRow("generator") << "checkme = [i for i in [1, 2, 3]]" << "int" << false;
     QTest::newRow("list_access") << "list = [1, 2, 3]\ncheckme = list[0]" << "int" << true;
     QTest::newRow("set_of_int") << "checkme = {1, 2, 3}" << "int" << false;
     QTest::newRow("set_of_int_call") << "checkme = set({1, 2, 3})" << "int" << false;
     QTest::newRow("set_generator") << "checkme = {i for i in [1, 2, 3]}" << "int" << false;
     QTest::newRow("dict_of_int") << "checkme = {a:1, b:2, c:3}" << "int" << false;
     QTest::newRow("dict_of_int_call") << "checkme = dict({a:1, b:2, c:3})" << "int" << false;
     QTest::newRow("dict_generator") << "checkme = {\"Foo\":i for i in [1, 2, 3]}" << "int" << false;
     QTest::newRow("dict_access") << "list = {a:1, b:2, c:3}\ncheckme = list[0]" << "int" << true;
     QTest::newRow("generator_attribute") << "checkme = [item.capitalize() for item in ['foobar']]" << "str" << false;
     QTest::newRow("cannot_change_type") << "checkme = [\"Foo\", \"Bar\"]" << "str" << false;
     QTest::newRow("cannot_change_type2") << "[1, 2, 3].append(5)\ncheckme = [\"Foo\", \"Bar\"]" << "str" << false;
     
     QTest::newRow("list_append") << "d = []\nd.append(3)\ncheckme = d[0]" << "int" << true;
     QTest::newRow("list_extend") << "d = []; q = [int()]\nd.extend(q)\ncheckme = d[0]" << "int" << true;
 
     QTest::newRow("for_loop") << "d = [3]\nfor item in d:\n checkme = item" << "int" << true;
     QTest::newRow("for_loop_unsure") << "d = [3, \"foo\"]\nfor item in d:\n checkme = item" << "unsure (int, str)" << true;
     QTest::newRow("for_loop_tuple_1") << "d = [(3, 3.5)]\nfor a, b in d:\n checkme = a" << "int" << true;
     QTest::newRow("for_loop_tuple_2") << "d = [(3, 3.5)]\nfor a, b in d:\n checkme = b" << "float" << true;
     QTest::newRow("for_loop_tuple_unsure") << "d = [(3, 3.5), (3.5, 3)]\nfor a, b in d:\n checkme = b"
                                            << "unsure (float, int)" << true;
     // Proposed by Nicolás Alvarez; why not? https://bugs.kde.org/show_bug.cgi?id=359915
     QTest::newRow("comprehension_messy") << "users = {'a':19, 'b':42, 'c':35}\n"
                                             "sorted_list = sorted(users.items(), key=lambda kv: (-kv[1], kv[0]))\n"
                                             "checkme = [k for r,(k,v) in enumerate(sorted_list, 1)]" << "list of str" << true;
+    // From https://bugs.kde.org/show_bug.cgi?id=359912
+    QTest::newRow("subscript_multi") <<
+        "class Middle:\n def __getitem__(self, key):\n  return str()\n"
+        "class Outer:\n def __getitem__(self, key):\n  return Middle()\n"
+        "aaa = Outer()\ncheckme = aaa[0][0]" << "str" << true;
+    QTest::newRow("subscript_func_call") <<
+        "class Foo:\n def __getitem__(self, key):\n  return str()\n"
+        "def bar():\n return Foo()\n"
+        "checkme = bar()[0]" << "str" << true;
 }
 
 void PyDUChainTest::testVariableCreation()
 {
     QFETCH(QString, code);
     QFETCH(QStringList, expected_local_declarations);
     QFETCH(QStringList, expected_types);
 
     ReferencedTopDUContext top = parse(code);
     QVERIFY(top);
 
     DUChainReadLocker lock;
     auto localDecls = top->localDeclarations();
     QVector<QString> localDeclNames;
     for ( const Declaration* d: localDecls ) {
         localDeclNames.append(d->identifier().toString());
     }
     Q_ASSERT(expected_types.size() == expected_local_declarations.size());
     int offset = 0;
     for ( const QString& expected : expected_local_declarations ) {
         int index = localDeclNames.indexOf(expected);
         QVERIFY(index != -1);
         QVERIFY(localDecls[index]->abstractType());
         QCOMPARE(localDecls[index]->abstractType()->toString(), expected_types[offset]);
         offset++;
     }
 }
 
 void PyDUChainTest::testVariableCreation_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<QStringList>("expected_local_declarations");
     QTest::addColumn<QStringList>("expected_types");
 
     QTest::newRow("simple") << "a = 3" << QStringList{"a"} << QStringList{"int"};
     QTest::newRow("tuple_wrong") << "a, b = 3" << QStringList{"a", "b"} << QStringList{"mixed", "mixed"};
     QTest::newRow("tuple_unpack_inplace") << "a, b = 3, 5.5" << QStringList{"a", "b"} << QStringList{"int", "float"};
     QTest::newRow("tuple_unpack_indirect") << "c = 3, 3.5\na, b = c" << QStringList{"a", "b"} << QStringList{"int", "float"};
     QTest::newRow("tuple_unpack_stacked_inplace") << "a, (b, c) = 1, (2, 3.5)" << QStringList{"a", "b", "c"}
                                                                              << QStringList{"int", "int", "float"};
     QTest::newRow("tuple_unpack_stacked_indirect") << "d = 3.5, (3, 1)\na, (b, c) = d"
                                                    << QStringList{"a", "b", "c"} << QStringList{"float", "int", "int"};
     QTest::newRow("unpack_from_list_inplace") << "a, b = [1, 2, 3]" << QStringList{"a", "b"} << QStringList{"int", "int"};
     QTest::newRow("unpack_from_list_indirect") << "c = [1, 2, 3]\na, b = c" << QStringList{"a", "b"}
                                                                             << QStringList{"int", "int"};
     QTest::newRow("for_loop_simple") << "for i in range(3): pass" << QStringList{"i"} << QStringList{"int"};
     QTest::newRow("for_loop_unpack") << "for a, b in [(3, 5.1)]: pass" << QStringList{"a", "b"}
                                                                        << QStringList{"int", "float"};
     QTest::newRow("for_loop_stacked") << "for a, (b, c) in [(1, (2, 3.5))]: pass" << QStringList{"a", "b", "c"}
                                                                                 << QStringList{"int", "int", "float"};
     QTest::newRow("for_loop_tuple") << "for a in 1, 2: pass" << QStringList{"a"} << QStringList{"int"};
     QTest::newRow("for_loop_dict") << "for a in {'foo': 1}: pass" << QStringList{"a"} << QStringList{"str"};
 }
 
 void PyDUChainTest::testCleanupMultiplePasses()
 {
     for ( int j = 0; j < 20; j++ ) {
         ReferencedTopDUContext top = parse("from testCleanupMultiplePasses import foo\ndef fonc(): return 3+2j\nfoo.foo.func = fonc");
     }
 }
 
 void PyDUChainTest::testManyDeclarations()
 {
     ReferencedTopDUContext top = parse("from testManyDeclarations import test\nk=test.Foo()");
 }
 
 void PyDUChainTest::testComments()
 {
     QFETCH(QString, code);
 
     auto top = parse(code);
     QVERIFY(top);
     DUChainReadLocker lock;
 
     auto decls = top->findDeclarations(QualifiedIdentifier("a"));
     QCOMPARE(decls.size(), 1);
     auto a = decls.first();
     QCOMPARE(a->comment(), QByteArray("comment"));
 
     decls = top->findDeclarations(QualifiedIdentifier("b"));
     if ( decls.isEmpty() ) {
         decls = top->childContexts().last()->findDeclarations(QualifiedIdentifier("b"));
     }
     auto b = decls.first();
     QCOMPARE(b->comment(), QByteArray());
 }
 
 void PyDUChainTest::testComments_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::newRow("variable") << "b=5\n\"\"\"comment\"\"\"\na=5\nb=5";
     QTest::newRow("function") << "def a():\n    \"\"\"comment\"\"\"\n    b=5";
     QTest::newRow("class") << "class a:\n    \"\"\"comment\"\"\"\n    b=5";
 }