upsource: minute of fame (JB dictionary extended)
[idea/community.git] / platform / core-impl / src / com / intellij / psi / impl / DocumentCommitProcessor.java
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.psi.impl;
17
18 import com.intellij.lang.ASTNode;
19 import com.intellij.openapi.application.ApplicationManager;
20 import com.intellij.openapi.diagnostic.Attachment;
21 import com.intellij.openapi.diagnostic.Logger;
22 import com.intellij.openapi.editor.Document;
23 import com.intellij.openapi.progress.EmptyProgressIndicator;
24 import com.intellij.openapi.progress.ProgressIndicator;
25 import com.intellij.openapi.project.Project;
26 import com.intellij.openapi.util.Comparing;
27 import com.intellij.openapi.util.TextRange;
28 import com.intellij.openapi.util.text.StringUtil;
29 import com.intellij.pom.PomManager;
30 import com.intellij.pom.PomModel;
31 import com.intellij.pom.event.PomModelEvent;
32 import com.intellij.pom.impl.PomTransactionBase;
33 import com.intellij.pom.tree.TreeAspect;
34 import com.intellij.pom.tree.TreeAspectEvent;
35 import com.intellij.psi.PsiDocumentManager;
36 import com.intellij.psi.PsiFile;
37 import com.intellij.psi.PsiLock;
38 import com.intellij.psi.codeStyle.CodeStyleManager;
39 import com.intellij.psi.impl.source.PsiFileImpl;
40 import com.intellij.psi.impl.source.text.DiffLog;
41 import com.intellij.psi.impl.source.tree.FileElement;
42 import com.intellij.psi.impl.source.tree.ForeignLeafPsiElement;
43 import com.intellij.psi.impl.source.tree.TreeUtil;
44 import com.intellij.psi.text.BlockSupport;
45 import com.intellij.util.Processor;
46 import org.jetbrains.annotations.NonNls;
47 import org.jetbrains.annotations.NotNull;
48 import org.jetbrains.annotations.Nullable;
49
50 public abstract class DocumentCommitProcessor {
51   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.DocumentCommitThread");
52
53   public abstract void commitSynchronously(@NotNull Document document, @NotNull Project project);
54   public abstract void commitAsynchronously(@NotNull final Project project, @NotNull final Document document, @NonNls @NotNull Object reason);
55
56   protected static class CommitTask {
57     @NotNull public final Document document;
58     @NotNull public final Project project;
59
60     // when queued it's not started
61     // when dequeued it's started
62     // when failed it's canceled
63     @NotNull public final ProgressIndicator indicator; // progress to commit this doc under.
64     @NotNull public final Object reason;
65     public boolean removed; // task marked as removed, should be ignored.
66
67     public CommitTask(@NotNull Document document,
68                       @NotNull Project project,
69                       @NotNull ProgressIndicator indicator,
70                       @NotNull Object reason) {
71       this.document = document;
72       this.project = project;
73       this.indicator = indicator;
74       this.reason = reason;
75     }
76
77     @NonNls
78     @Override
79     public String toString() {
80       return "Project: " + project.getName()
81              + ", Doc: "+ document +" ("+  StringUtil.first(document.getImmutableCharSequence(), 12, true).toString().replaceAll("\n", " ")+")"
82              +(indicator.isCanceled() ? " (Canceled)" : "") + (removed ? "Removed" : "");
83     }
84
85     @Override
86     public boolean equals(Object o) {
87       if (this == o) return true;
88       if (!(o instanceof CommitTask)) return false;
89
90       CommitTask task = (CommitTask)o;
91
92       return document.equals(task.document) && project.equals(task.project);
93     }
94
95     @Override
96     public int hashCode() {
97       int result = document.hashCode();
98       result = 31 * result + project.hashCode();
99       return result;
100     }
101   }
102
103   // public for Upsource
104   @Nullable("returns runnable to execute under write action in AWT to finish the commit")
105   public Processor<Document> doCommit(@NotNull final CommitTask task,
106                                @NotNull final PsiFile file,
107                                final boolean synchronously) {
108     Document document = task.document;
109     final long startDocModificationTimeStamp = document.getModificationStamp();
110     final FileElement myTreeElementBeingReparsedSoItWontBeCollected = ((PsiFileImpl)file).calcTreeElement();
111     final CharSequence chars = document.getImmutableCharSequence();
112     final TextRange changedPsiRange = getChangedPsiRange(file, myTreeElementBeingReparsedSoItWontBeCollected, chars);
113     if (changedPsiRange == null) {
114       return null;
115     }
116
117     final Boolean data = document.getUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY);
118     if (data != null) {
119       document.putUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY, null);
120       file.putUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY, data);
121     }
122
123     BlockSupport blockSupport = BlockSupport.getInstance(file.getProject());
124     final DiffLog diffLog = blockSupport.reparseRange(file, changedPsiRange, chars, task.indicator);
125
126     return new Processor<Document>() {
127       @Override
128       public boolean process(Document document) {
129         ApplicationManager.getApplication().assertWriteAccessAllowed();
130         log("Finishing", task, synchronously, document.getModificationStamp(), startDocModificationTimeStamp);
131         if (document.getModificationStamp() != startDocModificationTimeStamp ||
132             ((PsiDocumentManagerBase)PsiDocumentManager.getInstance(file.getProject())).getCachedViewProvider(document) != file.getViewProvider()) {
133           return false; // optimistic locking failed
134         }
135
136         doActualPsiChange(file, diffLog);
137
138         assertAfterCommit(document, file, myTreeElementBeingReparsedSoItWontBeCollected);
139
140         return true;
141       }
142     };
143   }
144
145   private static int getLeafMatchingLength(CharSequence leafText, CharSequence pattern, int patternIndex, int finalPatternIndex, int direction) {
146     int leafIndex = direction == 1 ? 0 : leafText.length() - 1;
147     int finalLeafIndex = direction == 1 ? leafText.length() - 1 : 0;
148     int result = 0;
149     while (leafText.charAt(leafIndex) == pattern.charAt(patternIndex)) {
150       result++;
151       if (leafIndex == finalLeafIndex || patternIndex == finalPatternIndex) {
152         break;
153       }
154       leafIndex += direction;
155       patternIndex += direction;
156     }
157     return result;
158   }
159
160   private static int getMatchingLength(@NotNull FileElement treeElement, @NotNull CharSequence text, boolean fromStart) {
161     int patternIndex = fromStart ? 0 : text.length() - 1;
162     int finalPatternIndex = fromStart ? text.length() - 1 : 0;
163     int direction = fromStart ? 1 : -1;
164     ASTNode leaf = fromStart ? TreeUtil.findFirstLeaf(treeElement, false) : TreeUtil.findLastLeaf(treeElement, false);
165     int result = 0;
166     while (leaf != null && (fromStart ? patternIndex <= finalPatternIndex : patternIndex >= finalPatternIndex)) {
167       if (!(leaf instanceof ForeignLeafPsiElement)) {
168         CharSequence chars = leaf.getChars();
169         if (chars.length() > 0) {
170           int matchingLength = getLeafMatchingLength(chars, text, patternIndex, finalPatternIndex, direction);
171           result += matchingLength;
172           if (matchingLength != chars.length()) {
173             break;
174           }
175           patternIndex += (fromStart ? matchingLength : -matchingLength);
176         }
177       }
178       leaf = fromStart ? TreeUtil.nextLeaf(leaf, false) : TreeUtil.prevLeaf(leaf, false);
179     }
180     return result;
181   }
182
183   @Nullable
184   public static TextRange getChangedPsiRange(@NotNull PsiFile file, @NotNull FileElement treeElement, @NotNull CharSequence newDocumentText) {
185     int psiLength = treeElement.getTextLength();
186     if (!file.getViewProvider().supportsIncrementalReparse(file.getLanguage())) {
187       return new TextRange(0, psiLength);
188     }
189
190     int commonPrefixLength = getMatchingLength(treeElement, newDocumentText, true);
191     if (commonPrefixLength == newDocumentText.length() && newDocumentText.length() == psiLength) {
192       return null;
193     }
194
195     int commonSuffixLength = Math.min(getMatchingLength(treeElement, newDocumentText, false), psiLength - commonPrefixLength);
196     return new TextRange(commonPrefixLength, psiLength - commonSuffixLength);
197   }
198
199   public static void doActualPsiChange(@NotNull final PsiFile file, @NotNull final DiffLog diffLog) {
200     CodeStyleManager.getInstance(file.getProject()).performActionWithFormatterDisabled(new Runnable() {
201       @Override
202       public void run() {
203         synchronized (PsiLock.LOCK) {
204           file.getViewProvider().beforeContentsSynchronized();
205
206           final Document document = file.getViewProvider().getDocument();
207           PsiDocumentManagerBase documentManager = (PsiDocumentManagerBase)PsiDocumentManager.getInstance(file.getProject());
208           PsiToDocumentSynchronizer.DocumentChangeTransaction transaction = documentManager.getSynchronizer().getTransaction(document);
209
210           final PsiFileImpl fileImpl = (PsiFileImpl)file;
211
212           if (transaction == null) {
213             final PomModel model = PomManager.getModel(fileImpl.getProject());
214
215             model.runTransaction(new PomTransactionBase(fileImpl, model.getModelAspect(TreeAspect.class)) {
216               @Override
217               public PomModelEvent runInner() {
218                 return new TreeAspectEvent(model, diffLog.performActualPsiChange(file));
219               }
220             });
221           }
222           else {
223             diffLog.performActualPsiChange(file);
224           }
225         }
226       }
227     });
228   }
229
230   private void assertAfterCommit(@NotNull Document document,
231                                  @NotNull final PsiFile file,
232                                  @NotNull FileElement myTreeElementBeingReparsedSoItWontBeCollected) {
233     if (myTreeElementBeingReparsedSoItWontBeCollected.getTextLength() != document.getTextLength()) {
234       final String documentText = document.getText();
235       String fileText = file.getText();
236       LOG.error("commitDocument left PSI inconsistent: " + file +
237                 "; file len=" + myTreeElementBeingReparsedSoItWontBeCollected.getTextLength() +
238                 "; doc len=" + document.getTextLength() +
239                 "; doc.getText() == file.getText(): " + Comparing.equal(fileText, documentText),
240                 new Attachment("file psi text", fileText),
241                 new Attachment("old text", documentText));
242
243       file.putUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY, Boolean.TRUE);
244       try {
245         BlockSupport blockSupport = BlockSupport.getInstance(file.getProject());
246         final DiffLog diffLog = blockSupport.reparseRange(file, new TextRange(0, documentText.length()), documentText, createProgressIndicator());
247         doActualPsiChange(file, diffLog);
248
249         if (myTreeElementBeingReparsedSoItWontBeCollected.getTextLength() != document.getTextLength()) {
250           LOG.error("PSI is broken beyond repair in: " + file);
251         }
252       }
253       finally {
254         file.putUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY, null);
255       }
256     }
257   }
258
259   public void log(@NonNls String msg, @Nullable CommitTask task, boolean synchronously, @NonNls Object... args) {
260   }
261
262   @NotNull
263   protected ProgressIndicator createProgressIndicator() {
264     return new EmptyProgressIndicator();
265   }
266 }