Java Code Examples for com.intellij.psi.PsiFile#getProject()

@Override
public void highlightsOutsideVisiblePartAreProduced(@Nonnull final HighlightingSession session,
                                                    @Nullable Editor editor,
                                                    @Nonnull final List<? extends HighlightInfo> infos,
                                                    @Nonnull final TextRange priorityRange,
                                                    @Nonnull final TextRange restrictedRange, final int groupId) {
  final PsiFile psiFile = session.getPsiFile();
  final Project project = psiFile.getProject();
  final Document document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
  if (document == null) return;
  final long modificationStamp = document.getModificationStamp();
  ((HighlightingSessionImpl)session).applyInEDT(() -> {
    if (project.isDisposed() || modificationStamp != document.getModificationStamp()) return;

    EditorColorsScheme scheme = session.getColorsScheme();

    UpdateHighlightersUtil
            .setHighlightersOutsideRange(project, document, psiFile, infos, scheme, restrictedRange.getStartOffset(), restrictedRange.getEndOffset(), ProperTextRange.create(priorityRange), groupId);
    if (editor != null) {
      repaintErrorStripeAndIcon(editor, project);
    }
  });
}
 

@Nullable
public static RelatedItemLineMarkerInfo<PsiElement> getFileImplementsLineMarker(@NotNull PsiFile psiFile) {
    final Project project = psiFile.getProject();

    VirtualFile virtualFile = psiFile.getVirtualFile();
    if(virtualFile == null) {
        return null;
    }

    String bundleLocateName = FileResourceUtil.getBundleLocateName(project, virtualFile);
    if(bundleLocateName == null) {
        return null;
    }

    if(FileResourceUtil.getFileResourceRefers(project, bundleLocateName).size() == 0) {
        return null;
    }

    NavigationGutterIconBuilder<PsiElement> builder = NavigationGutterIconBuilder.create(PhpIcons.IMPLEMENTS).
        setTargets(new FileResourceUtil.FileResourceNotNullLazyValue(project, bundleLocateName)).
        setTooltipText("Navigate to resource");

    return builder.createLineMarkerInfo(psiFile);
}
 

@Nonnull
public static String getFileFqn(final PsiFile file) {
  final VirtualFile virtualFile = file.getVirtualFile();
  if (virtualFile == null) {
    return file.getName();
  }
  final Project project = file.getProject();
  final LogicalRoot logicalRoot = LogicalRootsManager.getLogicalRootsManager(project).findLogicalRoot(virtualFile);
  if (logicalRoot != null) {
    String logical = FileUtil.toSystemIndependentName(VfsUtil.virtualToIoFile(logicalRoot.getVirtualFile()).getPath());
    String path = FileUtil.toSystemIndependentName(VfsUtil.virtualToIoFile(virtualFile).getPath());
    return "/" + FileUtil.getRelativePath(logical, path, '/');
  }

  final VirtualFile contentRoot = ProjectRootManager.getInstance(project).getFileIndex().getContentRootForFile(virtualFile);
  if (contentRoot != null) {
    return "/" + FileUtil.getRelativePath(VfsUtil.virtualToIoFile(contentRoot), VfsUtil.virtualToIoFile(virtualFile));
  }
  return virtualFile.getPath();
}
 

private static void removeUnusedCode(PsiFile file) {
	while (true) {
		Collection<PsiElement> toDelete = new ArrayList<>();
		Project project = file.getProject();
		SearchScope scope = GlobalSearchScope.fileScope(project, file.getVirtualFile());
		file.acceptChildren(new DeletionMarkingVisitor(toDelete, scope));
		if (toDelete.isEmpty()) {
			break;
		}
		WriteCommandAction.writeCommandAction(project).run(
				() -> {
					for (PsiElement element : toDelete) {
						element.delete();
					}
				}
		);

	}
}
 

protected boolean supportsFileType(PsiFile file)
{
    if(file == null || file.getProject() == null)
    {
        return false;
    }

    DojoSettings settings = ServiceManager.getService(file.getProject(), DojoSettings.class);
    String[] fileTypes = settings.getSupportedFileTypes().split(",");
    for(String type : fileTypes)
    {
        if(type.trim().equals(file.getVirtualFile().getExtension()))
        {
            return true;
        }
    }

    return false;
}
 

