@Nullable
 private PyType resolveQualifierType(
     @NotNull List<Token<PyElementType>> tokens,
     @NotNull PyFile file,
     @NotNull TypeEvalContext context,
     @NotNull Map<TextRange, PyType> types,
     @NotNull Map<PyType, TextRange> fullRanges,
     @NotNull Map<PyType, PyImportElement> imports) {
   if (tokens.isEmpty()) {
     return null;
   }
   final Token<PyElementType> firstToken = tokens.get(0);
   final String firstText = firstToken.getText().toString();
   final TextRange firstRange = firstToken.getRange();
   final List<RatedResolveResult> resolveResults = file.multiResolveName(firstText);
   if (resolveResults.isEmpty()) {
     return getImplicitlyResolvedType(tokens, context, types, fullRanges, firstRange);
   }
   final List<PyType> members = Lists.newArrayList();
   for (RatedResolveResult result : resolveResults) {
     final PsiElement resolved = result.getElement();
     PyType type = null;
     if (resolved instanceof PyTargetExpression) {
       type =
           PyTypingTypeProvider.getTypeFromTargetExpression(
               (PyTargetExpression) resolved, context);
     }
     if (type == null && resolved instanceof PyTypedElement) {
       type = context.getType((PyTypedElement) resolved);
     }
     if (type != null) {
       if (!allowResolveToType(type)) {
         continue;
       }
       if (type instanceof PyClassLikeType) {
         type = ((PyClassLikeType) type).toInstance();
       }
       types.put(firstRange, type);
       fullRanges.put(type, firstRange);
       for (PyFromImportStatement fromImportStatement : file.getFromImports()) {
         for (PyImportElement importElement : fromImportStatement.getImportElements()) {
           if (firstText.equals(importElement.getVisibleName())) {
             imports.put(type, importElement);
           }
         }
       }
       for (PyImportElement importElement : file.getImportTargets()) {
         if (firstText.equals(importElement.getVisibleName())) {
           imports.put(type, importElement);
         }
       }
     }
     members.add(type);
   }
   if (!members.isEmpty()) {
     tokens.remove(0);
   }
   return PyUnionType.union(members);
 }
 @Override
 public Collection<AbstractTreeNode> getChildrenImpl() {
   PyFile value = (PyFile) getValue();
   List<AbstractTreeNode> children = new ArrayList<AbstractTreeNode>();
   for (PyClass child : value.getTopLevelClasses()) {
     children.add(new PyElementNode(myProject, child, getSettings()));
   }
   for (PyFunction function : value.getTopLevelFunctions()) {
     children.add(new PyElementNode(myProject, function, getSettings()));
   }
   return children;
 }
 public static boolean isAbsoluteImportEnabledFor(PsiElement foothold) {
   if (foothold != null) {
     PsiFile file = foothold.getContainingFile();
     if (file instanceof PyFile) {
       final PyFile pyFile = (PyFile) file;
       if (pyFile.getLanguageLevel().isPy3K()) {
         return true;
       }
       return pyFile.hasImportFromFuture(ABSOLUTE_IMPORT);
     }
   }
   // if the relevant import is below the foothold, it is either legal or we've detected the
   // offending statement already
   return false;
 }
 @Nullable
 @Override
 public List<? extends RatedResolveResult> resolveMember(
     @NotNull String name,
     @Nullable PyExpression location,
     @NotNull AccessDirection direction,
     @NotNull PyResolveContext resolveContext) {
   final PsiElement resolved = myImportedModule.resolve();
   if (resolved != null) {
     final PsiFile containingFile = location != null ? location.getContainingFile() : null;
     List<PsiElement> elements =
         Collections.singletonList(
             ResolveImportUtil.resolveChild(resolved, name, containingFile, false, true));
     final PyImportElement importElement = myImportedModule.getImportElement();
     final PyFile resolvedFile = PyUtil.as(resolved, PyFile.class);
     if (location != null
         && importElement != null
         && PyUtil.inSameFile(location, importElement)
         && ResolveImportUtil.getPointInImport(location) == PointInImport.NONE
         && resolved instanceof PsiFileSystemItem
         && (resolvedFile == null
             || !PyUtil.isPackage(resolvedFile)
             || resolvedFile.getElementNamed(name) == null)) {
       final List<PsiElement> importedSubmodules =
           PyModuleType.collectImportedSubmodules((PsiFileSystemItem) resolved, location);
       if (importedSubmodules != null) {
         final Set<PsiElement> imported = Sets.newHashSet(importedSubmodules);
         elements =
             ContainerUtil.filter(
                 elements,
                 new Condition<PsiElement>() {
                   @Override
                   public boolean value(PsiElement element) {
                     return imported.contains(element);
                   }
                 });
       }
     }
     return ResolveImportUtil.rateResults(elements);
   }
   return null;
 }
 private void addModulePath(PyFile followed) {
   // what to prepend to a module description?
   final VirtualFile file = followed.getVirtualFile();
   if (file == null) {
     myProlog.addWith(TagSmall, $(PyBundle.message("QDOC.module.path.unknown")));
   } else {
     final String path = file.getPath();
     RootFinder finder = new RootFinder(path);
     RootVisitorHost.visitRoots(followed, finder);
     final String rootPath = finder.getResult();
     if (rootPath != null) {
       String afterPart = path.substring(rootPath.length());
       myProlog.addWith(TagSmall, $(rootPath).addWith(TagBold, $(afterPart)));
     } else {
       myProlog.addWith(TagSmall, $(path));
     }
   }
 }