java/java-impl/src/com/intellij/psi/impl/source/JavaDummyHolder.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.psi.impl.source;
  17
  18 import com.intellij.lang.StdLanguages;
  19 import com.intellij.psi.*;
  20 import com.intellij.psi.impl.source.resolve.JavaResolveUtil;
  21 import com.intellij.psi.impl.source.tree.TreeElement;
  22 import com.intellij.psi.scope.ElementClassHint;
  23 import com.intellij.psi.scope.NameHint;
  24 import com.intellij.psi.scope.PsiScopeProcessor;
  25 import com.intellij.psi.util.PsiUtil;
  26 import com.intellij.util.CharTable;
  27 import org.jetbrains.annotations.NotNull;
  28
  29 import java.util.Collections;
  30 import java.util.LinkedHashMap;
  31 import java.util.Map;
  32
  33 public class JavaDummyHolder extends DummyHolder implements PsiImportHolder {
  34   private static final Map<String,PsiClass> EMPTY = Collections.emptyMap();
  35   private Map<String, PsiClass> myPseudoImports = EMPTY;
  36
  37   public JavaDummyHolder(@NotNull PsiManager manager, TreeElement contentElement, PsiElement context) {
  38     super(manager, contentElement, context, null, null, StdLanguages.JAVA);
  39   }
  40
  41   public JavaDummyHolder(@NotNull PsiManager manager, CharTable table, boolean validity) {
  42     super(manager, null, null, table, Boolean.valueOf(validity), StdLanguages.JAVA);
  43   }
  44
  45   public JavaDummyHolder(@NotNull PsiManager manager, PsiElement context) {
  46     super(manager, null, context, null, null, StdLanguages.JAVA);
  47   }
  48
  49   public JavaDummyHolder(@NotNull PsiManager manager, TreeElement contentElement, PsiElement context, CharTable table) {
  50     super(manager, contentElement, context, table, null, StdLanguages.JAVA);
  51   }
  52
  53   public JavaDummyHolder(@NotNull PsiManager manager, PsiElement context, CharTable table) {
  54     super(manager, null, context, table, null, StdLanguages.JAVA);
  55   }
  56
  57   public JavaDummyHolder(@NotNull PsiManager manager, final CharTable table) {
  58     super(manager, null, null, table, null, StdLanguages.JAVA);
  59   }
  60
  61   public boolean importClass(PsiClass aClass) {
  62     if (myContext != null) {
  63       final PsiClass resolved = JavaPsiFacade.getInstance(getProject()).getResolveHelper().resolveReferencedClass(aClass.getName(), myContext);
  64       if (resolved != null) {
  65         return getManager().areElementsEquivalent(aClass, resolved);
  66       }
  67     }
  68
  69     String className = aClass.getName();
  70     if (!myPseudoImports.containsKey(className)) {
  71       if (myPseudoImports == EMPTY) {
  72         myPseudoImports = new LinkedHashMap<String, PsiClass>();
  73       }
  74
  75       myPseudoImports.put(className, aClass);
  76       myManager.nonPhysicalChange(); // to clear resolve caches!
  77       return true;
  78     }
  79     else {
  80       return true;
  81     }
  82   }
  83
  84   public boolean hasImports() {
  85     return !myPseudoImports.isEmpty();
  86   }
  87
  88   public boolean processDeclarations(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent, @NotNull PsiElement place) {
  89     ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
  90     if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.CLASS)) {
  91       final NameHint nameHint = processor.getHint(NameHint.KEY);
  92       final String name = nameHint != null ? nameHint.getName(state) : null;
  93       //"pseudo-imports"
  94       if (name != null) {
  95         PsiClass imported = myPseudoImports.get(name);
  96         if (imported != null) {
  97           if (!processor.execute(imported, state)) return false;
  98         }
  99       } else {
 100         for (PsiClass aClass : myPseudoImports.values()) {
 101           if (!processor.execute(aClass, state)) return false;
 102         }
 103       }
 104
 105       if (myContext == null) {
 106         if (!JavaResolveUtil.processImplicitlyImportedPackages(processor, state, place, getManager())) return false;
 107       }
 108     }
 109     return true;
 110   }
 111
 112   public boolean isSamePackage(PsiElement other) {
 113     if (other instanceof DummyHolder) {
 114       final PsiElement otherContext = ((DummyHolder)other).myContext;
 115       if (myContext == null) return otherContext == null;
 116       return JavaPsiFacade.getInstance(myContext.getProject()).arePackagesTheSame(myContext, otherContext);
 117     }
 118     if (other instanceof PsiJavaFile) {
 119       if (myContext != null) return JavaPsiFacade.getInstance(myContext.getProject()).arePackagesTheSame(myContext, other);
 120       final String packageName = ((PsiJavaFile)other).getPackageName();
 121       return "".equals(packageName);
 122     }
 123     return false;
 124   }
 125
 126   public boolean isInPackage(PsiPackage aPackage) {
 127     if (myContext != null) return JavaPsiFacade.getInstance(myContext.getProject()).isInPackage(myContext, aPackage);
 128     return aPackage == null || "".equals(aPackage.getQualifiedName());
 129   }
 130
 131
 132   public void setOriginalFile(@NotNull final PsiFile originalFile) {
 133     super.setOriginalFile(originalFile);
 134     putUserData(PsiUtil.FILE_LANGUAGE_LEVEL_KEY, PsiUtil.getLanguageLevel(originalFile));
 135   }
 136 }