private CodeFormatterFacade getFormatterFacade(final FileViewProvider viewProvider) {
final CodeStyleSettings styleSettings =
CodeStyleSettingsManager.getSettings(myPsiManager.getProject());
final PsiDocumentManager documentManager =
PsiDocumentManager.getInstance(myPsiManager.getProject());
final Document document = viewProvider.getDocument();
final CodeFormatterFacade codeFormatter = new CodeFormatterFacade(styleSettings);
documentManager.commitDocument(document);
return codeFormatter;
}
public PostprocessReformattingAspect(
Project project, PsiManager psiManager, TreeAspect treeAspect) {
myProject = project;
myPsiManager = psiManager;
myTreeAspect = treeAspect;
PomManager.getModel(psiManager.getProject())
.registerAspect(
PostprocessReformattingAspect.class,
this,
Collections.singleton((PomModelAspect) treeAspect));
ApplicationListener applicationListener =
new ApplicationAdapter() {
public void writeActionStarted(final Object action) {
final CommandProcessor processor = CommandProcessor.getInstance();
if (processor != null) {
final Project project = processor.getCurrentCommandProject();
if (project == myProject) {
myPostponedCounter++;
}
}
}
public void writeActionFinished(final Object action) {
final CommandProcessor processor = CommandProcessor.getInstance();
if (processor != null) {
final Project project = processor.getCurrentCommandProject();
if (project == myProject) {
decrementPostponedCounter();
}
}
}
};
ApplicationManager.getApplication().addApplicationListener(applicationListener, this);
}
@NotNull
private static PsiClass[] resolveClassReferenceList(
@NotNull PsiClassType[] listOfTypes,
@NotNull PsiManager manager,
@NotNull GlobalSearchScope resolveScope,
boolean includeObject) {
PsiClass objectClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
if (objectClass == null) includeObject = false;
if (listOfTypes.length == 0) {
if (includeObject) return new PsiClass[] {objectClass};
return PsiClass.EMPTY_ARRAY;
}
int referenceCount = listOfTypes.length;
if (includeObject) referenceCount++;
PsiClass[] resolved = new PsiClass[referenceCount];
int resolvedCount = 0;
if (includeObject) resolved[resolvedCount++] = objectClass;
for (PsiClassType reference : listOfTypes) {
PsiClass refResolved = reference.resolve();
if (refResolved != null) resolved[resolvedCount++] = refResolved;
}
if (resolvedCount < referenceCount) {
PsiClass[] shorter = new PsiClass[resolvedCount];
System.arraycopy(resolved, 0, shorter, 0, resolvedCount);
resolved = shorter;
}
return resolved;
}
@Nullable
public static PsiClass getSuperClass(@NotNull PsiClass psiClass) {
PsiManager manager = psiClass.getManager();
GlobalSearchScope resolveScope = psiClass.getResolveScope();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
if (psiClass.isInterface()) {
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
}
if (psiClass.isEnum()) {
return facade.findClass(CommonClassNames.JAVA_LANG_ENUM, resolveScope);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassReference = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass == null || baseClass.isInterface())
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
return baseClass;
}
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return null;
final PsiClassType[] referenceElements = psiClass.getExtendsListTypes();
if (referenceElements.length == 0)
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
PsiClass psiResoved = referenceElements[0].resolve();
return psiResoved == null
? facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope)
: psiResoved;
}
private void doPostponedFormattingInner(final FileViewProvider key) {
final List<ASTNode> astNodes = myReformatElements.remove(key);
final Document document = key.getDocument();
// Sort ranges by end offsets so that we won't need any offset adjustment after reformat or
// reindent
if (document == null) return;
final VirtualFile virtualFile = key.getVirtualFile();
if (!virtualFile.isValid()) return;
final TreeSet<PostprocessFormattingTask> postProcessTasks =
new TreeSet<PostprocessFormattingTask>();
Collection<Disposable> toDispose = ContainerUtilRt.newArrayList();
try {
// process all roots in viewProvider to find marked for reformat before elements and create
// appropriate range markers
handleReformatMarkers(key, postProcessTasks);
toDispose.addAll(postProcessTasks);
// then we create ranges by changed nodes. One per node. There ranges can intersect. Ranges
// are sorted by end offset.
if (astNodes != null) createActionsMap(astNodes, key, postProcessTasks);
if ("true".equals(System.getProperty("check.psi.is.valid"))
&& ApplicationManager.getApplication().isUnitTestMode()) {
checkPsiIsCorrect(key);
}
while (!postProcessTasks.isEmpty()) {
// now we have to normalize actions so that they not intersect and ordered in most
// appropriate way
// (free reformatting -> reindent -> formatting under reindent)
final List<PostponedAction> normalizedActions =
normalizeAndReorderPostponedActions(postProcessTasks, document);
toDispose.addAll(normalizedActions);
// only in following loop real changes in document are made
for (final PostponedAction normalizedAction : normalizedActions) {
CodeStyleSettings settings =
CodeStyleSettingsManager.getSettings(myPsiManager.getProject());
boolean old = settings.ENABLE_JAVADOC_FORMATTING;
settings.ENABLE_JAVADOC_FORMATTING = false;
try {
normalizedAction.execute(key);
} finally {
settings.ENABLE_JAVADOC_FORMATTING = old;
}
}
}
} finally {
for (Disposable disposable : toDispose) {
//noinspection SSBasedInspection
disposable.dispose();
}
}
}
private static PsiClassType getEnumSuperType(
@NotNull PsiClass psiClass, @NotNull PsiElementFactory factory) {
PsiClassType superType;
final PsiManager manager = psiClass.getManager();
final PsiClass enumClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass("java.lang.Enum", psiClass.getResolveScope());
if (enumClass == null) {
try {
superType = (PsiClassType) factory.createTypeFromText("java.lang.Enum", null);
} catch (IncorrectOperationException e) {
superType = null;
}
} else {
final PsiTypeParameter[] typeParameters = enumClass.getTypeParameters();
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
if (typeParameters.length == 1) {
substitutor = substitutor.put(typeParameters[0], factory.createType(psiClass));
}
superType = new PsiImmediateClassType(enumClass, substitutor);
}
return superType;
}
@NotNull
public static UsageInfo[] findUsages(
final PsiElement element,
final String newName,
boolean searchInStringsAndComments,
boolean searchForTextOccurrences,
Map<? extends PsiElement, String> allRenames) {
final List<UsageInfo> result = Collections.synchronizedList(new ArrayList<UsageInfo>());
PsiManager manager = element.getManager();
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject());
RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(element);
Collection<PsiReference> refs = processor.findReferences(element, searchInStringsAndComments);
for (final PsiReference ref : refs) {
if (ref == null) {
LOG.error("null reference from processor " + processor);
continue;
}
PsiElement referenceElement = ref.getElement();
result.add(
new MoveRenameUsageInfo(
referenceElement,
ref,
ref.getRangeInElement().getStartOffset(),
ref.getRangeInElement().getEndOffset(),
element,
ref.resolve() == null));
}
processor.findCollisions(element, newName, allRenames, result);
final PsiElement searchForInComments =
processor.getElementToSearchInStringsAndComments(element);
if (searchInStringsAndComments && searchForInComments != null) {
String stringToSearch =
ElementDescriptionUtil.getElementDescription(
searchForInComments, NonCodeSearchDescriptionLocation.STRINGS_AND_COMMENTS);
if (stringToSearch.length() > 0) {
final String stringToReplace = getStringToReplace(element, newName, false, processor);
TextOccurrencesUtil.UsageInfoFactory factory =
new NonCodeUsageInfoFactory(searchForInComments, stringToReplace);
TextOccurrencesUtil.addUsagesInStringsAndComments(
searchForInComments, stringToSearch, result, factory);
}
}
if (searchForTextOccurrences && searchForInComments != null) {
String stringToSearch =
ElementDescriptionUtil.getElementDescription(
searchForInComments, NonCodeSearchDescriptionLocation.NON_JAVA);
if (stringToSearch.length() > 0) {
final String stringToReplace = getStringToReplace(element, newName, true, processor);
addTextOccurrence(
searchForInComments, result, projectScope, stringToSearch, stringToReplace);
}
final Pair<String, String> additionalStringToSearch =
processor.getTextOccurrenceSearchStrings(searchForInComments, newName);
if (additionalStringToSearch != null && additionalStringToSearch.first.length() > 0) {
addTextOccurrence(
searchForInComments,
result,
projectScope,
additionalStringToSearch.first,
additionalStringToSearch.second);
}
}
return result.toArray(new UsageInfo[result.size()]);
}
private static MultiHostRegistrarImpl probeElementsUp(
@NotNull PsiElement element, @NotNull PsiFile hostPsiFile, boolean probeUp) {
PsiManager psiManager = hostPsiFile.getManager();
final Project project = psiManager.getProject();
InjectedLanguageManagerImpl injectedManager =
InjectedLanguageManagerImpl.getInstanceImpl(project);
if (injectedManager == null) {
return null; // for tests
}
MultiHostRegistrarImpl registrar = null;
PsiElement current = element;
nextParent:
while (current != null && current != hostPsiFile) {
ProgressManager.checkCanceled();
if ("EL".equals(current.getLanguage().getID())) break;
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> data =
current.getUserData(INJECTED_PSI);
if (data == null) {
registrar =
InjectedPsiCachedValueProvider.doCompute(
current, injectedManager, project, hostPsiFile);
} else {
registrar = data.getValue(current);
}
current = current.getParent(); // cache no injection for current
if (registrar != null) {
List<Pair<Place, PsiFile>> places = registrar.getResult();
// check that injections found intersect with queried element
TextRange elementRange = element.getTextRange();
for (Pair<Place, PsiFile> pair : places) {
Place place = pair.first;
for (PsiLanguageInjectionHost.Shred shred : place) {
if (shred.getHost().getTextRange().intersects(elementRange)) {
if (place.isValid()) break nextParent;
}
}
}
}
if (!probeUp) {
break;
}
}
if (probeUp) {
// cache only if we walked all parents
for (PsiElement e = element;
e != current && e != null && e != hostPsiFile;
e = e.getParent()) {
ProgressManager.checkCanceled();
if (registrar == null) {
e.putUserData(INJECTED_PSI, null);
} else {
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> cachedValue =
CachedValuesManager.getManager(project)
.createParameterizedCachedValue(INJECTED_PSI_PROVIDER, false);
CachedValueProvider.Result<MultiHostRegistrarImpl> result =
CachedValueProvider.Result.create(
registrar, PsiModificationTracker.MODIFICATION_COUNT, registrar);
((PsiParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement>) cachedValue)
.setValue(result);
e.putUserData(INJECTED_PSI, cachedValue);
}
}
}
return registrar;
}