@Override
public boolean preparePsiElementsForWrite(@Nonnull Collection<? extends PsiElement> elements) {
  if (elements.isEmpty()) return true;
  Set<VirtualFile> files = new THashSet<VirtualFile>();
  Project project = null;
  for (PsiElement element : elements) {
    if (element == null) continue;
    PsiFile file = element.getContainingFile();
    if (file == null || !file.isPhysical()) continue;
    project = file.getProject();
    VirtualFile virtualFile = file.getVirtualFile();
    if (virtualFile == null) continue;
    files.add(virtualFile);
  }
  if (!files.isEmpty()) {
    VirtualFile[] virtualFiles = VfsUtilCore.toVirtualFileArray(files);
    ReadonlyStatusHandler.OperationStatus status = ReadonlyStatusHandler.getInstance(project).ensureFilesWritable(virtualFiles);
    return !status.hasReadonlyFiles();
  }
  return true;
}
 

@Override
public void collectActions(@Nonnull Editor hostEditor, @Nonnull PsiFile hostFile, @Nonnull ShowIntentionsPass.IntentionsInfo intentions, int passIdToShowIntentionsFor, int offset) {
  Project project = hostFile.getProject();
  final PsiElement psiElement = hostFile.findElementAt(offset);
  if (HighlightingLevelManager.getInstance(project).shouldInspect(hostFile)) {
    PsiElement intentionElement = psiElement;
    int intentionOffset = offset;
    if (psiElement instanceof PsiWhiteSpace && offset == psiElement.getTextRange().getStartOffset() && offset > 0) {
      final PsiElement prev = hostFile.findElementAt(offset - 1);
      if (prev != null && prev.isValid()) {
        intentionElement = prev;
        intentionOffset = offset - 1;
      }
    }
    if (intentionElement != null && intentionElement.getManager().isInProject(intentionElement)) {
      collectIntentionsFromDoNotShowLeveledInspections(project, hostFile, intentionElement, intentionOffset, intentions);
    }
  }
}
 

public static PsiElement createEmptyCsvField(PsiFile psiFile) {
    final Project project = psiFile.getProject();
    final String text = "<undefined>";
    final IElementType type = CsvTypes.FIELD;
    final PsiManager psiManager = PsiManager.getInstance(project);
    final DummyHolder dummyHolder = DummyHolderFactory.createHolder(psiManager, null);
    final FileElement fileElement = dummyHolder.getTreeElement();
    final FileParserDefinition parserDefinition = (FileParserDefinition) LanguageParserDefinitions.INSTANCE.forLanguage(CsvLanguage.INSTANCE);
    final Lexer lexer = parserDefinition.createLexer(psiFile);
    final PsiBuilder psiBuilder = PsiBuilderFactory.getInstance().createBuilder(project, fileElement, lexer, CsvLanguage.INSTANCE, text);
    final ASTNode node = parserDefinition.createParser(project).parse(type, psiBuilder);
    fileElement.rawAddChildren((com.intellij.psi.impl.source.tree.TreeElement) node);
    return node.getPsi();
}
 

@Nullable
    private static ExternalLintAnnotationInput collectInformation(@NotNull PsiFile psiFile, @Nullable Editor editor) {
        if (psiFile.getContext() != null) {
            return null;
        }
        VirtualFile virtualFile = psiFile.getVirtualFile();
        if (virtualFile == null || !virtualFile.isInLocalFileSystem()) {
            return null;
        }
        if (psiFile.getViewProvider() instanceof MultiplePsiFilesPerDocumentFileViewProvider) {
            return null;
        }
        Project project = psiFile.getProject();
        ESLintProjectComponent component = project.getComponent(ESLintProjectComponent.class);
        if (!component.isSettingsValid() || !component.isEnabled() || !isJavaScriptFile(psiFile, component.ext)) {
            return null;
        }
        Document document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
        if (document == null) {
            return null;
        }
        String fileContent = document.getText();
        if (StringUtil.isEmptyOrSpaces(fileContent)) {
            return null;
        }
        EditorColorsScheme colorsScheme = editor == null ? null : editor.getColorsScheme();
//        tabSize = getTabSize(editor);
//        tabSize = 4;
        return new ExternalLintAnnotationInput(project, psiFile, fileContent, colorsScheme);
    }
 

