void clear() {
myPsiElements.clear();
for (RangeMarker marker : myRangeMarkers) {
if (!(marker instanceof FoldRegion)) marker.dispose();
}
myRangeMarkers.clear();
mySerializedElements.clear();
}
@NotNull
public UsageInfo[] findUsages() {
myRenamers.clear();
ArrayList<UsageInfo> result = new ArrayList<UsageInfo>();
List<PsiElement> elements = new ArrayList<PsiElement>(myAllRenames.keySet());
//noinspection ForLoopReplaceableByForEach
for (int i = 0; i < elements.size(); i++) {
PsiElement element = elements.get(i);
final String newName = myAllRenames.get(element);
final UsageInfo[] usages =
RenameUtil.findUsages(
element, newName, mySearchInComments, mySearchTextOccurrences, myAllRenames);
final List<UsageInfo> usagesList = Arrays.asList(usages);
result.addAll(usagesList);
for (AutomaticRenamerFactory factory : myRenamerFactories) {
if (factory.isApplicable(element)) {
myRenamers.add(factory.createRenamer(element, newName, usagesList));
}
}
for (AutomaticRenamerFactory factory :
Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
if (factory.getOptionName() == null && factory.isApplicable(element)) {
myRenamers.add(factory.createRenamer(element, newName, usagesList));
}
}
}
UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]);
usageInfos = UsageViewUtil.removeDuplicatedUsages(usageInfos);
return usageInfos;
}
public void testTypingDoesNotInterfereWithDuplicates() throws Exception {
SliceTreeStructure treeStructure = configureTree("DupSlice");
SliceNode root = (SliceNode) treeStructure.getRootElement();
List<SliceNode> nodes = new ArrayList<SliceNode>();
expandNodesTo(root, nodes);
for (int i = 0; i < nodes.size() - 1; i++) {
SliceNode node = nodes.get(i);
assertNull(node.getDuplicate());
}
SliceNode last = nodes.get(nodes.size() - 1);
assertNotNull(last.getDuplicate());
type(" xx");
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
backspace();
backspace();
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
nodes.clear();
expandNodesTo(root, nodes);
for (int i = 0; i < nodes.size() - 1; i++) {
SliceNode node = nodes.get(i);
assertNull(node.getDuplicate());
}
assertNotNull(last.getDuplicate());
}
public void cleanup() {
myScope = null;
myRefProject = null;
synchronized (myRefTable) {
myRefTable.clear();
mySortedRefs = null;
}
myModules.clear();
myContext = null;
myGraphAnnotators.clear();
for (RefManagerExtension extension : myExtensions.values()) {
extension.cleanup();
}
}
@Override
public void readExternal(Element element) throws InvalidDataException {
PathMacroManager.getInstance(getProject()).expandPaths(element);
super.readExternal(element);
JavaRunConfigurationExtensionManager.getInstance().readExternal(this, element);
readModule(element);
DefaultJDOMExternalizer.readExternal(this, element);
DefaultJDOMExternalizer.readExternal(getPersistantData(), element);
EnvironmentVariablesComponent.readExternal(element, getPersistantData().getEnvs());
Map<String, String> properties = getPersistantData().TEST_PROPERTIES;
properties.clear();
Element propertiesElement = element.getChild("properties");
if (propertiesElement != null) {
List<Element> children = propertiesElement.getChildren("property");
for (Element property : children) {
properties.put(property.getAttributeValue("name"), property.getAttributeValue("value"));
}
}
List<String> listeners = getPersistantData().TEST_LISTENERS;
listeners.clear();
Element listenersElement = element.getChild("listeners");
if (listenersElement != null) {
List<Element> children = listenersElement.getChildren("listener");
for (Element listenerClassName : children) {
listeners.add(listenerClassName.getAttributeValue("class"));
}
}
final Element patternsElement = element.getChild(PATTERNS_EL_NAME);
if (patternsElement != null) {
final LinkedHashSet<String> tests = new LinkedHashSet<String>();
for (Object o : patternsElement.getChildren(PATTERN_EL_NAME)) {
Element patternElement = (Element) o;
tests.add(patternElement.getAttributeValue(TEST_CLASS_ATT_NAME));
}
getPersistantData().setPatterns(tests);
}
}
public void clear() {
myResults.clear();
}
@Override
public void setToEditor(@NotNull final Editor editor) {
assertDispatchThread();
final PsiManager psiManager = PsiManager.getInstance(myProject);
if (psiManager.isDisposed()) return;
if (!myFile.isValid()) return;
final PsiFile psiFile = psiManager.findFile(myFile);
if (psiFile == null) return;
if (!mySerializedElements.isEmpty()) {
// Restore postponed state
assert myPsiElements.isEmpty() : "Sequential deserialization";
for (SerializedPsiElement entry : mySerializedElements) {
PsiElement restoredElement =
FoldingPolicy.restoreBySignature(psiFile, entry.mySerializedElement);
if (restoredElement != null && restoredElement.isValid()) {
myPsiElements.add(
SmartPointerManager.getInstance(myProject)
.createSmartPsiElementPointer(restoredElement));
restoredElement.putUserData(FOLDING_INFO_KEY, entry.myFoldingInfo);
}
}
mySerializedElements.clear();
}
Map<PsiElement, FoldingDescriptor> ranges = null;
for (SmartPsiElementPointer<PsiElement> ptr : myPsiElements) {
PsiElement element = ptr.getElement();
if (element == null || !element.isValid()) {
continue;
}
if (ranges == null) {
ranges = buildRanges(editor, psiFile);
}
FoldingDescriptor descriptor = ranges.get(element);
if (descriptor == null) {
continue;
}
TextRange range = descriptor.getRange();
FoldRegion region =
FoldingUtil.findFoldRegion(editor, range.getStartOffset(), range.getEndOffset());
if (region != null) {
FoldingInfo fi = element.getUserData(FOLDING_INFO_KEY);
boolean state = fi != null && fi.expanded;
region.setExpanded(state);
}
}
for (RangeMarker marker : myRangeMarkers) {
if (!marker.isValid()) {
continue;
}
FoldRegion region =
FoldingUtil.findFoldRegion(editor, marker.getStartOffset(), marker.getEndOffset());
FoldingInfo info = marker.getUserData(FOLDING_INFO_KEY);
if (region == null) {
if (info != null) {
region =
editor
.getFoldingModel()
.addFoldRegion(marker.getStartOffset(), marker.getEndOffset(), info.placeHolder);
}
if (region == null) {
return;
}
}
boolean state = info != null && info.expanded;
region.setExpanded(state);
}
}