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

The following examples show how to use com.intellij.psi.PsiFile#getProject() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
@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);
}
 
Example 2
@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);
    }
  });
}
 
Example 3
Source Project: consulo   File: QualifiedNameProviders.java    License: Apache License 2.0 6 votes vote down vote up
@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();
}
 
Example 4
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();
					}
				}
		);

	}
}
 
Example 5
Source Project: needsmoredojo   File: JavaScriptAction.java    License: Apache License 2.0 6 votes vote down vote up
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;
}
 
Example 6
Source Project: consulo   File: CodeInsightUtilBase.java    License: Apache License 2.0 6 votes vote down vote up
@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;
}
 
Example 7
@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);
    }
  }
}
 
Example 8
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();
}
 
Example 9
Source Project: eslint-plugin   File: ESLintExternalAnnotator.java    License: MIT License 5 votes vote down vote up
@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);
    }
 
Example 10
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;
}
 
Example 11
Source Project: buck   File: BuildifierUtil.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * 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);
}
 
Example 12
Source Project: consulo   File: UndoUtil.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * 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);
}
 
Example 13
Source Project: consulo   File: CustomTemplateCallback.java    License: Apache License 2.0 5 votes vote down vote up
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;
}
 
Example 14
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();
}
 
Example 15
@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);
}
 
Example 16
Source Project: yiistorm   File: I18TitleCompletionProvider.java    License: MIT License 4 votes vote down vote up
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));
        } */
    }

}
 
Example 17
@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);
}
 
Example 18
@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));
    }
  }
}
 
Example 19
Source Project: consulo   File: IndentsPassFactory.java    License: Apache License 2.0 4 votes vote down vote up
@Override
@Nonnull
public TextEditorHighlightingPass createHighlightingPass(@Nonnull PsiFile file, @Nonnull final Editor editor) {
  return new IndentsPass(file.getProject(), editor, file);
}
 
Example 20
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);
}