java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.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 package com.intellij.codeInsight.daemon.impl.analysis;
  17
  18 import com.intellij.codeHighlighting.Pass;
  19 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
  20 import com.intellij.codeInsight.daemon.JavaErrorMessages;
  21 import com.intellij.codeInsight.daemon.impl.*;
  22 import com.intellij.codeInsight.daemon.impl.quickfix.QuickFixAction;
  23 import com.intellij.codeInsight.daemon.impl.quickfix.SetupJDKFix;
  24 import com.intellij.lang.injection.InjectedLanguageManager;
  25 import com.intellij.openapi.diagnostic.Logger;
  26 import com.intellij.openapi.editor.Document;
  27 import com.intellij.openapi.progress.ProgressManager;
  28 import com.intellij.openapi.project.DumbAware;
  29 import com.intellij.openapi.project.IndexNotReadyException;
  30 import com.intellij.openapi.project.Project;
  31 import com.intellij.openapi.util.Pair;
  32 import com.intellij.openapi.util.TextRange;
  33 import com.intellij.pom.java.LanguageLevel;
  34 import com.intellij.psi.*;
  35 import com.intellij.psi.controlFlow.ControlFlowUtil;
  36 import com.intellij.psi.impl.source.javadoc.PsiDocMethodOrFieldRef;
  37 import com.intellij.psi.impl.source.jsp.jspJava.JspClass;
  38 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
  39 import com.intellij.psi.javadoc.PsiDocComment;
  40 import com.intellij.psi.javadoc.PsiDocTagValue;
  41 import com.intellij.psi.templateLanguages.OuterLanguageElement;
  42 import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
  43 import com.intellij.psi.util.PsiTreeUtil;
  44 import com.intellij.psi.util.PsiUtil;
  45 import com.intellij.psi.xml.XmlAttributeValue;
  46 import gnu.trove.THashMap;
  47 import org.jetbrains.annotations.NonNls;
  48 import org.jetbrains.annotations.NotNull;
  49
  50 import java.util.Collection;
  51 import java.util.List;
  52 import java.util.Map;
  53
  54 public class HighlightVisitorImpl extends JavaElementVisitor implements HighlightVisitor, DumbAware {
  55   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.analysis.HighlightVisitorImpl");
  56
  57   private final PsiResolveHelper myResolveHelper;
  58
  59   private HighlightInfoHolder myHolder;
  60
  61   private RefCountHolder myRefCountHolder;
  62
  63   // map codeBlock->List of PsiReferenceExpression of uninitialized final variables
  64   private final Map<PsiElement, Collection<PsiReferenceExpression>> myUninitializedVarProblems = new THashMap<PsiElement, Collection<PsiReferenceExpression>>();
  65   // map codeBlock->List of PsiReferenceExpression of extra initialization of final variable
  66   private final Map<PsiElement, Collection<ControlFlowUtil.VariableInfo>> myFinalVarProblems = new THashMap<PsiElement, Collection<ControlFlowUtil.VariableInfo>>();
  67   private final Map<PsiParameter, Boolean> myParameterIsReassigned = new THashMap<PsiParameter, Boolean>();
  68
  69   private final Map<String, Pair<PsiImportStatementBase, PsiClass>> mySingleImportedClasses = new THashMap<String, Pair<PsiImportStatementBase, PsiClass>>();
  70   private final Map<String, Pair<PsiImportStaticReferenceElement, PsiField>> mySingleImportedFields = new THashMap<String, Pair<PsiImportStaticReferenceElement, PsiField>>();
  71   private PsiFile myFile;
  72   private final PsiElementVisitor REGISTER_REFERENCES_VISITOR = new PsiRecursiveElementWalkingVisitor() {
  73     @Override public void visitElement(PsiElement element) {
  74       super.visitElement(element);
  75       for (PsiReference reference : element.getReferences()) {
  76         PsiElement resolved = reference.resolve();
  77         if (resolved instanceof PsiNamedElement) {
  78           myRefCountHolder.registerLocallyReferenced((PsiNamedElement)resolved);
  79         }
  80       }
  81     }
  82   };
  83
  84   @SuppressWarnings({"UnusedDeclaration"}) //in plugin.xml
  85   public HighlightVisitorImpl(Project project) {
  86     this(JavaPsiFacade.getInstance(project).getResolveHelper());
  87   }
  88
  89   private HighlightVisitorImpl(@NotNull PsiResolveHelper resolveHelper) {
  90     myResolveHelper = resolveHelper;
  91   }
  92
  93   public HighlightVisitorImpl clone() {
  94     return new HighlightVisitorImpl(myResolveHelper);
  95   }
  96
  97   public int order() {
  98     return 0;
  99   }
 100
 101   public boolean suitableForFile(PsiFile file) {
 102     return !InjectedLanguageManager.getInstance(file.getProject()).isInjectedFragment(file);
 103   }
 104
 105   public void visit(PsiElement element, HighlightInfoHolder holder) {
 106     myHolder = holder;
 107
 108     if (LOG.isDebugEnabled()) {
 109       LOG.assertTrue(element.isValid());
 110     }
 111     element.accept(this);
 112
 113     if (myRefCountHolder != null) {
 114       registerReferencesFromInjectedFragments(element);
 115     }
 116   }
 117
 118   private void registerReferencesFromInjectedFragments(final PsiElement element) {
 119     InjectedLanguageUtil.enumerate(element, myFile, new PsiLanguageInjectionHost.InjectedPsiVisitor() {
 120       public void visit(@NotNull final PsiFile injectedPsi, @NotNull final List<PsiLanguageInjectionHost.Shred> places) {
 121         injectedPsi.accept(REGISTER_REFERENCES_VISITOR);
 122       }
 123     }, false);
 124   }
 125
 126   public boolean analyze(final Runnable action, final boolean updateWholeFile, final PsiFile file) {
 127     myFile = file;
 128     boolean success = true;
 129     try {
 130       if (updateWholeFile) {
 131         Project project = file.getProject();
 132         DaemonCodeAnalyzer daemonCodeAnalyzer = DaemonCodeAnalyzer.getInstance(project);
 133         FileStatusMap fileStatusMap = ((DaemonCodeAnalyzerImpl)daemonCodeAnalyzer).getFileStatusMap();
 134         RefCountHolder refCountHolder = RefCountHolder.getInstance(file);
 135         myRefCountHolder = refCountHolder;
 136         Document document = PsiDocumentManager.getInstance(project).getDocument(file);
 137         TextRange dirtyScope = document == null ? file.getTextRange() : fileStatusMap.getFileDirtyScope(document, Pass.UPDATE_ALL);
 138         success = refCountHolder.analyze(action, dirtyScope, file);
 139       }
 140       else {
 141         myRefCountHolder = null;
 142         action.run();
 143       }
 144     }
 145     finally {
 146       myUninitializedVarProblems.clear();
 147       myFinalVarProblems.clear();
 148       mySingleImportedClasses.clear();
 149       mySingleImportedFields.clear();
 150       myParameterIsReassigned.clear();
 151
 152       myRefCountHolder = null;
 153       myFile = null;
 154       myHolder = null;
 155     }
 156
 157     return success;
 158   }
 159
 160   public void visitElement(final PsiElement element) {
 161     if (element instanceof XmlAttributeValue) {
 162       try {
 163         for (PsiReference reference : element.getReferences()) {
 164           if(reference instanceof PsiJavaReference && myRefCountHolder != null){
 165             final PsiJavaReference psiJavaReference = (PsiJavaReference)reference;
 166             myRefCountHolder.registerReference(psiJavaReference, psiJavaReference.advancedResolve(false));
 167           }
 168         }
 169       }
 170       catch (IndexNotReadyException ignored) {
 171       }
 172     }
 173   }
 174
 175   @Override public void visitAnnotation(PsiAnnotation annotation) {
 176     super.visitAnnotation(annotation);
 177     if (!PsiUtil.isLanguageLevel5OrHigher(annotation)) {
 178       HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, annotation, JavaErrorMessages.message("annotations.prior.15"));
 179       QuickFixAction.registerQuickFixAction(info, new IncreaseLanguageLevelFix(LanguageLevel.JDK_1_5));
 180       myHolder.add(info);
 181       return;
 182     }
 183
 184     myHolder.add(AnnotationsHighlightUtil.checkApplicability(annotation));
 185     if (!myHolder.hasErrorResults()) myHolder.add(AnnotationsHighlightUtil.checkAnnotationType(annotation));
 186     if (!myHolder.hasErrorResults()) myHolder.add(AnnotationsHighlightUtil.checkMissingAttributes(annotation));
 187     if (!myHolder.hasErrorResults()) myHolder.add(AnnotationsHighlightUtil.checkTargetAnnotationDuplicates(annotation));
 188     if (!myHolder.hasErrorResults()) myHolder.add(AnnotationsHighlightUtil.checkDuplicatedAnnotations(annotation));
 189   }
 190
 191   @Override public void visitAnnotationArrayInitializer(PsiArrayInitializerMemberValue initializer) {
 192     PsiMethod method = null;
 193     PsiElement parent = initializer.getParent();
 194     if (parent instanceof PsiNameValuePair) {
 195       method = (PsiMethod)parent.getReference().resolve();
 196     }
 197     else if (parent instanceof PsiAnnotationMethod) {
 198       method = (PsiMethod)parent;
 199     }
 200     if (method != null) {
 201       PsiType type = method.getReturnType();
 202       if (type instanceof PsiArrayType) {
 203         type = ((PsiArrayType)type).getComponentType();
 204         PsiAnnotationMemberValue[] initializers = initializer.getInitializers();
 205         for (PsiAnnotationMemberValue initializer1 : initializers) {
 206           myHolder.add(AnnotationsHighlightUtil.checkMemberValueType(initializer1, type));
 207         }
 208       }
 209     }
 210   }
 211
 212   @Override public void visitAnnotationMethod(PsiAnnotationMethod method) {
 213     PsiType returnType = method.getReturnType();
 214     PsiAnnotationMemberValue value = method.getDefaultValue();
 215     if (returnType != null && value != null) {
 216       myHolder.add(AnnotationsHighlightUtil.checkMemberValueType(value, returnType));
 217     }
 218
 219     myHolder.add(AnnotationsHighlightUtil.checkValidAnnotationType(method.getReturnTypeElement()));
 220     myHolder.add(AnnotationsHighlightUtil.checkCyclicMemberType(method.getReturnTypeElement(), method.getContainingClass()));
 221   }
 222
 223   @Override public void visitArrayInitializerExpression(PsiArrayInitializerExpression expression) {
 224     super.visitArrayInitializerExpression(expression);
 225     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkArrayInitializerApplicable(expression));
 226     if (!(expression.getParent() instanceof PsiNewExpression)) {
 227       if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkGenericArrayCreation(expression, expression.getType()));
 228     }
 229   }
 230
 231   @Override public void visitAssignmentExpression(PsiAssignmentExpression assignment) {
 232     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkAssignmentCompatibleTypes(assignment));
 233     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkAssignmentOperatorApplicable(assignment));
 234     if (!myHolder.hasErrorResults()) visitExpression(assignment);
 235   }
 236
 237   @Override public void visitBinaryExpression(PsiBinaryExpression expression) {
 238     super.visitBinaryExpression(expression);
 239     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkBinaryOperatorApplicable(expression));
 240   }
 241
 242   @Override public void visitBreakStatement(PsiBreakStatement statement) {
 243     super.visitBreakStatement(statement);
 244     if (!myHolder.hasErrorResults()) {
 245       myHolder.add(HighlightUtil.checkLabelDefined(statement.getLabelIdentifier(), statement.findExitedStatement()));
 246     }
 247   }
 248
 249   @Override public void visitClass(PsiClass aClass) {
 250     super.visitClass(aClass);
 251     if (aClass instanceof JspClass) return;
 252     if (aClass.isAnnotationType()) {
 253       if (!PsiUtil.isLanguageLevel5OrHigher(aClass)) {
 254         HighlightInfo info = HighlightInfo
 255             .createHighlightInfo(HighlightInfoType.ERROR, aClass.getNameIdentifier(), JavaErrorMessages.message("annotations.prior.15"));
 256         QuickFixAction.registerQuickFixAction(info, new IncreaseLanguageLevelFix(LanguageLevel.JDK_1_5));
 257         myHolder.add(info);
 258       }
 259     }
 260     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkInterfaceMultipleInheritance(aClass));
 261     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkDuplicateTopLevelClass(aClass));
 262     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkEnumMustNotBeLocal(aClass));
 263     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkImplicitThisReferenceBeforeSuper(aClass));
 264   }
 265
 266   @Override public void visitClassInitializer(PsiClassInitializer initializer) {
 267     super.visitClassInitializer(initializer);
 268     if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkInitializerCompleteNormally(initializer));
 269     if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkUnreachableStatement(initializer.getBody()));
 270     if (!myHolder.hasErrorResults()) {
 271       myHolder.add(HighlightClassUtil.checkThingNotAllowedInInterface(initializer, initializer.getContainingClass()));
 272     }
 273   }
 274
 275   @Override public void visitClassObjectAccessExpression(PsiClassObjectAccessExpression expression) {
 276     super.visitClassObjectAccessExpression(expression);
 277     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkClassObjectAccessExpression(expression));
 278   }
 279
 280   @Override public void visitComment(PsiComment comment) {
 281     super.visitComment(comment);
 282     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkUnclosedComment(comment));
 283   }
 284
 285   @Override public void visitContinueStatement(PsiContinueStatement statement) {
 286     super.visitContinueStatement(statement);
 287     if (!myHolder.hasErrorResults()) {
 288       myHolder.add(HighlightUtil.checkLabelDefined(statement.getLabelIdentifier(), statement.findContinuedStatement()));
 289     }
 290   }
 291
 292   @Override public void visitJavaToken(PsiJavaToken token) {
 293     super.visitJavaToken(token);
 294     if (!myHolder.hasErrorResults()
 295         && token.getTokenType() == JavaTokenType.RBRACE
 296         && token.getParent() instanceof PsiCodeBlock
 297         && token.getParent().getParent() instanceof PsiMethod) {
 298       PsiMethod method = (PsiMethod)token.getParent().getParent();
 299       myHolder.add(HighlightControlFlowUtil.checkMissingReturnStatement(method));
 300     }
 301
 302   }
 303
 304   @Override public void visitDocComment(PsiDocComment comment) {
 305     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkUnclosedComment(comment));
 306   }
 307
 308   @Override public void visitDocTagValue(PsiDocTagValue value) {
 309     if (value.getReference() != null) {
 310       PsiReference reference = value.getReference();
 311       if (reference != null) {
 312         PsiElement element = reference.resolve();
 313         if (element instanceof PsiMethod) {
 314           myHolder.add(HighlightNamesUtil.highlightMethodName((PsiMethod)element, ((PsiDocMethodOrFieldRef)value).getNameElement(), false));
 315         }
 316         else if (element instanceof PsiParameter) {
 317           myHolder.add(HighlightNamesUtil.highlightVariable((PsiVariable)element, value.getNavigationElement()));
 318         }
 319       }
 320     }
 321   }
 322
 323   @Override public void visitEnumConstant(PsiEnumConstant enumConstant) {
 324     super.visitEnumConstant(enumConstant);
 325     if (!myHolder.hasErrorResults()) GenericsHighlightUtil.checkEnumConstantForConstructorProblems(enumConstant, myHolder);
 326     if (!myHolder.hasErrorResults()) registerConstructorCall(enumConstant);
 327   }
 328
 329   @Override public void visitEnumConstantInitializer(PsiEnumConstantInitializer enumConstantInitializer) {
 330     super.visitEnumConstantInitializer(enumConstantInitializer);
 331     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkClassMustBeAbstract(enumConstantInitializer));
 332   }
 333
 334   @Override public void visitExpression(PsiExpression expression) {
 335     ProgressManager.checkCanceled(); // visitLiteralExpression is invoked very often in array initializers
 336
 337     super.visitExpression(expression);
 338     if (myHolder.add(HighlightUtil.checkMustBeBoolean(expression))) return;
 339     if (expression instanceof PsiArrayAccessExpression
 340         && ((PsiArrayAccessExpression)expression).getIndexExpression() != null) {
 341       myHolder.add(HighlightUtil.checkValidArrayAccessExpression(((PsiArrayAccessExpression)expression).getArrayExpression(),
 342                                                                  ((PsiArrayAccessExpression)expression).getIndexExpression()));
 343     }
 344     if (expression.getParent() instanceof PsiNewExpression
 345              && ((PsiNewExpression)expression.getParent()).getQualifier() != expression
 346              && ((PsiNewExpression)expression.getParent()).getArrayInitializer() != expression) {
 347       // like in 'new String["s"]'
 348       myHolder.add(HighlightUtil.checkValidArrayAccessExpression(null, expression));
 349     }
 350     if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkCannotWriteToFinal(expression));
 351     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkVariableExpected(expression));
 352     if (!myHolder.hasErrorResults()) HighlightUtil.checkArrayInitalizer(expression, myHolder);
 353     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkTernaryOperatorConditionIsBoolean(expression));
 354     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkAssertOperatorTypes(expression));
 355     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSynchronizedExpressionType(expression));
 356     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkConditionalExpressionBranchTypesMatch(expression));
 357     if (!myHolder.hasErrorResults()
 358         && expression.getParent() instanceof PsiThrowStatement
 359         && ((PsiThrowStatement)expression.getParent()).getException() == expression) {
 360       PsiType type = expression.getType();
 361       myHolder.add(HighlightUtil.checkMustBeThrowable(type, expression, true));
 362     }
 363
 364     if (!myHolder.hasErrorResults()) {
 365       myHolder.add(AnnotationsHighlightUtil.checkConstantExpression(expression));
 366     }
 367   }
 368
 369   @Override public void visitField(PsiField field) {
 370     super.visitField(field);
 371     if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkFinalFieldInitialized(field));
 372   }
 373
 374   @Override public void visitForeachStatement(PsiForeachStatement statement) {
 375     if (!PsiUtil.isLanguageLevel5OrHigher(statement)) {
 376       HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, statement.getFirstChild(), JavaErrorMessages.message("foreach.prior.15"));
 377       QuickFixAction.registerQuickFixAction(info, new IncreaseLanguageLevelFix(LanguageLevel.JDK_1_5));
 378       myHolder.add(info);
 379     }
 380   }
 381
 382   @Override public void visitImportStaticStatement(PsiImportStaticStatement statement) {
 383     if (!PsiUtil.isLanguageLevel5OrHigher(statement)) {
 384       HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, statement.getFirstChild(), JavaErrorMessages.message("static.imports.prior.15"));
 385       QuickFixAction.registerQuickFixAction(info, new IncreaseLanguageLevelFix(LanguageLevel.JDK_1_5));
 386       myHolder.add(info);
 387     }
 388   }
 389
 390   @Override public void visitIdentifier(PsiIdentifier identifier) {
 391     PsiElement parent = identifier.getParent();
 392     if (parent instanceof PsiVariable) {
 393       myHolder.add(HighlightUtil.checkVariableAlreadyDefined((PsiVariable)parent));
 394     }
 395     else if (parent instanceof PsiClass) {
 396       myHolder.add(HighlightClassUtil.checkClassAlreadyImported((PsiClass)parent, identifier));
 397       myHolder.add(HighlightClassUtil.checkExternalizableHasPublicNoArgsConstructor((PsiClass)parent, identifier));
 398       if (!(parent instanceof PsiAnonymousClass)) {
 399         myHolder.add(HighlightNamesUtil.highlightClassName((PsiClass)parent, ((PsiClass)parent).getNameIdentifier()));
 400       }
 401     }
 402     else if (parent instanceof PsiMethod) {
 403       PsiMethod method = (PsiMethod)parent;
 404       if (method.isConstructor()) {
 405         myHolder.add(HighlightMethodUtil.checkConstructorName(method));
 406       }
 407     }
 408     super.visitIdentifier(identifier);
 409   }
 410
 411   @Override public void visitImportStatement(PsiImportStatement statement) {
 412     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSingleImportClassConflict(statement, mySingleImportedClasses));
 413   }
 414
 415   @Override public void visitImportStaticReferenceElement(PsiImportStaticReferenceElement ref) {
 416     String refName = ref.getReferenceName();
 417     JavaResolveResult[] results = ref.multiResolve(false);
 418
 419     if (results.length == 0) {
 420       String description = JavaErrorMessages.message("cannot.resolve.symbol", refName);
 421       HighlightInfo info = HighlightInfo.createHighlightInfo(HighlightInfoType.WRONG_REF, ref.getReferenceNameElement(), description);
 422       myHolder.add(info);
 423       QuickFixAction.registerQuickFixAction(info, SetupJDKFix.getInstnace());
 424     }
 425     else {
 426       PsiManager manager = ref.getManager();
 427       for (JavaResolveResult result : results) {
 428         PsiElement element = result.getElement();
 429         if (!(element instanceof PsiModifierListOwner) || !((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC)) {
 430           continue;
 431         }
 432         @NonNls String messageKey = null;
 433         if (element instanceof PsiClass) {
 434           Pair<PsiImportStatementBase, PsiClass> imported = mySingleImportedClasses.get(refName);
 435           PsiClass aClass = imported == null ? null : imported.getSecond();
 436           PsiImportStaticStatement statement = (PsiImportStaticStatement)ref.getParent();
 437
 438           if (aClass != null && !manager.areElementsEquivalent(aClass, element) && !imported.getFirst().equals(statement)) {
 439             messageKey = "class.is.already.defined.in.single.type.import";
 440           }
 441           mySingleImportedClasses.put(refName, Pair.<PsiImportStatementBase, PsiClass>create(statement, (PsiClass)element));
 442         }
 443         else if (element instanceof PsiField) {
 444           Pair<PsiImportStaticReferenceElement, PsiField> imported = mySingleImportedFields.get(refName);
 445           PsiField field = imported == null ? null : imported.getSecond();
 446
 447           if (field != null && !manager.areElementsEquivalent(field, element) && !imported.getFirst().equals(ref.getParent())) {
 448             messageKey = "field.is.already.defined.in.single.type.import";
 449           }
 450           mySingleImportedFields.put(refName, Pair.create(ref, (PsiField)element));
 451         }
 452
 453         if (messageKey != null) {
 454           String description = JavaErrorMessages.message(messageKey, refName);
 455           myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, ref, description));
 456         }
 457       }
 458     }
 459   }
 460
 461   @Override public void visitInstanceOfExpression(PsiInstanceOfExpression expression) {
 462     super.visitInstanceOfExpression(expression);
 463     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkInstanceOfApplicable(expression));
 464     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkInstanceOfGenericType(expression));
 465   }
 466
 467   @Override public void visitKeyword(PsiKeyword keyword) {
 468     super.visitKeyword(keyword);
 469     PsiElement parent = keyword.getParent();
 470     if (parent instanceof PsiModifierList) {
 471       PsiModifierList psiModifierList = (PsiModifierList)parent;
 472       if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkNotAllowedModifier(keyword, psiModifierList));
 473       if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkIllegalModifierCombination(keyword, psiModifierList));
 474       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkPublicClassInRightFile(keyword, psiModifierList));
 475       if (PsiModifier.ABSTRACT.equals(keyword.getText()) && psiModifierList.getParent() instanceof PsiMethod) {
 476         if (!myHolder.hasErrorResults()) {
 477           myHolder.add(HighlightMethodUtil.checkAbstractMethodInConcreteClass((PsiMethod)psiModifierList.getParent(), keyword));
 478         }
 479       }
 480     }
 481     else if (keyword.getText().equals(PsiKeyword.CONTINUE) && parent instanceof PsiContinueStatement) {
 482       PsiContinueStatement statement = (PsiContinueStatement)parent;
 483       if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkContinueOutsideLoop(statement));
 484     }
 485     else if (keyword.getText().equals(PsiKeyword.BREAK) && parent instanceof PsiBreakStatement) {
 486       PsiBreakStatement statement = (PsiBreakStatement)parent;
 487       if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkBreakOutsideLoop(statement));
 488     }
 489     else if (PsiKeyword.INTERFACE.equals(keyword.getText()) && parent instanceof PsiClass) {
 490       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkInterfaceCannotBeLocal((PsiClass)parent));
 491     }
 492     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkStaticDeclarationInInnerClass(keyword));
 493     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkIllegalVoidType(keyword));
 494
 495     if (PsiTreeUtil.getParentOfType(keyword, PsiDocTagValue.class) != null) {
 496       myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.JAVA_KEYWORD, keyword, null));
 497     }
 498   }
 499
 500   @Override public void visitLabeledStatement(PsiLabeledStatement statement) {
 501     super.visitLabeledStatement(statement);
 502     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkLabelWithoutStatement(statement));
 503     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkLabelAlreadyInUse(statement));
 504   }
 505
 506   @Override public void visitLiteralExpression(PsiLiteralExpression expression) {
 507     super.visitLiteralExpression(expression);
 508     if (myHolder.hasErrorResults()) return;
 509     myHolder.add(HighlightUtil.checkLiteralExpressionParsingError(expression));
 510   }
 511
 512   @Override public void visitMethod(PsiMethod method) {
 513     super.visitMethod(method);
 514     if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkUnreachableStatement(method.getBody()));
 515     if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkConstructorHandleSuperClassExceptions(method));
 516     if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkRecursiveConstructorInvocation(method));
 517     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkOverrideAnnotation(method));
 518     if (!myHolder.hasErrorResults() && method.isConstructor()) {
 519       myHolder.add(HighlightClassUtil.checkThingNotAllowedInInterface(method, method.getContainingClass()));
 520     }
 521     myHolder.add(HighlightNamesUtil.highlightMethodName(method, method.getNameIdentifier(), true));
 522   }
 523
 524   private void highlightMethodOrClassName(PsiJavaCodeReferenceElement element) {
 525     PsiElement parent = element.getParent();
 526     if (parent instanceof PsiReferenceExpression || parent instanceof PsiJavaCodeReferenceElement) {
 527       return;
 528     }
 529     if (parent instanceof PsiMethodCallExpression) {
 530       PsiMethod method = ((PsiMethodCallExpression)parent).resolveMethod();
 531       PsiElement methodNameElement = element.getReferenceNameElement();
 532       if (method != null && methodNameElement != null) {
 533         myHolder.add(HighlightNamesUtil.highlightMethodName(method, methodNameElement, false));
 534         myHolder.add(HighlightNamesUtil.highlightClassNameInQualifier(element));
 535       }
 536     }
 537     else if (parent instanceof PsiConstructorCall) {
 538       try {
 539         PsiMethod method = ((PsiConstructorCall)parent).resolveConstructor();
 540         if (method == null) {
 541           PsiElement resolved = element.resolve();
 542           if (resolved instanceof PsiClass) {
 543             myHolder.add(HighlightNamesUtil.highlightClassName((PsiClass)resolved, element));
 544           }
 545         }
 546         else {
 547           myHolder.add(HighlightNamesUtil.highlightMethodName(method, element, false));
 548         }
 549       }
 550       catch (IndexNotReadyException ignored) {
 551       }
 552     }
 553     else if (parent instanceof PsiImportStatement && ((PsiImportStatement)parent).isOnDemand()) {
 554       // highlight on demand import as class
 555       myHolder.add(HighlightNamesUtil.highlightClassName(null, element));
 556     }
 557     else {
 558       PsiElement resolved = element.resolve();
 559       if (resolved instanceof PsiClass) {
 560         myHolder.add(HighlightNamesUtil.highlightClassName((PsiClass)resolved, element));
 561       }
 562     }
 563   }
 564
 565   @Override public void visitMethodCallExpression(PsiMethodCallExpression expression) {
 566     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkEnumSuperConstructorCall(expression));
 567     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkSuperQualifierType(expression));
 568
 569     if (!myHolder.hasErrorResults()) visitExpression(expression);
 570   }
 571
 572   @Override public void visitModifierList(PsiModifierList list) {
 573     super.visitModifierList(list);
 574     PsiElement parent = list.getParent();
 575     if (!myHolder.hasErrorResults() && parent instanceof PsiMethod) {
 576       myHolder.add(HighlightMethodUtil.checkMethodCanHaveBody((PsiMethod)parent));
 577     }
 578     if (parent instanceof PsiMethod) {
 579       PsiMethod method = (PsiMethod)parent;
 580       MethodSignatureBackedByPsiMethod methodSignature = MethodSignatureBackedByPsiMethod.create(method, PsiSubstitutor.EMPTY);
 581       if (!method.isConstructor()) {
 582         List<HierarchicalMethodSignature> superMethodSignatures = method.getHierarchicalMethodSignature().getSuperSignatures();
 583         if (!superMethodSignatures.isEmpty()) {
 584           if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkMethodIncompatibleReturnType(methodSignature, superMethodSignatures, true));
 585           if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkMethodIncompatibleThrows(methodSignature, superMethodSignatures, true, method.getContainingClass()));
 586           if (!method.hasModifierProperty(PsiModifier.STATIC)) {
 587             if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkMethodWeakerPrivileges(methodSignature, superMethodSignatures, true));
 588             if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkUncheckedOverriding(method, superMethodSignatures));
 589             if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkMethodOverridesFinal(methodSignature, superMethodSignatures));
 590           }
 591         }
 592       }
 593       PsiClass aClass = method.getContainingClass();
 594       if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkMethodMustHaveBody(method, aClass));
 595       if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkDuplicateMethod(aClass, method));
 596       if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkConstructorCallsBaseClassConstructor(method, myRefCountHolder, myResolveHelper));
 597       if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkStaticMethodOverride(method));
 598     }
 599     else if (parent instanceof PsiClass) {
 600       PsiClass aClass = (PsiClass)parent;
 601       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkDuplicateNestedClass(aClass));
 602       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkClassMustBeAbstract(aClass));
 603       if (!myHolder.hasErrorResults()) {
 604         myHolder.add(HighlightClassUtil.checkClassDoesNotCallSuperConstructorOrHandleExceptions(aClass, myRefCountHolder, myResolveHelper));
 605       }
 606       if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkOverrideEquivalentInheritedMethods(aClass));
 607       if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkOverrideEquivalentMethods(aClass));
 608       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkCyclicInheritance(aClass));
 609     }
 610     else if (parent instanceof PsiEnumConstant) {
 611       if (!myHolder.hasErrorResults()) myHolder.addAll(GenericsHighlightUtil.checkEnumConstantModifierList(list));
 612     }
 613   }
 614
 615   @Override public void visitNameValuePair(PsiNameValuePair pair) {
 616     myHolder.add(AnnotationsHighlightUtil.checkNameValuePair(pair));
 617     if (!myHolder.hasErrorResults()) {
 618       PsiIdentifier nameId = pair.getNameIdentifier();
 619       if (nameId != null) myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.ANNOTATION_ATTRIBUTE_NAME, nameId, null));
 620     }
 621   }
 622
 623   @Override public void visitNewExpression(PsiNewExpression expression) {
 624     myHolder.add(HighlightUtil.checkUnhandledExceptions(expression, null));
 625     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkAnonymousInheritFinal(expression));
 626     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkQualifiedNewOfStaticClass(expression));
 627     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkCreateInnerClassFromStaticContext(expression));
 628     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkTypeParameterInstantiation(expression));
 629     if (!myHolder.hasErrorResults()) HighlightMethodUtil.checkNewExpression(expression, myHolder);
 630     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkEnumInstantiation(expression));
 631     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkGenericArrayCreation(expression, expression.getType()));
 632     if (!myHolder.hasErrorResults()) registerConstructorCall(expression);
 633
 634     if (!myHolder.hasErrorResults()) visitExpression(expression);
 635   }
 636
 637   @Override public void visitOuterLanguageElement(OuterLanguageElement element) {
 638     XmlHighlightVisitor.visitJspElement(element);
 639     super.visitOuterLanguageElement(element);
 640   }
 641
 642   @Override public void visitPackageStatement(PsiPackageStatement statement) {
 643     super.visitPackageStatement(statement);
 644     myHolder.add(AnnotationsHighlightUtil.checkPackageAnnotationContainingFile(statement));
 645   }
 646
 647   @Override public void visitParameter(PsiParameter parameter) {
 648     super.visitParameter(parameter);
 649     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkVarArgParameterIsLast(parameter));
 650     if (!myHolder.hasErrorResults() && parameter.getParent() instanceof PsiForeachStatement) {
 651       myHolder.add(GenericsHighlightUtil.checkForeachLoopParameterType((PsiForeachStatement)parameter.getParent()));
 652     }
 653   }
 654
 655   @Override public void visitParameterList(PsiParameterList list) {
 656     PsiElement parent = list.getParent();
 657     if (parent instanceof PsiAnnotationMethod && list.getParametersCount() > 0) {
 658       myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR,
 659                                                      list,
 660                                                      JavaErrorMessages.message("annotation.interface.members.may.not.have.parameters")));
 661     }
 662   }
 663
 664   @Override public void visitPostfixExpression(PsiPostfixExpression expression) {
 665     super.visitPostfixExpression(expression);
 666     if (!myHolder.hasErrorResults()) {
 667       myHolder.add(HighlightUtil.checkUnaryOperatorApplicable(expression.getOperationSign(), expression.getOperand()));
 668     }
 669   }
 670
 671   @Override public void visitPrefixExpression(PsiPrefixExpression expression) {
 672     super.visitPrefixExpression(expression);
 673     if (!myHolder.hasErrorResults()) {
 674       myHolder.add(HighlightUtil.checkUnaryOperatorApplicable(expression.getOperationSign(), expression.getOperand()));
 675     }
 676   }
 677
 678   private void registerConstructorCall(PsiConstructorCall constructorCall) {
 679     if (myRefCountHolder != null) {
 680       JavaResolveResult resolveResult = constructorCall.resolveMethodGenerics();
 681       final PsiElement resolved = resolveResult.getElement();
 682       if (resolved instanceof PsiNamedElement) {
 683         myRefCountHolder.registerLocallyReferenced((PsiNamedElement)resolved);
 684       }
 685     }
 686   }
 687
 688   @Override public void visitReferenceElement(PsiJavaCodeReferenceElement ref) {
 689     JavaResolveResult result;
 690     try {
 691       result = ref.advancedResolve(true);
 692     }
 693     catch (IndexNotReadyException e) {
 694       return;
 695     }
 696     PsiElement resolved = result.getElement();
 697     PsiElement parent = ref.getParent();
 698     if (myRefCountHolder != null) {
 699       myRefCountHolder.registerReference(ref, result);
 700     }
 701
 702     myHolder.add(HighlightUtil.checkReference(ref, result, resolved));
 703     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkAbstractInstantiation(ref));
 704     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkExtendsDuplicate(ref, resolved));
 705     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkExceptionAlreadyCaught(ref, resolved));
 706     if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkClassExtendsForeignInnerClass(ref, resolved));
 707     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkSelectStaticClassFromParameterizedType(resolved, ref));
 708     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkParameterizedReferenceTypeArguments(resolved, ref, result.getSubstitutor()));
 709
 710     if (resolved != null && parent instanceof PsiReferenceList) {
 711       if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkElementInReferenceList(ref, (PsiReferenceList)parent, result));
 712     }
 713
 714     if (parent instanceof PsiAnonymousClass && ref.equals(((PsiAnonymousClass)parent).getBaseClassReference())) {
 715       myHolder.add(GenericsHighlightUtil.checkOverrideEquivalentMethods((PsiClass)parent));
 716     }
 717
 718     if (resolved instanceof PsiVariable) {
 719       PsiVariable variable = (PsiVariable)resolved;
 720
 721       final PsiClass containingClass = PsiTreeUtil.getParentOfType(ref, PsiClass.class);
 722       if (containingClass instanceof PsiAnonymousClass && !PsiTreeUtil.isAncestor(containingClass, variable, false) && !(variable instanceof PsiField)) {
 723         if (!PsiTreeUtil.isAncestor(((PsiAnonymousClass) containingClass).getArgumentList(), ref, false)) {
 724           myHolder.add(HighlightInfo.createHighlightInfo(HighlightInfoType.IMPLICIT_ANONYMOUS_CLASS_PARAMETER, ref, null));
 725         }
 726       }
 727
 728       if (!variable.hasModifierProperty(PsiModifier.FINAL) && isReassigned(variable)) {
 729         myHolder.add(HighlightNamesUtil.highlightReassignedVariable(variable, ref));
 730       }
 731       else {
 732         myHolder.add(HighlightNamesUtil.highlightVariable(variable, ref.getReferenceNameElement()));
 733       }
 734       myHolder.add(HighlightNamesUtil.highlightClassNameInQualifier(ref));
 735     }
 736     else {
 737       highlightMethodOrClassName(ref);
 738     }
 739   }
 740
 741   @Override public void visitReferenceExpression(PsiReferenceExpression expression) {
 742     visitReferenceElement(expression);
 743     if (!myHolder.hasErrorResults()) {
 744       visitExpression(expression);
 745       if (myHolder.hasErrorResults()) return;
 746     }
 747     JavaResolveResult result;
 748     try {
 749       result = expression.advancedResolve(false);
 750     }
 751     catch (IndexNotReadyException e) {
 752       return;
 753     }
 754     PsiElement resolved = result.getElement();
 755     if (resolved instanceof PsiVariable && resolved.getContainingFile() == expression.getContainingFile()) {
 756       if (!myHolder.hasErrorResults()) {
 757         myHolder.add(HighlightControlFlowUtil.checkVariableInitializedBeforeUsage(expression, (PsiVariable)resolved, myUninitializedVarProblems));
 758       }
 759       PsiVariable variable = (PsiVariable)resolved;
 760       boolean isFinal = variable.hasModifierProperty(PsiModifier.FINAL);
 761       if (isFinal && !variable.hasInitializer()) {
 762         if (!myHolder.hasErrorResults()) {
 763           myHolder.add(HighlightControlFlowUtil.checkFinalVariableMightAlreadyHaveBeenAssignedTo(variable, expression, myFinalVarProblems));
 764         }
 765         if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkFinalVariableInitalizedInLoop(expression, resolved));
 766       }
 767     }
 768     else {
 769       PsiElement parent = expression.getParent();
 770       PsiMethodCallExpression methodCall;
 771
 772       if (parent instanceof PsiMethodCallExpression && (methodCall = (PsiMethodCallExpression)parent).getMethodExpression() == expression) {
 773         myHolder.addAll(HighlightMethodUtil.checkMethodCall(methodCall, myResolveHelper));
 774       }
 775     }
 776
 777     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkExpressionRequired(expression));
 778     if (!myHolder.hasErrorResults() && resolved instanceof PsiField) {
 779       myHolder.add(HighlightUtil.checkIllegalForwardReferenceToField(expression, (PsiField)resolved));
 780     }
 781     if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkConstructorCallMustBeFirstStatement(expression));
 782     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkAccessStaticFieldFromEnumConstructor(expression, result));
 783     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkClassReferenceAfterQualifier(expression, resolved));
 784   }
 785
 786   @Override public void visitReferenceList(PsiReferenceList list) {
 787     if (list.getFirstChild() == null) return;
 788     PsiElement parent = list.getParent();
 789     if (!(parent instanceof PsiTypeParameter)) {
 790       myHolder.add(AnnotationsHighlightUtil.checkAnnotationDeclaration(parent, list));
 791       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkImplementsAllowed(list));
 792       if (!myHolder.hasErrorResults()) myHolder.add(HighlightClassUtil.checkClassExtendsOnlyOneClass(list));
 793       if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkGenericCannotExtendException(list));
 794     }
 795   }
 796
 797   @Override public void visitReferenceParameterList(PsiReferenceParameterList list) {
 798     myHolder.add(GenericsHighlightUtil.checkParametersOnRaw(list));
 799   }
 800
 801   @Override public void visitReturnStatement(PsiReturnStatement statement) {
 802     myHolder.add(HighlightUtil.checkReturnStatementType(statement));
 803   }
 804
 805   @Override public void visitStatement(PsiStatement statement) {
 806     super.visitStatement(statement);
 807     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkNotAStatement(statement));
 808     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkStatementPrependedWithCaseInsideSwitch(statement));
 809   }
 810
 811   @Override public void visitSuperExpression(PsiSuperExpression expr) {
 812     myHolder.add(HighlightUtil.checkThisOrSuperExpressionInIllegalContext(expr, expr.getQualifier()));
 813     if (!myHolder.hasErrorResults()) myHolder.add(HighlightMethodUtil.checkAbstractMethodDirectCall(expr));
 814     if (!myHolder.hasErrorResults()) visitExpression(expr);
 815   }
 816
 817   @Override public void visitSwitchLabelStatement(PsiSwitchLabelStatement statement) {
 818     super.visitSwitchLabelStatement(statement);
 819     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkCaseStatement(statement));
 820   }
 821
 822   @Override public void visitSwitchStatement(PsiSwitchStatement statement) {
 823     super.visitSwitchStatement(statement);
 824     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSwitchSelectorType(statement));
 825   }
 826
 827   @Override public void visitThisExpression(PsiThisExpression expr) {
 828     myHolder.add(HighlightUtil.checkThisOrSuperExpressionInIllegalContext(expr, expr.getQualifier()));
 829     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkMemberReferencedBeforeConstructorCalled(expr));
 830     if (!myHolder.hasErrorResults()) {
 831       visitExpression(expr);
 832     }
 833   }
 834
 835   @Override public void visitThrowStatement(PsiThrowStatement statement) {
 836     myHolder.add(HighlightUtil.checkUnhandledExceptions(statement, null));
 837     if (!myHolder.hasErrorResults()) visitStatement(statement);
 838   }
 839
 840   @Override public void visitTryStatement(PsiTryStatement statement) {
 841     super.visitTryStatement(statement);
 842     if (!myHolder.hasErrorResults()) {
 843       PsiParameter[] parameters = statement.getCatchBlockParameters();
 844       for (PsiParameter parameter : parameters) {
 845         myHolder.add(HighlightUtil.checkExceptionThrownInTry(parameter));
 846         myHolder.add(HighlightUtil.checkCatchParameterIsThrowable(parameter));
 847         myHolder.add(GenericsHighlightUtil.checkCatchParameterIsClass(parameter));
 848       }
 849     }
 850   }
 851
 852   @Override public void visitTypeElement(PsiTypeElement type) {
 853     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkIllegalType(type));
 854     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkReferenceTypeUsedAsTypeArgument(type));
 855     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkWildcardUsage(type));
 856   }
 857
 858   @Override public void visitTypeCastExpression(PsiTypeCastExpression typeCast) {
 859     super.visitTypeCastExpression(typeCast);
 860     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkInconvertibleTypeCast(typeCast));
 861     if (!myHolder.hasErrorResults()) myHolder.add(GenericsHighlightUtil.checkUncheckedTypeCast(typeCast));
 862   }
 863
 864   @Override public void visitTypeParameterList(PsiTypeParameterList list) {
 865     myHolder.add(GenericsHighlightUtil.checkTypeParametersList(list));
 866   }
 867
 868   @Override public void visitVariable(PsiVariable variable) {
 869     super.visitVariable(variable);
 870     if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkVariableInitializerType(variable));
 871
 872     if (isReassigned(variable)) {
 873       myHolder.add(HighlightNamesUtil.highlightReassignedVariable(variable, variable.getNameIdentifier()));
 874     }
 875     else {
 876       if (variable.getInitializer() == null) {
 877         final PsiElement child = variable.getLastChild();
 878         if (child instanceof PsiErrorElement && child.getPrevSibling() == variable.getNameIdentifier()) return;
 879       }
 880       myHolder.add(HighlightNamesUtil.highlightVariable(variable, variable.getNameIdentifier()));
 881     }
 882   }
 883
 884   private boolean isReassigned(PsiVariable variable) {
 885     try {
 886       return HighlightControlFlowUtil.isReassigned(variable, myFinalVarProblems, myParameterIsReassigned);
 887     }
 888     catch (IndexNotReadyException e) {
 889       return false;
 890     }
 891   }
 892 }