don't report groovy type parameters as unused
[idea/community.git] / plugins / groovy / src / org / jetbrains / plugins / groovy / codeInspection / local / GroovyPostHighlightingPass.java
1 /*
2  * Copyright 2000-2009 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
17 package org.jetbrains.plugins.groovy.codeInspection.local;
18
19 import com.intellij.codeHighlighting.TextEditorHighlightingPass;
20 import com.intellij.codeInsight.CodeInsightSettings;
21 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
22 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
23 import com.intellij.codeInsight.daemon.impl.*;
24 import com.intellij.codeInsight.intention.IntentionAction;
25 import com.intellij.codeInspection.InspectionProfile;
26 import com.intellij.codeInspection.ProblemHighlightType;
27 import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection;
28 import com.intellij.lang.annotation.Annotation;
29 import com.intellij.lang.annotation.AnnotationHolder;
30 import com.intellij.lang.annotation.AnnotationSession;
31 import com.intellij.lang.annotation.HighlightSeverity;
32 import com.intellij.openapi.application.ApplicationManager;
33 import com.intellij.openapi.command.CommandProcessor;
34 import com.intellij.openapi.editor.Editor;
35 import com.intellij.openapi.progress.ProgressIndicator;
36 import com.intellij.openapi.project.Project;
37 import com.intellij.openapi.roots.ProjectFileIndex;
38 import com.intellij.openapi.roots.ProjectRootManager;
39 import com.intellij.openapi.util.TextRange;
40 import com.intellij.openapi.vfs.VirtualFile;
41 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
42 import com.intellij.psi.*;
43 import com.intellij.util.Processor;
44 import org.jetbrains.annotations.NotNull;
45 import org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle;
46 import org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection;
47 import org.jetbrains.plugins.groovy.lang.editor.GroovyImportOptimizer;
48 import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
49 import org.jetbrains.plugins.groovy.lang.psi.GrNamedElement;
50 import org.jetbrains.plugins.groovy.lang.psi.GrReferenceElement;
51 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
52 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
53 import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
54 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
55 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
56 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
57 import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.imports.GrImportStatement;
58
59 import java.util.ArrayList;
60 import java.util.HashSet;
61 import java.util.List;
62 import java.util.Set;
63
64 /**
65  * @author ilyas
66  */
67 public class GroovyPostHighlightingPass extends TextEditorHighlightingPass {
68   private final GroovyFile myFile;
69   private final Editor myEditor;
70   private volatile Set<GrImportStatement> myUnusedImports;
71   private volatile Runnable myOptimizeRunnable;
72   private volatile List<HighlightInfo> myUnusedDeclarations;
73
74   public GroovyPostHighlightingPass(GroovyFile file, Editor editor) {
75     super(file.getProject(), editor.getDocument(), true);
76     myFile = file;
77     myEditor = editor;
78   }
79
80   public void doCollectInformation(final ProgressIndicator progress) {
81     final InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile();
82     final boolean deadCodeEnabled = profile.isToolEnabled(HighlightDisplayKey.find(GroovyUnusedDeclarationInspection.SHORT_NAME), myFile);
83     ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
84     VirtualFile virtualFile = myFile.getViewProvider().getVirtualFile();
85     if (!fileIndex.isInContent(virtualFile)) {
86       return;
87     }
88     final UnusedDeclarationInspection deadCodeInspection = (UnusedDeclarationInspection)profile.getInspectionTool(UnusedDeclarationInspection.SHORT_NAME, myFile);
89     final GlobalUsageHelper usageHelper = new GlobalUsageHelper() {
90       public boolean isCurrentFileAlreadyChecked() {
91         return false;
92       }
93
94       public boolean isLocallyUsed(@NotNull PsiNamedElement member) {
95         return false;
96       }
97
98       @Override
99       public boolean shouldCheckUsages(@NotNull PsiMember member) {
100         return deadCodeInspection == null || !deadCodeInspection.isEntryPoint(member);
101       }
102     };
103
104     final List<HighlightInfo> unusedDeclarations = new ArrayList<HighlightInfo>();
105     final Set<GrImportStatement> unusedImports = new HashSet<GrImportStatement>(GroovyImportOptimizer.getValidImportStatements(myFile));
106     myFile.accept(new PsiRecursiveElementWalkingVisitor() {
107       @Override
108       public void visitElement(PsiElement element) {
109         if (element instanceof GrReferenceElement) {
110           for (GroovyResolveResult result : ((GrReferenceElement)element).multiResolve(true)) {
111             GroovyPsiElement context = result.getCurrentFileResolveContext();
112             if (context instanceof GrImportStatement) {
113               GrImportStatement importStatement = (GrImportStatement)context;
114               unusedImports.remove(importStatement);
115             }
116           }
117         }
118
119         if (deadCodeEnabled && element instanceof GrNamedElement && !PostHighlightingPass.isImplicitUsage((GrNamedElement)element, progress)) {
120           PsiElement nameId = ((GrNamedElement)element).getNameIdentifierGroovy();
121           if (nameId.getNode().getElementType() == GroovyTokenTypes.mIDENT) {
122             String name = ((GrNamedElement)element).getName();
123             if (element instanceof GrTypeDefinition && !PostHighlightingPass.isClassUsed((GrTypeDefinition)element, progress, usageHelper)) {
124               unusedDeclarations.add(
125                 PostHighlightingPass.createUnusedSymbolInfo(nameId, "Class " + name + " is unused", HighlightInfoType.UNUSED_SYMBOL));
126             }
127             else if (element instanceof GrMethod) {
128               GrMethod method = (GrMethod)element;
129               if (!PostHighlightingPass.isMethodReferenced(method, progress, usageHelper)) {
130                 unusedDeclarations.add(
131                   PostHighlightingPass.createUnusedSymbolInfo(nameId, (method.isConstructor() ? "Constructor" : "Method") +" " + name + " is unused", HighlightInfoType.UNUSED_SYMBOL));
132               }
133             }
134             else if (element instanceof GrField && PostHighlightingPass.isFieldUnused((GrField)element, progress, usageHelper)) {
135               unusedDeclarations.add(
136                 PostHighlightingPass.createUnusedSymbolInfo(nameId, "Property " + name + " is unused", HighlightInfoType.UNUSED_SYMBOL));
137             }
138           }
139         }
140         
141         super.visitElement(element);
142       }
143     });
144     myUnusedImports = unusedImports;
145     myUnusedDeclarations = unusedDeclarations;
146     if (!unusedImports.isEmpty() && CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) {
147       final VirtualFile vfile = myFile.getVirtualFile();
148       if (vfile != null && ProjectRootManager.getInstance(myFile.getProject()).getFileIndex().isInSource(vfile)) {
149         final GrImportStatement[] imports = myFile.getImportStatements();
150         if (imports.length > 0) {
151           final int offset = myEditor.getCaretModel().getOffset();
152           if (imports[0].getTextRange().getStartOffset() <= offset && offset <= imports[imports.length - 1].getTextRange().getEndOffset()) {
153             return;
154           }
155         }
156
157         myOptimizeRunnable = new GroovyImportOptimizer().processFile(myFile);
158       }
159     }
160
161   }
162
163   private static IntentionAction createUnusedImportIntention() {
164     return new IntentionAction() {
165
166       @NotNull
167       public String getText() {
168         return GroovyInspectionBundle.message("optimize.all.imports");
169       }
170
171       @NotNull
172       public String getFamilyName() {
173         return GroovyInspectionBundle.message("optimize.imports");
174       }
175
176       public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
177         return true;
178       }
179
180       public void invoke(@NotNull final Project project, Editor editor, PsiFile file) {
181         optimizeImports(project, file);
182       }
183
184       public boolean startInWriteAction() {
185         return true;
186       }
187     };
188   }
189
190   public static void optimizeImports(final Project project, PsiFile file) {
191     GroovyImportOptimizer optimizer = new GroovyImportOptimizer();
192     final Runnable runnable = optimizer.processFile(file);
193     ApplicationManager.getApplication().runWriteAction(new Runnable() {
194       public void run() {
195         CommandProcessor.getInstance().executeCommand(project, runnable, "optimize imports", this);
196       }
197     });
198   }
199
200   public void doApplyInformationToEditor() {
201     if (myUnusedDeclarations == null || myUnusedImports == null) {
202       return;
203     }
204
205     AnnotationHolder annotationHolder = new AnnotationHolderImpl(new AnnotationSession(myFile));
206     List<HighlightInfo> infos = new ArrayList<HighlightInfo>(myUnusedDeclarations);
207     for (GrImportStatement unusedImport : myUnusedImports) {
208       Annotation annotation = annotationHolder.createWarningAnnotation(unusedImport, GroovyInspectionBundle.message("unused.import"));
209       annotation.setHighlightType(ProblemHighlightType.LIKE_UNUSED_SYMBOL);
210       annotation.registerFix(createUnusedImportIntention());
211       infos.add(HighlightInfo.fromAnnotation(annotation));
212     }
213
214     UpdateHighlightersUtil.setHighlightersToEditor(myProject, myDocument, 0, myFile.getTextLength(), infos, getColorsScheme(), getId());
215
216     final Runnable optimize = myOptimizeRunnable;
217     if (optimize != null && timeToOptimizeImports()) {
218       PostHighlightingPass.invokeOnTheFlyImportOptimizer(new Runnable() {
219         @Override
220         public void run() {
221           optimize.run();
222         }
223       }, myFile, myEditor);
224     }
225   }
226
227   private boolean timeToOptimizeImports() {
228     if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) return false;
229
230     DaemonCodeAnalyzerImpl codeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(myProject);
231     if (!codeAnalyzer.isHighlightingAvailable(myFile)) return false;
232
233     if (!codeAnalyzer.isErrorAnalyzingFinished(myFile)) return false;
234     boolean errors = containsErrorsPreventingOptimize();
235
236     return !errors && codeAnalyzer.canChangeFileSilently(myFile);
237   }
238
239   private boolean containsErrorsPreventingOptimize() {
240     // ignore unresolved imports errors
241     final TextRange ignoreRange;
242     final GrImportStatement[] imports = myFile.getImportStatements();
243     if (imports.length != 0) {
244       final int start = imports[0].getTextRange().getStartOffset();
245       final int end = imports[imports.length - 1].getTextRange().getEndOffset();
246       ignoreRange = new TextRange(start, end);
247     } else {
248       ignoreRange = TextRange.EMPTY_RANGE;
249     }
250
251     return !DaemonCodeAnalyzerImpl.processHighlights(myDocument, myProject, HighlightSeverity.ERROR, 0, myDocument.getTextLength(), new Processor<HighlightInfo>() {
252       public boolean process(HighlightInfo error) {
253         int infoStart = error.getActualStartOffset();
254         int infoEnd = error.getActualEndOffset();
255
256         return ignoreRange.containsRange(infoStart,infoEnd) && error.type.equals(HighlightInfoType.WRONG_REF);
257       }
258     });
259   }
260
261
262 }