private Collection<JSQualifiedNamedElement> getCandidates(Editor editor, PsiFile file) {
    final Collection<JSQualifiedNamedElement> candidates;

    if (myReference instanceof JSReferenceExpression
        && ((JSReferenceExpression) myReference).getQualifier() == null) {
      Collection<JSQualifiedNamedElement> c =
          getCandidates(editor, file, myReference.getCanonicalText());
      filterCandidates(c);
      candidates = new THashSet<>(c, JSPsiImplUtils.QUALIFIED_NAME_HASHING_STRATEGY);
    } else {
      JSQualifiedNamedElement invalidResult = null;

      for (ResolveResult r : myReference.multiResolve(false)) {
        PsiElement element = r.getElement();
        if (element instanceof JSQualifiedNamedElement) {
          invalidResult = (JSQualifiedNamedElement) element;
        }
      }
      if (invalidResult != null) {
        if (myReference.getElement().getParent() instanceof JSNewExpression
            && invalidResult instanceof JSFunction
            && ((JSFunction) invalidResult).isConstructor()) {
          invalidResult = (JSClass) invalidResult.getParent();
        }
        candidates = new SmartList<>();
        candidates.add(invalidResult);
      } else {
        candidates = Collections.emptyList();
      }
    }
    return candidates;
  }
  @Nullable
  static HighlightInfo checkModuleReference(@Nullable PsiJavaModuleReferenceElement refElement) {
    if (refElement != null) {
      PsiPolyVariantReference ref = refElement.getReference();
      assert ref != null : refElement.getParent();
      if (ref.multiResolve(false).length == 0) {
        String message =
            JavaErrorMessages.message("module.ref.unknown", refElement.getReferenceText());
        return HighlightInfo.newHighlightInfo(HighlightInfoType.WRONG_REF)
            .range(refElement)
            .description(message)
            .create();
      }
    }

    return null;
  }
  public boolean isAvailable(
      @NotNull final Project project, final Editor editor, final PsiFile file) {
    if (!myReference.getElement().isValid()) return false;
    final long modL =
        myReference.getElement().getManager().getModificationTracker().getModificationCount();

    if (!isAvailableCalculated || modL != modificationCount) {
      final ResolveResult[] results = myReference.multiResolve(false);
      boolean hasValidResult = false;

      for (ResolveResult r : results) {
        if (r.isValidResult()) {
          hasValidResult = true;
          break;
        }
      }

      if (!hasValidResult) {
        final Collection<JSQualifiedNamedElement> candidates = getCandidates(editor, file);

        isAvailableCalculated = true;
        isAvailable = candidates.size() > 0;
        String text;

        if (isAvailable) {
          final JSQualifiedNamedElement element = candidates.iterator().next();
          text = element.getQualifiedName() + "?";
          if (candidates.size() > 1) text += " (multiple choices...)";
          if (!ApplicationManager.getApplication().isHeadlessEnvironment()) {
            text += " Alt+Enter";
          }
        } else {
          text = "";
        }
        myText = text;
      } else {
        isAvailableCalculated = true;
        isAvailable = false;
        myText = "";
      }

      modificationCount = modL;
    }

    return isAvailable;
  }
  private void doTest() throws Exception {
    PsiPolyVariantReference reference =
        (PsiPolyVariantReference) configureByFile(getTestName(true) + ".kt");
    PsiElement resolved = reference.resolve();
    assertNotNull(resolved);
    assertEquals(1, reference.multiResolve(false).length);

    List<PsiComment> comments = PsiTreeUtil.getChildrenOfTypeAsList(getFile(), PsiComment.class);
    String[] expectedTarget = comments.get(comments.size() - 1).getText().substring(2).split(":");
    assertEquals(2, expectedTarget.length);
    String expectedFile = expectedTarget[0];
    String expectedName = expectedTarget[1];

    PsiFile targetFile = resolved.getContainingFile();
    PsiDirectory targetDir = targetFile.getParent();
    assertNotNull(targetDir);
    assertEquals(expectedFile, targetDir.getName() + "/" + targetFile.getName());
    assertInstanceOf(resolved, PsiNamedElement.class);
    assertEquals(expectedName, ((PsiNamedElement) resolved).getName());
  }