public static boolean availableFor(@Nonnull PsiFile psiFile, @Nonnull Editor editor, @Nonnull IntentionAction action) {
  if (!psiFile.isValid()) return false;

  try {
    Project project = psiFile.getProject();
    action = IntentionActionDelegate.unwrap(action);
    if (action instanceof SuppressIntentionActionFromFix) {
      final ThreeState shouldBeAppliedToInjectionHost = ((SuppressIntentionActionFromFix)action).isShouldBeAppliedToInjectionHost();
      if (editor instanceof EditorWindow && shouldBeAppliedToInjectionHost == ThreeState.YES) {
        return false;
      }
      if (!(editor instanceof EditorWindow) && shouldBeAppliedToInjectionHost == ThreeState.NO) {
        return false;
      }
    }

    if (action instanceof PsiElementBaseIntentionAction) {
      PsiElementBaseIntentionAction psiAction = (PsiElementBaseIntentionAction)action;
      if (!psiAction.checkFile(psiFile)) {
        return false;
      }
      PsiElement leaf = psiFile.findElementAt(editor.getCaretModel().getOffset());
      if (leaf == null || !psiAction.isAvailable(project, editor, leaf)) {
        return false;
      }
    }
    else if (!action.isAvailable(project, editor, psiFile)) {
      return false;
    }
  }
  catch (IndexNotReadyException e) {
    return false;
  }
  return true;
}
 

/**
 * Reformats the given {@link PsiFile} using {@code buildifier}, returning true if reformatting
 * changed the file.
 */
public static boolean doReformat(PsiFile psiFile) {
  Project project = psiFile.getProject();
  return Optional.ofNullable(PsiDocumentManager.getInstance(project).getDocument(psiFile))
      .map(document -> doReformat(project, document))
      .orElse(false);
}
 

/**
 * make undoable action in current document in order to Undo action work from current file
 *
 * @param file to make editors of to respond to undo action.
 */
public static void markPsiFileForUndo(@Nonnull final PsiFile file) {
  Project project = file.getProject();
  final Document document = PsiDocumentManager.getInstance(project).getDocument(file);
  if (document == null) return;
  CommandProcessor.getInstance().addAffectedDocuments(project, document);
}
 

private static File generateSourceJar(ProgressIndicator progress, String target, String sourceJarPath, PsiFile psiFile)
  throws IOException, URISyntaxException {

  Project project = psiFile.getProject();

  progress.setText("Getting source paths for target " + target);
  List<String> sources = getSourcesForTarget(project, target);

  progress.setText("Finding Pants build root");
  Path buildRoot = findBuildRoot(project);

  progress.setText("Preparing source jar");
  Path targetPath = Paths.get(sourceJarPath);
  Optional<String> packageName = findPackageName(psiFile);
  try (FileSystem zipFileSystem = createZipFileSystem(targetPath)) {
    for (String source : sources) {
      progress.setText2("Processing " + source);

      String sourceRoot = findSourceRoot(source, packageName);
      Path pathInZip = zipFileSystem.getPath(source.substring(sourceRoot.length()));

      Files.createDirectories(pathInZip.getParent());
      Path absoluteSourcePath = buildRoot.resolve(source);
      Files.copy(absoluteSourcePath, pathInZip, StandardCopyOption.REPLACE_EXISTING);
    }
  }
  return targetPath.toFile();
}
 

public CustomTemplateCallback(@Nonnull Editor editor, @Nonnull PsiFile file) {
  myProject = file.getProject();
  myTemplateManager = TemplateManager.getInstance(myProject);

  int parentEditorOffset = getOffset(editor);
  PsiElement element = InjectedLanguageManager.getInstance(file.getProject()).findInjectedElementAt(file, parentEditorOffset);
  myFile = element != null ? element.getContainingFile() : file;

  myInInjectedFragment = InjectedLanguageManager.getInstance(myProject).isInjectedFragment(myFile);
  myEditor = myInInjectedFragment ? InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(editor, file, parentEditorOffset) : editor;
  myOffset = myInInjectedFragment ? getOffset(myEditor) : parentEditorOffset;
}
 

