java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DeclarationSearcher.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.quickfix;
  17
  18 import com.intellij.psi.*;
  19 import org.jetbrains.annotations.Nullable;
  20
  21 import java.util.HashMap;
  22 import java.util.Map;
  23
  24 public class DeclarationSearcher {
  25   private final PsiMethod myMethod;
  26   private final PsiType myTargetType;
  27
  28   private final Map<PsiElement, PsiVariable> cache;
  29
  30   public DeclarationSearcher(final PsiMethod method, final PsiType targetType) {
  31     myMethod = method;
  32     myTargetType = targetType;
  33
  34     cache = new HashMap<PsiElement, PsiVariable>();
  35   }
  36
  37   @Nullable
  38   public PsiVariable getDeclaration(final PsiElement endPositionElement) {
  39     final PsiVariable localVariable = getLocalDeclaration(endPositionElement);
  40     if (localVariable != null) {
  41       return localVariable;
  42     }
  43     return getParameterDeclaration();
  44   }
  45
  46   @Nullable
  47   private PsiVariable getParameterDeclaration() {
  48     for (PsiParameter parameter : myMethod.getParameterList().getParameters()) {
  49       if (myTargetType.equals(parameter.getType())) {
  50         return goThroughCache(myMethod, parameter);
  51       }
  52     }
  53     return null;
  54   }
  55
  56   @Nullable
  57   private PsiVariable getLocalDeclaration(final PsiElement endPositionElement) {
  58     final PsiElement parent = endPositionElement.getParent();
  59
  60     // reuse of cache is possible IF requests are done up-to-down. otherwise - not first declaration can be returned
  61     final PsiVariable cachedCandidate = cache.get(parent);
  62     if (cachedCandidate != null) {
  63       return cachedCandidate;
  64     }
  65
  66     if (parent != myMethod) {
  67       // go up
  68       final PsiVariable parentResult = getLocalDeclaration(parent);
  69       if (parentResult != null) {
  70         return parentResult;
  71       }
  72     }
  73
  74     // look self
  75     for (PsiElement element : parent.getChildren()) {
  76       if (element == endPositionElement) {
  77         break;
  78       }
  79       if (element instanceof PsiDeclarationStatement) {
  80         final PsiElement[] declared = ((PsiDeclarationStatement) element).getDeclaredElements();
  81         for (final PsiElement declaredElement : declared) {
  82           if ((declaredElement instanceof PsiLocalVariable) && (myTargetType.equals(((PsiLocalVariable)declaredElement).getType()))) {
  83             return goThroughCache(parent, (PsiVariable) declaredElement);
  84           }
  85         }
  86       } else if (element instanceof PsiParameter) {
  87         // foreach
  88         if (myTargetType.equals(((PsiParameter) element).getType())) {
  89           return goThroughCache(parent, (PsiVariable) element);
  90         }
  91       }
  92     }
  93
  94     return null;
  95   }
  96
  97   private PsiVariable goThroughCache(final PsiElement parent, final PsiVariable variable) {
  98     cache.put(parent, variable);
  99     return variable;
 100   }
 101 }