public static void sendBeforeChildrenChangeEvent(
@NotNull PsiManagerImpl manager, @NotNull PsiElement scope, boolean isGenericChange) {
if (!scope.isPhysical()) {
manager.beforeChange(false);
return;
}
PsiTreeChangeEventImpl event = new PsiTreeChangeEventImpl(manager);
event.setParent(scope);
event.setFile(scope.getContainingFile());
TextRange range = scope.getTextRange();
event.setOffset(range == null ? 0 : range.getStartOffset());
event.setOldLength(scope.getTextLength());
// the "generic" event is being sent on every PSI change. It does not carry any specific info
// except the fact that "something has changed"
event.setGenericChange(isGenericChange);
manager.beforeChildrenChange(event);
}
public static void sendAfterChildrenChangedEvent(
@NotNull PsiManagerImpl manager,
@NotNull PsiFile scope,
int oldLength,
boolean isGenericChange) {
if (!scope.isPhysical()) {
manager.afterChange(false);
return;
}
PsiTreeChangeEventImpl event = new PsiTreeChangeEventImpl(manager);
event.setParent(scope);
event.setFile(scope);
event.setOffset(0);
event.setOldLength(oldLength);
event.setGenericChange(isGenericChange);
manager.childrenChanged(event);
}
public static void doTearDown() throws Exception {
UsefulTestCase.doPostponedFormatting(ourProject);
LookupManager.getInstance(ourProject).hideActiveLookup();
InspectionProfileManager.getInstance().deleteProfile(PROFILE);
assertNotNull("Application components damaged", ProjectManager.getInstance());
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
public void run() {
try {
final VirtualFile[] children = ourSourceRoot.getChildren();
for (VirtualFile child : children) {
child.delete(this);
}
} catch (IOException e) {
//noinspection CallToPrintStackTrace
e.printStackTrace();
}
FileDocumentManager manager = FileDocumentManager.getInstance();
if (manager instanceof FileDocumentManagerImpl) {
((FileDocumentManagerImpl) manager).dropAllUnsavedDocuments();
}
}
});
// final Project[] openProjects = ProjectManagerEx.getInstanceEx().getOpenProjects();
// assertTrue(Arrays.asList(openProjects).contains(ourProject));
assertFalse(PsiManager.getInstance(getProject()).isDisposed());
if (!ourAssertionsInTestDetected) {
if (IdeaLogger.ourErrorsOccurred != null) {
throw IdeaLogger.ourErrorsOccurred;
}
// assertTrue("Logger errors occurred. ", IdeaLogger.ourErrorsOccurred == null);
}
((PsiDocumentManagerImpl) PsiDocumentManager.getInstance(getProject()))
.clearUncommitedDocuments();
((UndoManagerImpl) UndoManager.getGlobalInstance()).dropHistoryInTests();
ProjectManagerEx.getInstanceEx().setCurrentTestProject(null);
ourApplication.setDataProvider(null);
ourTestCase = null;
((PsiManagerImpl) ourPsiManager).cleanupForNextTest();
final Editor[] allEditors = EditorFactory.getInstance().getAllEditors();
if (allEditors.length > 0) {
for (Editor allEditor : allEditors) {
EditorFactory.getInstance().releaseEditor(allEditor);
}
fail("Unreleased editors: " + allEditors.length);
}
}
public PsiVFSListener(Project project) {
myProject = project;
myFileTypeManager = FileTypeManager.getInstance();
myProjectRootManager = ProjectRootManager.getInstance(project);
myManager = (PsiManagerImpl) PsiManager.getInstance(project);
myFileManager = (FileManagerImpl) myManager.getFileManager();
myConnection = project.getMessageBus().connect(project);
StartupManager.getInstance(project)
.registerPreStartupActivity(
new Runnable() {
@Override
public void run() {
final BulkVirtualFileListenerAdapter adapter =
new BulkVirtualFileListenerAdapter(PsiVFSListener.this);
myConnection.subscribe(
VirtualFileManager.VFS_CHANGES,
new BulkFileListener() {
@Override
public void before(@NotNull List<? extends VFileEvent> events) {
adapter.before(events);
}
@Override
public void after(@NotNull List<? extends VFileEvent> events) {
myReportedUnloadedPsiChange = false;
adapter.after(events);
myReportedUnloadedPsiChange = false;
}
});
myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new MyModuleRootListener());
myConnection.subscribe(
FileTypeManager.TOPIC,
new FileTypeListener.Adapter() {
@Override
public void fileTypesChanged(@NotNull FileTypeEvent e) {
myFileManager.processFileTypesChanged();
}
});
myConnection.subscribe(
AppTopics.FILE_DOCUMENT_SYNC, new MyFileDocumentManagerAdapter());
myFileManager.markInitialized();
}
});
}
public CoreProjectEnvironment(
@NotNull Disposable parentDisposable,
@NotNull CoreApplicationEnvironment applicationEnvironment) {
myParentDisposable = parentDisposable;
myEnvironment = applicationEnvironment;
myProject =
createProject(myEnvironment.getApplication().getPicoContainer(), myParentDisposable);
preregisterServices();
myFileIndexFacade = createFileIndexFacade();
myMessageBus = MessageBusFactory.newMessageBus("CoreProjectEnvironment");
PsiModificationTrackerImpl modificationTracker = new PsiModificationTrackerImpl(myProject);
myProject.registerService(PsiModificationTracker.class, modificationTracker);
myProject.registerService(FileIndexFacade.class, myFileIndexFacade);
myProject.registerService(ResolveCache.class, new ResolveCache(myMessageBus));
registerProjectExtensionPoint(
PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor.class);
myPsiManager =
new PsiManagerImpl(
myProject, null, null, myFileIndexFacade, myMessageBus, modificationTracker);
((FileManagerImpl) myPsiManager.getFileManager()).markInitialized();
registerProjectComponent(PsiManager.class, myPsiManager);
myProject.registerService(SmartPointerManager.class, SmartPointerManagerImpl.class);
registerProjectComponent(
PsiDocumentManager.class,
new CorePsiDocumentManager(
myProject,
myPsiManager,
SmartPointerManager.getInstance(myProject),
myMessageBus,
new MockDocumentCommitProcessor()));
myProject.registerService(ResolveScopeManager.class, createResolveScopeManager(myPsiManager));
myProject.registerService(PsiFileFactory.class, new PsiFileFactoryImpl(myPsiManager));
myProject.registerService(
CachedValuesManager.class,
new CachedValuesManagerImpl(myProject, new PsiCachedValuesFactory(myPsiManager)));
myProject.registerService(PsiDirectoryFactory.class, new PsiDirectoryFactoryImpl(myPsiManager));
myProject.registerService(ProjectScopeBuilder.class, createProjectScopeBuilder());
myProject.registerService(DumbService.class, new MockDumbService(myProject));
}
@Nullable
private PsiFile createFileCopyWithNewName(VirtualFile vFile, String name) {
// TODO[ik] remove this. Event handling and generation must be in view providers mechanism since
// we
// need to track changes in _all_ psi views (e.g. namespace changes in XML)
final FileTypeManager instance = FileTypeManager.getInstance();
if (instance.isFileIgnored(name)) return null;
final FileType fileTypeByFileName = instance.getFileTypeByFileName(name);
final Document document = FileDocumentManager.getInstance().getDocument(vFile);
return PsiFileFactory.getInstance(myManager.getProject())
.createFileFromText(
name,
fileTypeByFileName,
document != null ? document.getCharsSequence() : "",
vFile.getModificationStamp(),
true,
false);
}
@Override
public void propertyChanged(@NotNull final VirtualFilePropertyEvent event) {
final String propertyName = event.getPropertyName();
final VirtualFile vFile = event.getFile();
final FileViewProvider oldFileViewProvider = myFileManager.findCachedViewProvider(vFile);
final PsiFile oldPsiFile;
if (oldFileViewProvider instanceof SingleRootFileViewProvider) {
oldPsiFile =
((SingleRootFileViewProvider) oldFileViewProvider)
.getCachedPsi(oldFileViewProvider.getBaseLanguage());
} else {
oldPsiFile = null;
}
VirtualFile parent = vFile.getParent();
final PsiDirectory parentDir =
oldPsiFile != null && parent != null
? myFileManager.findDirectory(parent)
: getCachedDirectory(parent);
if (oldFileViewProvider
!= null // there is no need to rebuild if there were no PSI in the first place
&& FileContentUtilCore.FORCE_RELOAD_REQUESTOR.equals(event.getRequestor())) {
myFileManager.forceReload(vFile);
return;
}
// do not suppress reparse request for light files
if (parentDir == null) {
boolean fire = VirtualFile.PROP_NAME.equals(propertyName) && vFile.isDirectory();
if (fire) {
PsiDirectory psiDir = myFileManager.getCachedDirectory(vFile);
fire = psiDir != null;
}
if (!fire && !VirtualFile.PROP_WRITABLE.equals(propertyName)) {
handleVfsChangeWithoutPsi(vFile);
return;
}
}
((SmartPointerManagerImpl) SmartPointerManager.getInstance(myManager.getProject()))
.fastenBelts(vFile, 0, null);
ApplicationManager.getApplication()
.runWriteAction(
new ExternalChangeAction() {
@Override
public void run() {
PsiTreeChangeEventImpl treeEvent = new PsiTreeChangeEventImpl(myManager);
treeEvent.setParent(parentDir);
if (VirtualFile.PROP_NAME.equals(propertyName)) {
if (vFile.isDirectory()) {
PsiDirectory psiDir = myFileManager.getCachedDirectory(vFile);
if (psiDir != null) {
if (myFileTypeManager.isFileIgnored(vFile)) {
myFileManager.removeFilesAndDirsRecursively(vFile);
treeEvent.setChild(psiDir);
myManager.childRemoved(treeEvent);
} else {
treeEvent.setElement(psiDir);
treeEvent.setPropertyName(PsiTreeChangeEvent.PROP_DIRECTORY_NAME);
treeEvent.setOldValue(event.getOldValue());
treeEvent.setNewValue(event.getNewValue());
myManager.propertyChanged(treeEvent);
}
} else {
PsiDirectory psiDir1 = myFileManager.findDirectory(vFile);
if (psiDir1 != null) {
treeEvent.setChild(psiDir1);
myManager.childAdded(treeEvent);
}
}
} else {
final FileViewProvider fileViewProvider =
myFileManager.createFileViewProvider(vFile, true);
final PsiFile newPsiFile =
fileViewProvider.getPsi(fileViewProvider.getBaseLanguage());
if (oldPsiFile != null) {
if (newPsiFile == null) {
myFileManager.setViewProvider(vFile, null);
treeEvent.setChild(oldPsiFile);
myManager.childRemoved(treeEvent);
} else if (!FileManagerImpl.areViewProvidersEquivalent(
fileViewProvider, oldFileViewProvider)) {
myFileManager.setViewProvider(vFile, fileViewProvider);
treeEvent.setOldChild(oldPsiFile);
treeEvent.setNewChild(newPsiFile);
myManager.childReplaced(treeEvent);
} else {
if (oldPsiFile instanceof PsiFileImpl) {
((PsiFileImpl) oldPsiFile).clearCaches();
}
treeEvent.setElement(oldPsiFile);
treeEvent.setPropertyName(PsiTreeChangeEvent.PROP_FILE_NAME);
treeEvent.setOldValue(event.getOldValue());
treeEvent.setNewValue(event.getNewValue());
myManager.propertyChanged(treeEvent);
}
} else if (newPsiFile != null) {
myFileManager.setViewProvider(vFile, fileViewProvider);
if (parentDir != null) {
treeEvent.setChild(newPsiFile);
myManager.childAdded(treeEvent);
}
}
}
} else if (VirtualFile.PROP_WRITABLE.equals(propertyName)) {
if (oldPsiFile == null) return;
treeEvent.setElement(oldPsiFile);
treeEvent.setPropertyName(PsiTreeChangeEvent.PROP_WRITABLE);
treeEvent.setOldValue(event.getOldValue());
treeEvent.setNewValue(event.getNewValue());
myManager.propertyChanged(treeEvent);
} else if (VirtualFile.PROP_ENCODING.equals(propertyName)) {
if (oldPsiFile == null) return;
treeEvent.setElement(oldPsiFile);
treeEvent.setPropertyName(VirtualFile.PROP_ENCODING);
treeEvent.setOldValue(event.getOldValue());
treeEvent.setNewValue(event.getNewValue());
myManager.propertyChanged(treeEvent);
}
}
});
}