public void doInsert(
  @NotNull PsiFile buildFile,
  @NotNull final String targetName,
  @NotNull PantsTargetAddress addressToAdd
) throws IncorrectOperationException {
  final PyCallExpression targetDefinitionExpression = PantsPsiUtil.findTargets(buildFile).get(targetName);
  if (targetDefinitionExpression == null) {
    return;
  }

  final Project project = buildFile.getProject();
  final PyElementGenerator generator = PyElementGenerator.getInstance(project);
  final String targetAddressStringToAdd = addressToAdd.toString();

  final PyExpression dependenciesArgument = targetDefinitionExpression.getKeywordArgument("dependencies");
  if (dependenciesArgument == null) {
    final PyKeywordArgument keywordArgument =
      generator.createKeywordArgument(LanguageLevel.forElement(buildFile), "dependencies", "['"+ targetAddressStringToAdd + "']");
    Optional.ofNullable(targetDefinitionExpression.getArgumentList()).ifPresent(l -> l.addArgument(keywordArgument));
  } else if (dependenciesArgument instanceof PyListLiteralExpression) {
    PyExpression position = null;
    // we assume all elements are sorted.
    for (PyExpression expression : ((PyListLiteralExpression)dependenciesArgument).getElements()) {
      if (expression instanceof PyStringLiteralExpression &&
          targetAddressStringToAdd.compareTo(((PyStringLiteralExpression)expression).getStringValue()) < 0) {
        // found a position to insert
        break;
      }
      position = expression;
    }
    final PyStringLiteralExpression literalToAdd = generator.createStringLiteralAlreadyEscaped("'" + targetAddressStringToAdd + "'");
    if (position != null) {
      final PsiElement newLine = PsiParserFacade.SERVICE.getInstance(project).createWhiteSpaceFromText("\n");
      final PsiElement addedLiteral = dependenciesArgument.addAfter(literalToAdd, position);
      dependenciesArgument.getNode().addChild(newLine.getNode(), addedLiteral.getNode());
    } else {
      dependenciesArgument.add(literalToAdd);
    }
    CodeStyleManager.getInstance(project).reformat(dependenciesArgument);
  }
  FileDocumentManager.getInstance().saveAllDocuments(); // dump VFS to FS before refreshing
  PantsUtil.refreshAllProjects(project);
}
 

@Override
@Nonnull
public TextEditorHighlightingPass createHighlightingPass(@Nonnull PsiFile file, @Nonnull final Editor editor) {
  return new IndentsPass(file.getProject(), editor, file);
}
 

@Override
protected void doBeforeCharDeleted(char c, PsiFile file, Editor editor) {
  Project project = file.getProject();
  Document document = editor.getDocument();
  CharSequence charSequence = document.getImmutableCharSequence();
  CaretModel caretModel = editor.getCaretModel();
  int caretOffset = caretModel.getOffset();
  LogicalPosition pos = caretModel.getLogicalPosition();
  int lineStartOffset = document.getLineStartOffset(pos.line);
  int beforeWhitespaceOffset = CharArrayUtil.shiftBackward(charSequence, caretOffset - 1, " \t") + 1;
  if (beforeWhitespaceOffset != lineStartOffset) {
    myReplacement = null;
    return;
  }
  PsiDocumentManager.getInstance(project).commitDocument(document);
  CodeStyleFacade codeStyleFacade = CodeStyleFacade.getInstance(project);
  myReplacement = codeStyleFacade.getLineIndent(document, lineStartOffset);
  if (myReplacement == null) {
    return;
  }
  int tabSize = codeStyleFacade.getTabSize(file.getFileType());
  int targetColumn = getWidth(myReplacement, tabSize);
  int endOffset = CharArrayUtil.shiftForward(charSequence, caretOffset, " \t");
  LogicalPosition logicalPosition = caretOffset < endOffset ? editor.offsetToLogicalPosition(endOffset) : pos;
  int currentColumn = logicalPosition.column;
  if (currentColumn > targetColumn) {
    myStartOffset = lineStartOffset;
  }
  else if (logicalPosition.line == 0) {
    myStartOffset = 0;
    myReplacement = "";
  }
  else {
    int prevLineEndOffset = document.getLineEndOffset(logicalPosition.line - 1);
    myStartOffset = CharArrayUtil.shiftBackward(charSequence, prevLineEndOffset - 1, " \t") + 1;
    if (myStartOffset != document.getLineStartOffset(logicalPosition.line - 1)) {
      int spacing = CodeStyleManager.getInstance(project).getSpacing(file, endOffset);
      myReplacement = StringUtil.repeatSymbol(' ', Math.max(0, spacing));
    }
  }
}
 

