import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
public PsiElement resolveImportReference(QualifiedName name, PyQualifiedNameResolveContext context, boolean withRoots) {
  if (StudyTaskManager.getInstance(context.getProject()).getCourse() == null) {
    return null;
  }
  final String nameString = name.toString();
  PsiFile containingFile = context.getFootholdFile();
  if (containingFile == null) return null;

  final PsiDirectory directory = containingFile.getContainingDirectory();
  if (directory == null) return null;
  final PsiFile file = directory.findFile(nameString + ".py");
  if (file != null) {
    return file;
  }

  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
public PsiElement resolveImportReference(QualifiedName name, QualifiedNameResolveContext context, boolean withRoots) {
  if (StudyTaskManager.getInstance(context.getProject()).getCourse() == null) {
    return null;
  }
  final String nameString = name.toString();
  PsiFile containingFile = context.getFootholdFile();
  if (containingFile == null) return null;

  final PsiDirectory directory = containingFile.getContainingDirectory();
  if (directory == null) return null;
  final PsiFile file = directory.findFile(nameString + ".py");
  if (file != null) {
    return file;
  }

  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
public PsiElement resolveImportReference(QualifiedName name, QualifiedNameResolveContext context, boolean withRoots) {
  String fqn = name.toString();
  final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(context.getProject());
  final PsiPackage aPackage = psiFacade.findPackage(fqn);
  if (aPackage != null) {
    return aPackage;
  }

  Module module = context.getModule();
  if (module != null) {
    final PsiClass aClass = psiFacade.findClass(fqn, module.getModuleWithDependenciesAndLibrariesScope(false));
    if (aClass != null) return aClass;
  }
  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
@Override
public PyType getCallableType(@NotNull PyCallable callable, @NotNull TypeEvalContext context) {
  if (callable instanceof PyFunction) {
    final String qualifiedName = callable.getQualifiedName();
    if (qualifiedName != null && qualifiedName.startsWith("PyQt")){
      final QualifiedName name = QualifiedName.fromDottedString(qualifiedName);
      final String qtVersion = name.getComponents().get(0);
      final String docstring = ((PyFunction)callable).getDocStringValue();
      if (docstring != null && docstring.contains("[signal]")) {
        final PyClass aClass = PyClassNameIndex.findClass(qtVersion + "." + ourQtBoundSignal, callable.getProject());
        if (aClass != null)
          return new PyClassTypeImpl(aClass, false);
      }
    }
  }
  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Override
public final void addImportCandidates(
    PsiReference reference, String name, AutoImportQuickFix quickFix) {
  Project project = reference.getElement().getProject();
  PySourcesIndex index = getSourcesIndex(project);
  if (index == null) {
    return;
  }
  PsiManager psiManager = PsiManager.getInstance(project);
  for (QualifiedName candidate : index.shortNames.get(name)) {
    PsiElementProvider resolver = index.sourceMap.get(candidate);
    if (resolver == null) {
      continue;
    }
    PsiElement psi = resolver.get(psiManager);
    if (psi == null) {
      continue;
    }
    PsiFile file = psi.getContainingFile();
    if (file != null) {
      quickFix.addImport(psi, file, candidate.removeLastComponent());
    }
  }
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public PyClassStub createStub(@NotNull final PyClass psi, final StubElement parentStub) {
  final PyExpression[] exprs = psi.getSuperClassExpressions();
  List<QualifiedName> superClasses = new ArrayList<QualifiedName>();
  for (PyExpression expression : exprs) {
    if (expression instanceof PyKeywordArgument) {
      continue;
    }
    expression = PyClassImpl.unfoldClass(expression);
    superClasses.add(PyPsiUtils.asQualifiedName(expression));
  }
  final PyStringLiteralExpression docStringExpression = psi.getDocStringExpression();
  return new PyClassStubImpl(psi.getName(), parentStub,
                             superClasses.toArray(new QualifiedName[superClasses.size()]),
                             PyPsiUtils.asQualifiedName(psi.getMetaClassExpression()),
                             psi.getOwnSlots(),
                             PyPsiUtils.strValue(docStringExpression),
                             getStubElementType());
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
/**
 * Helper method that builds an import path, handling all these "import foo", "import foo as bar", "from bar import foo", etc.
 * Either importPath or importSource must be not null.
 *
 * @param name       what is ultimately imported.
 * @param importPath known path to import the name.
 * @param source     known ImportElement to import the name; its 'as' clause is used if present.
 * @return a properly qualified name.
 */
@NotNull
public static String getQualifiedName(@NotNull String name, @Nullable QualifiedName importPath, @Nullable PyImportElement source) {
  final StringBuilder sb = new StringBuilder();
  if (source != null) {
    final PsiElement parent = source.getParent();
    if (parent instanceof PyFromImportStatement) {
      sb.append(name);
    }
    else {
      sb.append(source.getVisibleName()).append(".").append(name);
    }
  }
  else {
    if (importPath != null && importPath.getComponentCount() > 0) {
      sb.append(importPath).append(".");
    }
    sb.append(name);
  }
  return sb.toString();
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
private static QualifiedName findImportableName(@NotNull PyFile file) {
  final VirtualFile moduleVirtualFile = file.getVirtualFile();
  if (moduleVirtualFile != null) {
    String moduleName = QualifiedNameFinder.findShortestImportableName(file, moduleVirtualFile);
    if (moduleName != null) {
      final QualifiedName qName = QualifiedName.fromDottedString(moduleName);
      for (PyCanonicalPathProvider provider : Extensions.getExtensions(PyCanonicalPathProvider.EP_NAME)) {
        final QualifiedName restored = provider.getCanonicalPath(qName, null);
        if (restored != null) {
          return restored;
        }
      }
      return qName;
    }
  }
  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
@Override
public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
  if (element.equals(resolve())) {
    return element;
  }
  if (myElement instanceof PyStringLiteralExpression && element instanceof PyClass) {
    final PyStringLiteralExpression e = (PyStringLiteralExpression)myElement;
    final PyClass cls = (PyClass)element;
    QualifiedName qname = QualifiedNameFinder.findCanonicalImportPath(cls, element);
    if (qname != null) {
      qname = qname.append(cls.getName());
      ElementManipulator<PyStringLiteralExpression> manipulator = ElementManipulators.getManipulator(e);
      myType = new PyClassTypeImpl(cls, false);
      return manipulator.handleContentChange(e, myFullRange, qname.toString());
    }
  }
  return null;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Override
public void promptToConfigureDocumentation(@NotNull PsiElement element) {
  final Project project = element.getProject();
  final QualifiedName qName = QualifiedNameFinder.findCanonicalImportPath(element, element);
  if (qName != null && qName.getComponentCount() > 0) {
    ApplicationManager.getApplication().invokeLater(new Runnable() {
      @Override
      public void run() {
        final int rc = Messages.showOkCancelDialog(project,
                                                   "No external documentation URL configured for module " + qName.getComponents().get(0) +
                                                   ".\nWould you like to configure it now?",
                                                   "Python External Documentation",
                                                   Messages.getQuestionIcon());
        if (rc == Messages.OK) {
          ShowSettingsUtilImpl.showSettingsDialog(project, PythonDocumentationConfigurable.ID, "");
        }
      }
    }, ModalityState.NON_MODAL);
  }
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
private static Collection<PyExpression> collectAssignedAttributes(PyQualifiedExpression qualifier) {
  final Set<String> names = new HashSet<String>();
  final QualifiedName qualifierQName = qualifier.asQualifiedName();
  if (qualifierQName != null) {
    final List<PyExpression> results = new ArrayList<PyExpression>();
    for (ScopeOwner owner = ScopeUtil.getScopeOwner(qualifier); owner != null; owner = ScopeUtil.getScopeOwner(owner)) {
      final Scope scope = ControlFlowCache.getScope(owner);
      for (PyTargetExpression target : scope.getTargetExpressions()) {
        final QualifiedName targetQName = target.asQualifiedName();
        if (targetQName != null) {
          if (targetQName.getComponentCount() == qualifierQName.getComponentCount() + 1 && targetQName.matchesPrefix(qualifierQName)) {
            final String name = target.getName();
            if (!names.contains(name)) {
              names.add(name);
              results.add(target);
            }
          }
        }
      }
    }
    return results;
  }
  return Collections.emptyList();
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Override
public void visitPyImportElement(PyImportElement node) {
  final String asName = node.getAsName();
  final QualifiedName importedQName = node.getImportedQName();
  if (importedQName == null) return;
  final String name = importedQName.getLastComponent();

  if (asName == null || name == null) return;
  if (UPPERCASE_REGEX.matcher(name).matches()) {
    if (!UPPERCASE_REGEX.matcher(asName).matches()) {
      registerAndAddRenameQuickFix(node.getAsNameElement(), "Constant variable imported as non constant");
    }
  }
  else if (LOWERCASE_REGEX.matcher(name).matches()) {
    if (!LOWERCASE_REGEX.matcher(asName).matches()) {
      registerAndAddRenameQuickFix(node.getAsNameElement(), "Lowercase variable imported as non lowercase");
    }
  }
  else if (LOWERCASE_REGEX.matcher(asName).matches()) {
    registerAndAddRenameQuickFix(node.getAsNameElement(), "CamelCase variable imported as lowercase");
  }
  else if (UPPERCASE_REGEX.matcher(asName).matches()) {
    registerAndAddRenameQuickFix(node.getAsNameElement(), "CamelCase variable imported as constant");
  }
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
@Nullable
private static PsiElement resolveModuleAt(
    @Nullable PsiDirectory directory,
    QualifiedName qualifiedName,
    PyQualifiedNameResolveContext context) {
  if (directory == null || !directory.isValid()) {
    return null;
  }
  PsiElement seeker = directory;
  for (String name : qualifiedName.getComponents()) {
    if (name == null) {
      return null;
    }
    seeker =
        ResolveImportUtil.resolveChild(
            seeker, name, context.getFootholdFile(), false, true, false);
  }
  return seeker;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public boolean visitRoot(final VirtualFile root, @Nullable Module module, @Nullable Sdk sdk, boolean isModuleSource) {
  if (!root.isValid()) {
    return true;
  }
  if (root.equals(PyUserSkeletonsUtil.getUserSkeletonsDirectory())) {
    return true;
  }
  PsiElement resolveResult = resolveInRoot(root);
  if (resolveResult != null) {
    addRoot(resolveResult, isModuleSource);
  }

  if (isAcceptRootAsTopLevelPackage() && myQualifiedName.matchesPrefix(QualifiedName.fromDottedString(root.getName()))) {
    resolveResult = resolveInRoot(root.getParent());
    if (resolveResult != null) {
      addRoot(resolveResult, isModuleSource);
    }
  }

  return true;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
/**
 * Resolve relative imports from sdk root to the skeleton dir
 */
private void addRelativeImportResultsFromSkeletons(@NotNull final PsiFile foothold) {
  final boolean inSource = FileIndexFacade.getInstance(foothold.getProject()).isInContent(foothold.getVirtualFile());
  if (inSource) return;
  PsiDirectory containingDirectory = foothold.getContainingDirectory();
  if (myRelativeLevel > 0) {
    containingDirectory = ResolveImportUtil.stepBackFrom(foothold, myRelativeLevel);
  }
  if (containingDirectory != null) {
    final QualifiedName containingQName = QualifiedNameFinder.findCanonicalImportPath(containingDirectory, null);
    if (containingQName != null && containingQName.getComponentCount() > 0) {
      final QualifiedName absoluteQName = containingQName.append(myQualifiedName.toString());
      final QualifiedNameResolverImpl absoluteVisitor =
        (QualifiedNameResolverImpl)new QualifiedNameResolverImpl(absoluteQName).fromElement(foothold);

      final Sdk sdk = PythonSdkType.getSdk(foothold);
      if (sdk == null) return;
      final VirtualFile skeletonsDir = PySdkUtil.findSkeletonsDir(sdk);
      if (skeletonsDir == null) return;
      final PsiDirectory directory = myContext.getPsiManager().findDirectory(skeletonsDir);
      final PsiElement psiElement = absoluteVisitor.resolveModuleAt(directory);
      if (psiElement != null)
        myLibResults.add(psiElement);
    }
  }
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public static List<RatedResolveResult> resolveNameInFromImport(PyFromImportStatement importStatement, @NotNull QualifiedName qName) {
  PsiFile file = importStatement.getContainingFile().getOriginalFile();
  String name = qName.getComponents().get(0);

  final List<PsiElement> candidates = importStatement.resolveImportSourceCandidates();
  List<PsiElement> resultList = new ArrayList<PsiElement>();
  for (PsiElement candidate : candidates) {
    if (!candidate.isValid()) {
      throw new PsiInvalidElementAccessException(candidate, "Got an invalid candidate from resolveImportSourceCandidates(): " + candidate.getClass());
    }
    if (candidate instanceof PsiDirectory) {
      candidate = PyUtil.getPackageElement((PsiDirectory)candidate, importStatement);
    }
    PsiElement result = resolveChild(candidate, name, file, false, true);
    if (result != null) {
      if (!result.isValid()) {
        throw new PsiInvalidElementAccessException(result, "Got an invalid candidate from resolveChild(): " + result.getClass());
      }
      resultList.add(result);
    }
  }
  if (!resultList.isEmpty()) {
    return rateResults(resultList);
  }
  return Collections.emptyList();
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
private int getImplicitResultRate(PyElement target, List<QualifiedName> imports) {
  int rate = RatedResolveResult.RATE_LOW;
  if (target.getContainingFile() == myElement.getContainingFile()) {
    rate += 200;
  }
  else {
    final VirtualFile vFile = target.getContainingFile().getVirtualFile();
    if (vFile != null) {
      if (ProjectScope.getProjectScope(myElement.getProject()).contains(vFile)) {
        rate += 80;
      }
      final QualifiedName qName = QualifiedNameFinder.findShortestImportableQName(myElement, vFile);
      if (qName != null && imports.contains(qName)) {
        rate += 70;
      }
    }
  }
  if (myElement.getParent() instanceof PyCallExpression) {
    if (target instanceof PyFunction) rate += 50;
  }
  else {
    if (!(target instanceof PyFunction)) rate += 50;
  }
  return rate;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public void testImportStatement() {
  final PyFileImpl file = (PyFileImpl) getTestFile();

  final List<PyFromImportStatement> fromImports = file.getFromImports();
  assertEquals(1, fromImports.size());
  final PyFromImportStatement fromImport = fromImports.get(0);
  final PyImportElement[] importElements = fromImport.getImportElements();
  assertEquals(1, importElements.length);
  assertEquals("argv", importElements [0].getVisibleName());
  assertFalse(fromImport.isStarImport());
  assertEquals(0, fromImport.getRelativeLevel());
  final QualifiedName qName = fromImport.getImportSourceQName();
  assertSameElements(qName.getComponents(), "sys");

  final List<PyImportElement> importTargets = file.getImportTargets();
  assertEquals(1, importTargets.size());
  final PyImportElement importElement = importTargets.get(0);
  final QualifiedName importQName = importElement.getImportedQName();
  assertSameElements(importQName.getComponents(), "os", "path");

  assertNotParsed(file);
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public boolean visitRoot(VirtualFile root, Module module, Sdk sdk, boolean isModuleSource) {
  if (myVFile != null) {
    final String relativePath = VfsUtilCore.getRelativePath(myVFile, root, '/');
    if (relativePath != null && !relativePath.isEmpty()) {
      List<String> result = StringUtil.split(relativePath, "/");
      if (result.size() > 0) {
        result.set(result.size() - 1, FileUtil.getNameWithoutExtension(result.get(result.size() - 1)));
      }
      for (String component : result) {
        if (!PyNames.isIdentifier(component)) {
          return true;
        }
      }
      myResults.add(QualifiedName.fromComponents(result));
    }
  }
  return true;
}
 

import com.intellij.psi.util.QualifiedName; //导入依赖的package包/类
public QualifiedName getImportSourceQName() {
  final PyFromImportStatementStub stub = getStub();
  if (stub != null) {
    final QualifiedName qName = stub.getImportSourceQName();
    if (qName != null && qName.getComponentCount() == 0) {  // relative import only: from .. import the_name
      return null;
    }
    return qName;
  }

  final PyReferenceExpression importSource = getImportSource();
  if (importSource == null) {
    return null;
  }
  return importSource.asQualifiedName();
}