@Nullable
private static TargetInfo getTargetLabel(PsiFile psiFile) {
  Project project = psiFile.getProject();
  BlazeProjectData projectData =
      BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
  if (projectData == null) {
    return null;
  }
  VirtualFile virtualFile = psiFile.getVirtualFile();
  if (virtualFile == null) {
    return null;
  }
  File file = VfsUtil.virtualToIoFile(virtualFile);
  Collection<TargetKey> rulesForFile =
      SourceToTargetMap.getInstance(project).getRulesForSourceFile(file);

  TargetMap targetMap = projectData.getTargetMap();
  List<TargetKey> libraryKeys = new ArrayList<>();
  for (TargetKey key : rulesForFile) {
    TargetIdeInfo target = targetMap.get(key);
    if (target == null || target.getKind().getLanguageClass() != LanguageClass.GO) {
      continue;
    }
    switch (target.getKind().getRuleType()) {
      case BINARY:
        return target.toTargetInfo();
      case LIBRARY:
        libraryKeys.add(target.getKey());
        break;
      case TEST:
      case UNKNOWN:
        // ignore these
    }
  }
  ImmutableMultimap<TargetKey, TargetKey> rdeps = ReverseDependencyMap.get(project);
  return libraryKeys.stream()
      .map(rdeps::get)
      .flatMap(Collection::stream)
      .map(targetMap::get)
      .filter(Objects::nonNull)
      .filter(t -> t.getKind().getLanguageClass() == LanguageClass.GO)
      .filter(t -> t.getKind().getRuleType() == RuleType.BINARY)
      .map(TargetIdeInfo::toTargetInfo)
      .findFirst()
      .orElse(null);
}
 

protected void addCompletions(@NotNull com.intellij.codeInsight.completion.CompletionParameters completionParameters,
                              ProcessingContext processingContext,
                              @NotNull CompletionResultSet completionResultSet) {

    PsiFile currentFile = completionParameters.getPosition().getContainingFile();
    Project project = currentFile.getProject();

    String lang = I18NHelper.getLang(project);

    PsiElement position = completionParameters.getPosition();
    PsiElement list = (ParameterList) position.getParent().getParent();
    PsiElement[] children = list.getChildren();
    if (children.length < 2) {
        return;
    }
    if (!children[0].toString().equals("String") || children[1] != position.getParent()) {
        return;
    }
    String fileName = CommonHelper.rmQuotes(children[0].getFirstChild().getText());
    String searchString = CommonHelper.cleanCompleterSearchString(completionParameters.getPosition().getText());
    VirtualFile originalFile = currentFile.getOriginalFile().getVirtualFile();

    Boolean identMatch = false;
    if (originalFile != null) {

        String path = CommonHelper.getFilePath(currentFile);
        String protectedPath = CommonHelper.searchCurrentProtected(path);
        protectedPath = CommonHelper.getRelativePath(project, protectedPath);
        if (fileName.contains(".")) {
            String[] result = I18NHelper.findMessageSource(fileName, protectedPath, project);
            if (result != null) {
                protectedPath = result[0];
                fileName = result[2];
            } else {
                protectedPath += "/messages/" + lang;
            }
        } else {
            protectedPath += "/messages/" + lang;
        }

        VirtualFile file = project.getBaseDir().findFileByRelativePath(protectedPath + "/" + fileName + ".php");
        if (file == null) {
            return;
        }
        HashMap<String, String> map = CommonHelper.parsePhpArrayConfig(project, file.getCanonicalPath());

        completionResultSet.caseInsensitive();
        if (map.size() > 0) {
            for (String key : map.keySet()) {
                if (key.equals(searchString)) {
                    identMatch = true;
                }
                completionResultSet.getPrefixMatcher().prefixMatches(key.toLowerCase());
                MessageLookupElement exFL = new MessageLookupElement(key, map.get(key),
                        completionParameters.getPosition().getProject());
                completionResultSet.addElement(exFL);
            }
        }


        /*
        AUTOCREATE NEW LINES
        @FIXME: file sync bug

        if (!identMatch) {
            ArrayList<String> phpDoc = new ArrayList<String>();
            phpDoc.add("Localization file " + lang + "/" + cleanText);
            NewArrayValueLookupElement n = new NewArrayValueLookupElement(
                    cleanText,
                    path,
                    fileName,
                    completionParameters.getPosition().getProject()
            );
            completionResultSet.addElement(n);
            completionResultSet.addElement(new IgnoredLookupElement(cleanText));
        } */
    }

}
 

@NotNull
private List<HaxeCompilerCompletionItem> collectCompletionsFromCompiler(@NotNull PsiFile file,
                                                                        @NotNull PsiElement element,
                                                                        @NotNull Editor editor,
                                                                        ArrayList<String> commandLineArguments,
                                                                        HaxeDebugTimeLog timeLog) {
    // There is a problem here in that the current buffer may not have been saved.
    // If that is the case, then the position is also incorrect, and the compiler
    // doesn't have access to the correct sources.  If the haxe compiler is version 3.4 or
    // later, then it has the -D display-stdin parameter available and we can pump the
    // unsaved buffer through to the compiler. (Though that does nothing for completion
    // from related but also unsaved buffers.)  Doing so will also require the compiler
    // server (if used) to be started with the "--wait stdin" parameter.

    if (null == file) {
        // TODO: Handle in-memory files for Haxe 3.4.
        advertiseError("Error: Compiler completion requested for in-memory-only file.");  // TODO: Externalize string.
        return HaxeCompilerCompletionItem.EMPTY_LIST;
    }

    Project project = file.getProject();
    Module moduleForFile = ModuleUtil.findModuleForFile(file.getVirtualFile(), project);
    int offset = recalculateFileOffset(file, element, editor);

    // TODO: Add libraries that could be referenced.

    // Source roots need to be in the classpath, too.
    for (VirtualFile root : ModuleRootManager.getInstance(moduleForFile).getSourceRoots()) {
        commandLineArguments.add("-cp");
        commandLineArguments.add(root.getPath());
    }

    // Add all of the definitions, so that the compiler can see the code we are dealing with.
    HaxeProjectSettings settings = HaxeProjectSettings.getInstance(project);
    for (String define : settings.getUserCompilerDefinitions()) {
        commandLineArguments.add("-D");
        commandLineArguments.add(define);
    }

    // Tell the compiler we want field completion, adding the type (var or method)
    commandLineArguments.add("-D");
    commandLineArguments.add("display-details");
    commandLineArguments.add("--display");

    commandLineArguments.add(file.getVirtualFile().getPath() + "@" + Integer.toString(offset));

    timeLog.stamp("Calling compiler");
    List<String> stderr = new ArrayList<String>();
    List<String> stdout = new ArrayList<String>();
    int status = HaxeCompilerUtil.runInterruptibleCompileProcess(commandLineArguments, false,
                                                                 HaxeCompilerUtil.findCompileRoot(file),
                                                                 HaxeSdkUtilBase.getSdkData(moduleForFile),
                                                                 stdout, stderr, timeLog);

    timeLog.stamp("Compiler finished. Output found on " + (stdout.isEmpty() ? "" : "stdout ") + (stderr.isEmpty() ? "" : "stderr"));
    // LOG.debug("Compiler finished. Output found on " + (stdout.isEmpty() ? "" : "stdout ") + (stderr.isEmpty() ? "" : "stderr"));
    if (0 != status) {
        return handleCompilerError(project, stderr);
    }
    return parseCompletionFromXml(project, stderr);
}