run tests on module classpath: Inspection Gadgets
[idea/community.git] / java / java-impl / src / com / intellij / psi / impl / PsiClassImplUtil.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;
17
18 import com.intellij.openapi.diagnostic.Logger;
19 import com.intellij.openapi.roots.ProjectFileIndex;
20 import com.intellij.openapi.roots.ProjectRootManager;
21 import com.intellij.openapi.util.*;
22 import com.intellij.openapi.vfs.VirtualFile;
23 import com.intellij.psi.*;
24 import com.intellij.psi.augment.PsiAugmentProvider;
25 import com.intellij.psi.filters.OrFilter;
26 import com.intellij.psi.impl.compiled.ClsElementImpl;
27 import com.intellij.psi.impl.source.PsiImmediateClassType;
28 import com.intellij.psi.infos.MethodCandidateInfo;
29 import com.intellij.psi.scope.ElementClassFilter;
30 import com.intellij.psi.scope.ElementClassHint;
31 import com.intellij.psi.scope.NameHint;
32 import com.intellij.psi.scope.PsiScopeProcessor;
33 import com.intellij.psi.scope.processor.FilterScopeProcessor;
34 import com.intellij.psi.scope.processor.MethodResolverProcessor;
35 import com.intellij.psi.search.GlobalSearchScope;
36 import com.intellij.psi.search.LocalSearchScope;
37 import com.intellij.psi.search.PackageScope;
38 import com.intellij.psi.search.SearchScope;
39 import com.intellij.psi.util.*;
40 import com.intellij.ui.IconDeferrer;
41 import com.intellij.ui.RowIcon;
42 import com.intellij.util.Function;
43 import com.intellij.util.IncorrectOperationException;
44 import com.intellij.util.ReflectionCache;
45 import com.intellij.util.SmartList;
46 import com.intellij.util.containers.HashMap;
47 import gnu.trove.THashSet;
48 import org.jetbrains.annotations.NonNls;
49 import org.jetbrains.annotations.NotNull;
50 import org.jetbrains.annotations.Nullable;
51
52 import javax.swing.*;
53 import java.util.*;
54
55 /**
56  * Created by IntelliJ IDEA.
57  * User: ik
58  * Date: 24.10.2003
59  * Time: 16:50:37
60  * To change this template use Options | File Templates.
61  */
62 public class PsiClassImplUtil {
63   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.PsiClassImplUtil");
64   private static final Key<Boolean> NAME_MAPS_BUILT_FLAG = Key.create("NAME_MAPS_BUILT_FLAG");
65
66   private static final Key<CachedValue<Map>> MAP_IN_CLASS_KEY = Key.create("MAP_KEY");
67
68   @NotNull public static PsiField[] getAllFields(final PsiClass aClass) {
69     List<PsiField> map = getAllByMap(aClass, PsiField.class);
70     return map.toArray(new PsiField[map.size()]);
71   }
72
73   @NotNull public static PsiMethod[] getAllMethods(final PsiClass aClass) {
74     List<PsiMethod> methods = getAllByMap(aClass, PsiMethod.class);
75     return methods.toArray(new PsiMethod[methods.size()]);
76   }
77
78   @NotNull public static PsiClass[] getAllInnerClasses(PsiClass aClass) {
79     List<PsiClass> classes = getAllByMap(aClass, PsiClass.class);
80     return classes.toArray(new PsiClass[classes.size()]);
81   }
82
83   @Nullable public static PsiField findFieldByName(PsiClass aClass, String name, boolean checkBases) {
84     final List<PsiField> byMap = findByMap(aClass, name, checkBases, PsiField.class);
85     return byMap.isEmpty() ? null : byMap.get(0);
86   }
87
88   @NotNull public static PsiMethod[] findMethodsByName(PsiClass aClass, String name, boolean checkBases) {
89     List<PsiMethod> methods = findByMap(aClass, name, checkBases, PsiMethod.class);
90     return methods.toArray(new PsiMethod[methods.size()]);
91   }
92
93   @Nullable public static PsiMethod findMethodBySignature(final PsiClass aClass, final PsiMethod patternMethod, final boolean checkBases) {
94     final List<PsiMethod> result = findMethodsBySignature(aClass, patternMethod, checkBases, true);
95     return result.isEmpty() ? null : result.get(0);
96   }
97
98   // ----------------------------- findMethodsBySignature -----------------------------------
99
100   @NotNull public static PsiMethod[] findMethodsBySignature(final PsiClass aClass, final PsiMethod patternMethod, final boolean checkBases) {
101     List<PsiMethod> methods = findMethodsBySignature(aClass, patternMethod, checkBases, false);
102     return methods.toArray(new PsiMethod[methods.size()]);
103   }
104
105   @NotNull private static List<PsiMethod> findMethodsBySignature(final PsiClass aClass,
106                                                     final PsiMethod patternMethod,
107                                                     final boolean checkBases,
108                                                     final boolean stopOnFirst) {
109 /*    final MethodSignature patternSignature = MethodSignatureBackedByPsiMethod.create(patternMethod, PsiSubstitutor.EMPTY);
110     if (!checkBases) {
111       final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), false);
112       if (methodsByName.length == 0) return PsiMethod.EMPTY_ARRAY;
113       List<PsiMethod> result = new ArrayList<PsiMethod>();
114       for (PsiMethod method : methodsByName) {
115         final MethodSignature otherSignature = method.getSignature(PsiSubstitutor.EMPTY);
116         if (otherSignature.equals(patternSignature)) {
117           result.add(method);
118           if (stopOnFirst) break;
119         }
120       }
121
122       return result.toArray(new PsiMethod[result.size()]);
123     }
124     else {
125       final Set<HierarchicalMethodSignature> signatures = getOverrideEquivalentSignatures(aClass);
126       final HierarchicalMethodSignature signatureWithSupers = signatures.get(patternSignature);
127       if (signatureWithSupers == null) return PsiMethod.EMPTY_ARRAY;
128       final List<PsiMethod> result = new ArrayList<PsiMethod>();
129       MethodSignatureUtil.processMethodHierarchy(signatureWithSupers, new Processor<HierarchicalMethodSignature>() {
130         public boolean process(final HierarchicalMethodSignature sig) {
131           result.add(sig.getSignature().getMethod());
132           return !stopOnFirst;
133         }
134       });
135       return result.toArray(new PsiMethod[result.size()]);
136     }*/
137
138     final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases);
139     if (methodsByName.length == 0) return Collections.emptyList();
140     final List<PsiMethod> methods = new SmartList<PsiMethod>();
141     final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
142     for (final PsiMethod method : methodsByName) {
143       final PsiClass superClass = method.getContainingClass();
144       final PsiSubstitutor substitutor;
145       if (checkBases && !aClass.equals(superClass)) {
146         substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
147       }
148       else {
149         substitutor = PsiSubstitutor.EMPTY;
150       }
151       final MethodSignature signature = method.getSignature(substitutor);
152       if (signature.equals(patternSignature)) {
153         methods.add(method);
154         if (stopOnFirst) {
155           break;
156         }
157       }
158     }
159     return methods;
160   }
161
162   // ----------------------------------------------------------------------------------------
163
164   @Nullable public static PsiClass findInnerByName(PsiClass aClass, String name, boolean checkBases) {
165     final List<PsiClass> byMap = findByMap(aClass, name, checkBases, PsiClass.class);
166     return byMap.isEmpty() ? null : byMap.get(0);
167   }
168
169   @SuppressWarnings({"unchecked"})
170   @NotNull private static <T extends PsiMember> List<T> findByMap(PsiClass aClass, String name, boolean checkBases, Class<T> type) {
171     if (name == null) return Collections.emptyList();
172
173     if (!checkBases) {
174       T[] members = null;
175       if (ReflectionCache.isAssignable(type,PsiMethod.class)) {
176         members = (T[])aClass.getMethods();
177       }
178       else if (ReflectionCache.isAssignable(type,PsiClass.class)) {
179         members = (T[])aClass.getInnerClasses();
180       }
181       else if (ReflectionCache.isAssignable(type,PsiField.class)) {
182         members = (T[])aClass.getFields();
183       }
184       if (members == null) return Collections.emptyList();
185
186       List<T> list = new ArrayList<T>();
187       for (T member : members) {
188         if (name.equals(member.getName())) list.add(member);
189       }
190       return list;
191     }
192     else {
193       final Map<String, List<Pair<T, PsiSubstitutor>>> allMethodsMap = getMap(aClass, type);
194       final List<Pair<T, PsiSubstitutor>> list = allMethodsMap.get(name);
195       if (list == null) return Collections.emptyList();
196       final List<T> ret = new ArrayList<T>();
197       for (final Pair<T, PsiSubstitutor> info : list) {
198         ret.add(info.getFirst());
199       }
200
201       return ret;
202     }
203   }
204
205   public static <T extends PsiMember> List<Pair<T, PsiSubstitutor>> getAllWithSubstitutorsByMap(PsiClass aClass, Class<T> type) {
206     final Map<String, List<Pair<T, PsiSubstitutor>>> allMap = getMap(aClass, type);
207     return allMap.get(ALL);
208   }
209
210   @NotNull private static <T extends PsiMember> List<T> getAllByMap(PsiClass aClass, Class<T> type) {
211     List<Pair<T, PsiSubstitutor>> pairs = getAllWithSubstitutorsByMap(aClass, type);
212
213     assert pairs != null : "pairs should be already computed. Wrong allMap: " + getMap(aClass, type);
214
215     final List<T> ret = new ArrayList<T>(pairs.size());
216     for (final Pair<T, PsiSubstitutor> pair : pairs) {
217       T t = pair.getFirst();
218       LOG.assertTrue(t != null, aClass);
219       ret.add(t);
220     }
221     return ret;
222   }
223
224   @NonNls private static final String ALL = "Intellij-IDEA-ALL";
225
226   private static Map<Class<? extends PsiMember>, Map<String, List<Pair<PsiMember, PsiSubstitutor>>>> buildAllMaps(final PsiClass psiClass) {
227     final List<Pair<PsiMember, PsiSubstitutor>> classes = new ArrayList<Pair<PsiMember, PsiSubstitutor>>();
228     final List<Pair<PsiMember, PsiSubstitutor>> fields = new ArrayList<Pair<PsiMember, PsiSubstitutor>>();
229     final List<Pair<PsiMember, PsiSubstitutor>> methods = new ArrayList<Pair<PsiMember, PsiSubstitutor>>();
230
231     FilterScopeProcessor<MethodCandidateInfo> processor = new FilterScopeProcessor<MethodCandidateInfo>(
232       new OrFilter(ElementClassFilter.METHOD, ElementClassFilter.FIELD, ElementClassFilter.CLASS)) {
233       protected void add(PsiElement element, PsiSubstitutor substitutor) {
234         if (element instanceof PsiMethod) {
235           methods.add(new Pair<PsiMember, PsiSubstitutor>((PsiMethod)element, substitutor));
236         }
237         else if (element instanceof PsiField) {
238           fields.add(new Pair<PsiMember, PsiSubstitutor>((PsiField)element, substitutor));
239         }
240         else if (element instanceof PsiClass) {
241           classes.add(new Pair<PsiMember, PsiSubstitutor>((PsiClass)element, substitutor));
242         }
243       }
244     };
245     PsiElementFactory factory = JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory();
246     processDeclarationsInClassNotCached(psiClass, processor, ResolveState.initial(),  new THashSet<PsiClass>(), null, psiClass, false, factory);
247
248     Map<Class<? extends PsiMember>, Map<String, List<Pair<PsiMember, PsiSubstitutor>>>> result = new HashMap<Class<? extends PsiMember>, Map<String, List<Pair<PsiMember, PsiSubstitutor>>>>(3);
249     result.put(PsiClass.class, generateMapByList(classes));
250     result.put(PsiMethod.class, generateMapByList(methods));
251     result.put(PsiField.class, generateMapByList(fields));
252     psiClass.putUserData(NAME_MAPS_BUILT_FLAG, Boolean.TRUE);
253     return result;
254   }
255
256   private static Map<String, List<Pair<PsiMember, PsiSubstitutor>>> generateMapByList(@NotNull final List<Pair<PsiMember, PsiSubstitutor>> list) {
257     Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map = new HashMap<String, List<Pair<PsiMember, PsiSubstitutor>>>();
258     map.put(ALL, list);
259     for (final Pair<PsiMember, PsiSubstitutor> info : list) {
260       final PsiMember element = info.getFirst();
261       final String currentName = element.getName();
262       List<Pair<PsiMember, PsiSubstitutor>> listByName = map.get(currentName);
263       if (listByName == null) {
264         listByName = new ArrayList<Pair<PsiMember, PsiSubstitutor>>(1);
265         map.put(currentName, listByName);
266       }
267       listByName.add(info);
268     }
269     return map;
270   }
271
272   private static <T extends PsiMember> Map<String, List<Pair<T, PsiSubstitutor>>> getMap(final PsiClass aClass, Class<T> memberClazz) {
273     CachedValue<Map> value = aClass.getUserData(MAP_IN_CLASS_KEY);
274     if (value == null) {
275       final CachedValueProvider<Map> provider = new ByNameCachedValueProvider(aClass);
276       value = CachedValuesManager.getManager(aClass.getProject()).createCachedValue(provider, false);
277       //Do not cache for nonphysical elements
278       if (aClass.isPhysical()) {
279         value = ((UserDataHolderEx)aClass).putUserDataIfAbsent(MAP_IN_CLASS_KEY, value);
280       }
281     }
282     return (Map<String, List<Pair<T, PsiSubstitutor>>>)value.getValue().get(memberClazz);
283   }
284
285   private static class ClassIconRequest {
286     public PsiClass psiClass;
287     public int flags;
288
289     private ClassIconRequest(PsiClass psiClass, int flags) {
290       this.psiClass = psiClass;
291       this.flags = flags;
292     }
293
294     @Override
295     public boolean equals(Object o) {
296       if (this == o) return true;
297       if (!(o instanceof ClassIconRequest)) return false;
298
299       ClassIconRequest that = (ClassIconRequest)o;
300
301       if (flags != that.flags) return false;
302       if (psiClass != null ? !psiClass.equals(that.psiClass) : that.psiClass != null) return false;
303
304       return true;
305     }
306
307     @Override
308     public int hashCode() {
309       int result = psiClass != null ? psiClass.hashCode() : 0;
310       result = 31 * result + flags;
311       return result;
312     }
313   }
314
315   private static final Function<ClassIconRequest, Icon> FULL_ICON_EVALUATOR = new Function<ClassIconRequest, Icon>() {
316     public Icon fun(ClassIconRequest r) {
317       if (!r.psiClass.isValid() || r.psiClass.getProject().isDisposed()) return null;
318
319       final boolean isLocked = (r.flags & Iconable.ICON_FLAG_READ_STATUS) != 0 && !r.psiClass.isWritable();
320       Icon symbolIcon = ElementPresentationUtil.getClassIconOfKind(r.psiClass, ElementPresentationUtil.getClassKind(r.psiClass));
321       RowIcon baseIcon = ElementBase.createLayeredIcon(symbolIcon, ElementPresentationUtil.getFlags(r.psiClass, isLocked));
322       return ElementPresentationUtil.addVisibilityIcon(r.psiClass, r.flags, baseIcon);
323     }
324   };
325
326   public static Icon getClassIcon(final int flags, final PsiClass aClass) {
327     Icon base = aClass.getUserData(Iconable.LAST_COMPUTED_ICON);
328     if (base == null) {
329       Icon symbolIcon = ElementPresentationUtil.getClassIconOfKind(aClass, ElementPresentationUtil.getBasicClassKind(aClass));
330       RowIcon baseIcon = ElementBase.createLayeredIcon(symbolIcon, 0);
331       base = ElementPresentationUtil.addVisibilityIcon(aClass, flags, baseIcon);
332     }
333
334     return IconDeferrer.getInstance().defer(base, new ClassIconRequest(aClass, flags), FULL_ICON_EVALUATOR);
335   }
336
337   public static SearchScope getClassUseScope(final PsiClass aClass) {
338     final GlobalSearchScope maximalUseScope = ((PsiManagerEx) aClass.getManager()).getFileManager().getUseScope(aClass);
339     if (aClass instanceof PsiAnonymousClass) {
340       return new LocalSearchScope(aClass);
341     }
342     PsiFile file = aClass.getContainingFile();
343     if (JspPsiUtil.isInJspFile(file)) return maximalUseScope;
344     final PsiClass containingClass = aClass.getContainingClass();
345     if (aClass.hasModifierProperty(PsiModifier.PUBLIC)) {
346       return containingClass != null ? containingClass.getUseScope() : maximalUseScope;
347     }
348     else if (aClass.hasModifierProperty(PsiModifier.PROTECTED)) {
349       return containingClass != null ? containingClass.getUseScope() : maximalUseScope;
350     }
351     else if (aClass.hasModifierProperty(PsiModifier.PRIVATE) || aClass instanceof PsiTypeParameter) {
352       PsiClass topClass = PsiUtil.getTopLevelClass(aClass);
353       return new LocalSearchScope(topClass == null ? aClass.getContainingFile() : topClass);
354     }
355     else {
356       PsiPackage aPackage = null;
357       if (file instanceof PsiJavaFile) {
358         aPackage = JavaPsiFacade.getInstance(aClass.getProject()).findPackage(((PsiJavaFile)file).getPackageName());
359       }
360
361       if (aPackage == null) {
362         PsiDirectory dir = file.getContainingDirectory();
363         if (dir != null) {
364           aPackage = JavaDirectoryService.getInstance().getPackage(dir);
365         }
366       }
367
368       if (aPackage != null) {
369         SearchScope scope = PackageScope.packageScope(aPackage, false);
370         scope = scope.intersectWith(maximalUseScope);
371         return scope;
372       }
373
374       return new LocalSearchScope(file);
375     }
376   }
377
378   public static boolean isMainMethod(PsiMethod method) {
379     if (!PsiType.VOID.equals(method.getReturnType())) return false;
380     PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory();
381     try {
382       PsiMethod appMain = factory.createMethodFromText("void main(String[] args);", null);
383       if (MethodSignatureUtil.areSignaturesEqual(method, appMain)) return true;
384       PsiMethod appPremain = factory.createMethodFromText("void premain(String args, java.lang.instrument.Instrumentation i);", null);
385       if (MethodSignatureUtil.areSignaturesEqual(method, appPremain)) return true;
386     }
387     catch (IncorrectOperationException e) {
388       LOG.error(e);
389     }
390     return false;
391   }
392
393   private static class ByNameCachedValueProvider implements CachedValueProvider<Map> {
394     private final PsiClass myClass;
395
396     private ByNameCachedValueProvider(final PsiClass aClass) {
397       myClass = aClass;
398     }
399
400     public Result<Map> compute() {
401       final Map<Class<? extends PsiMember>, Map<String, List<Pair<PsiMember, PsiSubstitutor>>>> map = buildAllMaps(myClass);
402       return new Result<Map>(map, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
403     }
404   }
405
406   public static boolean processDeclarationsInClass(PsiClass aClass,
407                                                    PsiScopeProcessor processor,
408                                                    ResolveState state,
409                                                    Set<PsiClass> visited,
410                                                    PsiElement last,
411                                                    PsiElement place,
412                                                    boolean isRaw) {
413     if (visited != null && visited.contains(aClass)) return true;
414     PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
415     isRaw = isRaw || PsiUtil.isRawSubstitutor(aClass, substitutor);
416     if (last instanceof PsiTypeParameterList || last instanceof PsiModifierList) return true; //TypeParameterList and ModifierList do not see our declarations
417     final Boolean built = aClass.getUserData(NAME_MAPS_BUILT_FLAG);
418     PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
419     if (built == null) {
420       return processDeclarationsInClassNotCached(aClass, processor, state, visited, last, place, isRaw, factory);
421     }
422
423     final NameHint nameHint = processor.getHint(NameHint.KEY);
424     final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
425
426     if (nameHint != null) {
427       if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.FIELD)) {
428         final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false);
429         if (fieldByName != null) {
430           processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
431           if (!processor.execute(fieldByName, state)) return false;
432         }
433         else {
434           final Map<String, List<Pair<PsiField, PsiSubstitutor>>> allFieldsMap = getMap(aClass, PsiField.class);
435
436           final List<Pair<PsiField, PsiSubstitutor>> list = allFieldsMap.get(nameHint.getName(state));
437           if (list != null) {
438             for (final Pair<PsiField, PsiSubstitutor> candidate : list) {
439               PsiField candidateField = candidate.getFirst();
440               PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor(candidateField.getContainingClass(), candidate.getSecond(), aClass,
441                                                                        substitutor, place, factory);
442
443               processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, candidateField.getContainingClass());
444               if (!processor.execute(candidateField, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false;
445             }
446           }
447         }
448       }
449       if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.CLASS)) {
450         if (last != null && last.getParent() == aClass) {
451           if (last instanceof PsiClass) {
452             if (!processor.execute(last, state)) return false;
453           }
454           // Parameters
455           final PsiTypeParameterList list = aClass.getTypeParameterList();
456           if (list != null && !list.processDeclarations(processor, state, last, place)) return false;
457         }
458         if (!(last instanceof PsiReferenceList)) {
459           final PsiClass classByName = aClass.findInnerClassByName(nameHint.getName(state), false);
460           if (classByName != null) {
461             processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
462             if (!processor.execute(classByName, state)) return false;
463           }
464           else {
465             final Map<String, List<Pair<PsiClass, PsiSubstitutor>>> allClassesMap = getMap(aClass, PsiClass.class);
466
467             final List<Pair<PsiClass, PsiSubstitutor>> list = allClassesMap.get(nameHint.getName(state));
468             if (list != null) {
469               for (final Pair<PsiClass, PsiSubstitutor> candidate : list) {
470                 final PsiClass inner = candidate.getFirst();
471                 final PsiClass containingClass = inner.getContainingClass();
472                 if (containingClass != null) {
473                   PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor(containingClass, candidate.getSecond(), aClass,
474                                                                            substitutor, place, factory);
475                   processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
476                   if (!processor.execute(inner, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false;
477                 }
478               }
479             }
480           }
481         }
482       }
483       if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.METHOD)) {
484         if (processor instanceof MethodResolverProcessor) {
485           final MethodResolverProcessor methodResolverProcessor = (MethodResolverProcessor)processor;
486           if (methodResolverProcessor.isConstructor()) {
487             final PsiMethod[] constructors = aClass.getConstructors();
488             methodResolverProcessor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
489             for (PsiMethod constructor : constructors) {
490               if (!methodResolverProcessor.execute(constructor, state)) return false;
491             }
492             return true;
493           }
494         }
495         final Map<String, List<Pair<PsiMethod, PsiSubstitutor>>> allMethodsMap = getMap(aClass, PsiMethod.class);
496         final List<Pair<PsiMethod, PsiSubstitutor>> list = allMethodsMap.get(nameHint.getName(state));
497         if (list != null) {
498           for (final Pair<PsiMethod, PsiSubstitutor> candidate : list) {
499             PsiMethod candidateMethod = candidate.getFirst();
500             if (processor instanceof MethodResolverProcessor) {
501               if (candidateMethod.isConstructor() != ((MethodResolverProcessor)processor).isConstructor()) continue;
502             }
503             final PsiClass containingClass = candidateMethod.getContainingClass();
504             PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor(containingClass, candidate.getSecond(), aClass,
505                                                                      substitutor, place, factory);
506             if (isRaw && !candidateMethod.hasModifierProperty(PsiModifier.STATIC)) { //static methods are not erased due to raw overriding
507               PsiTypeParameter[] methodTypeParameters = candidateMethod.getTypeParameters();
508               finalSubstitutor = factory.createRawSubstitutor(finalSubstitutor, methodTypeParameters);
509             }
510             processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
511             if (!processor.execute(candidateMethod, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false;
512           }
513         }
514       }
515       return true;
516     }
517
518     return processDeclarationsInClassNotCached(aClass, processor, state, visited, last, place, isRaw, factory);
519   }
520
521   public static PsiSubstitutor obtainFinalSubstitutor(@NotNull PsiClass candidateClass, PsiSubstitutor candidateSubstitutor, PsiClass aClass,
522                                                        PsiSubstitutor substitutor,
523                                                        final PsiElement place,
524                                                        PsiElementFactory elementFactory) {
525     if (PsiUtil.isRawSubstitutor(aClass, substitutor)) {
526       return elementFactory.createRawSubstitutor(candidateClass);
527     }
528
529     final PsiType containingType = elementFactory.createType(candidateClass, candidateSubstitutor, PsiUtil.getLanguageLevel(place));
530     PsiType type = substitutor.substitute(containingType);
531     if (!(type instanceof PsiClassType)) return candidateSubstitutor;
532     return ((PsiClassType)type).resolveGenerics().getSubstitutor();
533   }
534
535   private static boolean processDeclarationsInClassNotCached(PsiClass aClass, PsiScopeProcessor processor, ResolveState state, Set<PsiClass> visited,
536                                                              PsiElement last,
537                                                              PsiElement place,
538                                                              boolean isRaw,
539                                                              PsiElementFactory factory) {
540     if (visited == null) visited = new THashSet<PsiClass>();
541     if (!visited.add(aClass)) return true;
542     processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
543     final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
544     final NameHint nameHint = processor.getHint(NameHint.KEY);
545
546
547     if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.FIELD)) {
548       if (nameHint != null) {
549         final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false);
550         if (fieldByName != null) {
551           if (!processor.execute(fieldByName, state)) return false;
552         }
553       }
554       else {
555         final PsiField[] fields = aClass.getFields();
556         for (final PsiField field : fields) {
557           if (!processor.execute(field, state)) return false;
558         }
559       }
560
561       for (PsiField field : PsiAugmentProvider.collectAugments(aClass, PsiField.class)) {
562         if (!processor.execute(field, state)) return false;
563       }
564     }
565
566     if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.METHOD)) {
567       final PsiMethod[] methods = nameHint != null ? aClass.findMethodsByName(nameHint.getName(state), false) : aClass.getMethods();
568       for (final PsiMethod method : methods) {
569         if (isRaw && !method.hasModifierProperty(PsiModifier.STATIC)) { //static methods are not erased due to raw overriding
570           PsiTypeParameter[] methodTypeParameters = method.getTypeParameters();
571           PsiSubstitutor raw = factory.createRawSubstitutor(state.get(PsiSubstitutor.KEY), methodTypeParameters);
572           state = state.put(PsiSubstitutor.KEY, raw);
573         }
574         if (!processor.execute(method, state)) return false;
575       }
576
577       for (PsiMethod method : PsiAugmentProvider.collectAugments(aClass, PsiMethod.class)) {
578         if (!processor.execute(method, state)) return false;
579       }
580     }
581
582     if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.CLASS)) {
583       if (last != null && last.getParent() == aClass) {
584         // Parameters
585         final PsiTypeParameterList list = aClass.getTypeParameterList();
586         if (list != null && !list.processDeclarations(processor, ResolveState.initial(), last, place)) return false;
587       }
588
589       if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) {
590         // Inners
591         if (nameHint != null) {
592           final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false);
593           if (inner != null) {
594             if (!processor.execute(inner, state)) return false;
595           }
596         }
597         else {
598           final PsiClass[] inners = aClass.getInnerClasses();
599           for (final PsiClass inner : inners) {
600             if (!processor.execute(inner, state)) return false;
601           }
602         }
603       }
604     }
605
606     return last instanceof PsiReferenceList || processSuperTypes(aClass, processor, visited, last, place, state, isRaw, factory);
607   }
608
609   private static boolean processSuperTypes(PsiClass aClass,
610                                            PsiScopeProcessor processor,
611                                            Set<PsiClass> visited,
612                                            PsiElement last,
613                                            PsiElement place,
614                                            ResolveState state,
615                                            boolean isRaw, PsiElementFactory factory) {
616     for (final PsiClassType superType : aClass.getSuperTypes()) {
617       final PsiClassType.ClassResolveResult superTypeResolveResult = superType.resolveGenerics();
618       PsiClass superClass = superTypeResolveResult.getElement();
619       if (superClass == null) continue;
620       PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor(superClass, superTypeResolveResult.getSubstitutor(), aClass, state.get(PsiSubstitutor.KEY),
621                                                                place, factory);
622       if (!processDeclarationsInClass(superClass, processor, state.put(PsiSubstitutor.KEY, finalSubstitutor), visited, last, place, isRaw)) {
623         return false;
624       }
625     }
626     return true;
627   }
628
629   @Nullable
630   public static PsiClass getSuperClass(PsiClass psiClass) {
631     PsiManager manager = psiClass.getManager();
632     GlobalSearchScope resolveScope = psiClass.getResolveScope();
633
634     final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
635     if (psiClass.isInterface()) {
636       return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
637     }
638     if (psiClass.isEnum()) {
639       return facade.findClass(CommonClassNames.JAVA_LANG_ENUM, resolveScope);
640     }
641
642     if (psiClass instanceof PsiAnonymousClass) {
643       PsiClassType baseClassReference = ((PsiAnonymousClass)psiClass).getBaseClassType();
644       PsiClass baseClass = baseClassReference.resolve();
645       if (baseClass == null || baseClass.isInterface()) return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
646       return baseClass;
647     }
648
649     if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return null;
650
651     final PsiClassType[] referenceElements = psiClass.getExtendsListTypes();
652
653     if (referenceElements.length == 0) return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
654
655     PsiClass psiResoved = referenceElements[0].resolve();
656     return psiResoved == null ? facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope) : psiResoved;
657   }
658
659   @NotNull public static PsiClass[] getSupers(PsiClass psiClass) {
660     final PsiClass[] supers = getSupersInner(psiClass);
661     for (final PsiClass aSuper : supers) {
662       LOG.assertTrue(aSuper != null);
663     }
664     return supers;
665   }
666
667   private static PsiClass[] getSupersInner(PsiClass psiClass) {
668     PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
669     PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
670
671     if (psiClass.isInterface()) {
672       return resolveClassReferenceList(extendsListTypes,
673                                        psiClass.getManager(), psiClass.getResolveScope(), true);
674     }
675
676     if (psiClass instanceof PsiAnonymousClass) {
677       PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass)psiClass;
678       PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType();
679       PsiClass baseClass = baseClassReference.resolve();
680       if (baseClass != null) {
681         if (baseClass.isInterface()) {
682           PsiClass objectClass = JavaPsiFacade.getInstance(psiClass.getProject()).findClass("java.lang.Object", psiClass.getResolveScope());
683           return objectClass != null ? new PsiClass[]{objectClass, baseClass} : new PsiClass[]{baseClass};
684         }
685         return new PsiClass[]{baseClass};
686       }
687
688       PsiClass objectClass = JavaPsiFacade.getInstance(psiClass.getProject()).findClass("java.lang.Object", psiClass.getResolveScope());
689       return objectClass != null ? new PsiClass[]{objectClass} : PsiClass.EMPTY_ARRAY;
690     }
691     else if (psiClass instanceof PsiTypeParameter) {
692       if (extendsListTypes.length == 0) {
693         final PsiClass objectClass =
694           JavaPsiFacade.getInstance(psiClass.getProject()).findClass("java.lang.Object", psiClass.getResolveScope());
695         return objectClass != null ? new PsiClass[]{objectClass} : PsiClass.EMPTY_ARRAY;
696       }
697       return resolveClassReferenceList(extendsListTypes, psiClass.getManager(),
698                                        psiClass.getResolveScope(), false);
699     }
700
701     PsiClass[] interfaces = resolveClassReferenceList(implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
702
703     PsiClass superClass = getSuperClass(psiClass);
704     if (superClass == null) return interfaces;
705     PsiClass[] types = new PsiClass[interfaces.length + 1];
706     types[0] = superClass;
707     System.arraycopy(interfaces, 0, types, 1, interfaces.length);
708
709     return types;
710   }
711
712   @NotNull public static PsiClassType[] getSuperTypes(PsiClass psiClass) {
713     if (psiClass instanceof PsiAnonymousClass) {
714       PsiClassType baseClassType = ((PsiAnonymousClass)psiClass).getBaseClassType();
715       PsiClass baseClass = baseClassType.resolve();
716       if (baseClass == null || !baseClass.isInterface()) {
717         return new PsiClassType[]{baseClassType};
718       }
719       else {
720         PsiClassType objectType = PsiType.getJavaLangObject(psiClass.getManager(), psiClass.getResolveScope());
721         return new PsiClassType[]{objectType, baseClassType};
722       }
723     }
724
725     PsiClassType[] extendsTypes = psiClass.getExtendsListTypes();
726     PsiClassType[] implementsTypes = psiClass.getImplementsListTypes();
727     boolean hasExtends = extendsTypes.length != 0;
728     int extendsListLength = extendsTypes.length + (hasExtends ? 0 : 1);
729     PsiClassType[] result = new PsiClassType[extendsListLength + implementsTypes.length];
730
731     System.arraycopy(extendsTypes, 0, result, 0, extendsTypes.length);
732     if (!hasExtends) {
733       if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) {
734         return PsiClassType.EMPTY_ARRAY;
735       }
736       PsiManager manager = psiClass.getManager();
737       PsiClassType objectType = PsiType.getJavaLangObject(manager, psiClass.getResolveScope());
738       result[0] = objectType;
739     }
740     System.arraycopy(implementsTypes, 0, result, extendsListLength, implementsTypes.length);
741     for (int i = 0; i < result.length; i++) {
742       PsiClassType type = result[i];
743       result[i] = (PsiClassType)PsiUtil.captureToplevelWildcards(type, psiClass);
744     }
745     return result;
746   }
747
748   private static PsiClassType getAnnotationSuperType(PsiClass psiClass, PsiElementFactory factory) {
749     return factory.createTypeByFQClassName("java.lang.annotation.Annotation", psiClass.getResolveScope());
750   }
751
752   private static PsiClassType getEnumSuperType(PsiClass psiClass, PsiElementFactory factory) {
753     PsiClassType superType;
754     final PsiManager manager = psiClass.getManager();
755     final PsiClass enumClass = JavaPsiFacade.getInstance(manager.getProject()).findClass("java.lang.Enum", psiClass.getResolveScope());
756     if (enumClass == null) {
757       try {
758         superType = (PsiClassType)factory.createTypeFromText("java.lang.Enum", null);
759       }
760       catch (IncorrectOperationException e) {
761         superType = null;
762       }
763     }
764     else {
765       final PsiTypeParameter[] typeParameters = enumClass.getTypeParameters();
766       PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
767       if (typeParameters.length == 1) {
768         substitutor = substitutor.put(typeParameters[0], factory.createType(psiClass));
769       }
770       superType = new PsiImmediateClassType(enumClass, substitutor);
771     }
772     return superType;
773   }
774
775   public static PsiClass[] getInterfaces(PsiTypeParameter typeParameter) {
776     final ArrayList<PsiClass> result = new ArrayList<PsiClass>();
777     final PsiClassType[] referencedTypes = typeParameter.getExtendsListTypes();
778     for (PsiClassType referencedType : referencedTypes) {
779       final PsiClass psiClass = referencedType.resolve();
780       if (psiClass != null && psiClass.isInterface()) {
781         result.add(psiClass);
782       }
783     }
784     return result.toArray(new PsiClass[result.size()]);
785   }
786
787   public static PsiClass[] getInterfaces(PsiClass psiClass) {
788     final PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
789     if (psiClass.isInterface()) {
790       return resolveClassReferenceList(extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
791     }
792
793     if (psiClass instanceof PsiAnonymousClass) {
794       PsiClassType baseClassReference = ((PsiAnonymousClass)psiClass).getBaseClassType();
795       PsiClass baseClass = baseClassReference.resolve();
796       if (baseClass != null && baseClass.isInterface()) return new PsiClass[]{baseClass};
797       return PsiClass.EMPTY_ARRAY;
798     }
799
800     final PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
801
802     return resolveClassReferenceList(implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
803   }
804
805   private static PsiClass[] resolveClassReferenceList(final PsiClassType[] listOfTypes,
806                                                       final PsiManager manager, final GlobalSearchScope resolveScope, boolean includeObject)
807   {
808     PsiClass objectClass = JavaPsiFacade.getInstance(manager.getProject()).findClass("java.lang.Object", resolveScope);
809     if (objectClass == null) includeObject = false;
810     if (listOfTypes == null || listOfTypes.length == 0) {
811       if (includeObject) return new PsiClass[]{objectClass};
812       return PsiClass.EMPTY_ARRAY;
813     }
814
815     int referenceCount = listOfTypes.length;
816     if (includeObject) referenceCount++;
817
818     PsiClass[] resolved = new PsiClass[referenceCount];
819     int resolvedCount = 0;
820
821     if (includeObject) resolved[resolvedCount++] = objectClass;
822     for (PsiClassType reference : listOfTypes) {
823       PsiClass refResolved = reference.resolve();
824       if (refResolved != null) resolved[resolvedCount++] = refResolved;
825     }
826
827     if (resolvedCount < referenceCount) {
828       PsiClass[] shorter = new PsiClass[resolvedCount];
829       System.arraycopy(resolved, 0, shorter, 0, resolvedCount);
830       resolved = shorter;
831     }
832
833     return resolved;
834   }
835
836   public static List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName(PsiClass psiClass, String name, boolean checkBases) {
837     if (!checkBases) {
838       final PsiMethod[] methodsByName = psiClass.findMethodsByName(name, false);
839       final List<Pair<PsiMethod, PsiSubstitutor>> ret = new ArrayList<Pair<PsiMethod, PsiSubstitutor>>(methodsByName.length);
840       for (final PsiMethod method : methodsByName) {
841         ret.add(new Pair<PsiMethod, PsiSubstitutor>(method, PsiSubstitutor.EMPTY));
842       }
843       return ret;
844     }
845     final Map<String, List<Pair<PsiMethod, PsiSubstitutor>>> map = getMap(psiClass, PsiMethod.class);
846     final List<Pair<PsiMethod, PsiSubstitutor>> list = map.get(name);
847     return list == null ?
848            Collections.<Pair<PsiMethod, PsiSubstitutor>>emptyList() :
849            Collections.unmodifiableList(list);
850   }
851
852   public static PsiClassType[] getExtendsListTypes(PsiClass psiClass) {
853     if (psiClass.isEnum()) {
854       return new PsiClassType[]{getEnumSuperType(psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())};
855     }
856     else if (psiClass.isAnnotationType()) {
857       return new PsiClassType[]{getAnnotationSuperType(psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())};
858     }
859     final PsiReferenceList extendsList = psiClass.getExtendsList();
860     if (extendsList != null) {
861       return extendsList.getReferencedTypes();
862     }
863     return PsiClassType.EMPTY_ARRAY;
864   }
865
866   public static PsiClassType[] getImplementsListTypes(PsiClass psiClass) {
867     final PsiReferenceList extendsList = psiClass.getImplementsList();
868     if (extendsList != null) {
869       return extendsList.getReferencedTypes();
870     }
871     return PsiClassType.EMPTY_ARRAY;
872   }
873
874   public static boolean isClassEquivalentTo(PsiClass aClass, PsiElement another) {
875     if (!(another instanceof PsiClass)) return false;
876     String name1 = aClass.getName();
877     if (name1 == null) return false;
878     if (!another.isValid()) return false;
879     String name2 = ((PsiClass)another).getName(); 
880     if (name2 == null) return false;
881     if (name1.hashCode() != name2.hashCode()) return false;
882     if (!name1.equals(name2)) return false;
883     String qName1 = aClass.getQualifiedName();
884     String qName2 = ((PsiClass)another).getQualifiedName();
885     if (qName1 == null || qName2 == null) {
886       //noinspection StringEquality
887       if (qName1 != qName2) return false;
888
889       if (aClass instanceof PsiTypeParameter && another instanceof PsiTypeParameter) {
890         PsiTypeParameter p1 = (PsiTypeParameter)aClass;
891         PsiTypeParameter p2 = (PsiTypeParameter)another;
892
893         return p1.getIndex() == p2.getIndex() &&
894                aClass.getManager().areElementsEquivalent(p1.getOwner(), p2.getOwner());
895
896       }
897       else {
898         return false;
899       }
900     }
901     if (qName1.hashCode() != qName2.hashCode() || !qName1.equals(qName2)) {
902       return false;
903     }
904
905     if (originalElement(aClass).equals(originalElement((PsiClass)another))) {
906       return true;
907     }
908
909     final PsiFile file1 = aClass.getContainingFile().getOriginalFile();
910     final PsiFile file2 = another.getContainingFile().getOriginalFile();
911     if (file1.equals(file2)) {
912       return true;
913     }
914
915     //see com.intellij.openapi.vcs.changes.PsiChangeTracker
916     //see com.intellij.psi.impl.PsiFileFactoryImpl#createFileFromText(CharSequence,PsiFile)
917     final PsiFile original1 = file1.getUserData(PsiFileFactory.ORIGINAL_FILE);
918     final PsiFile original2 = file2.getUserData(PsiFileFactory.ORIGINAL_FILE);
919     if (original1 == original2 && original1 != null
920         || original1 == file2 || original2 == file1) {
921       return true;
922     }    
923
924     final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(aClass.getProject()).getFileIndex();
925     final VirtualFile vfile1 = file1.getViewProvider().getVirtualFile();
926     final VirtualFile vfile2 = file2.getViewProvider().getVirtualFile();
927     return (fileIndex.isInSource(vfile1) || fileIndex.isInLibraryClasses(vfile1)) &&
928            (fileIndex.isInSource(vfile2) || fileIndex.isInLibraryClasses(vfile2));
929   }
930
931   private static PsiElement originalElement(PsiClass aClass) {
932     final PsiElement originalElement = aClass.getOriginalElement();
933     final PsiCompiledElement compiled = originalElement.getUserData(ClsElementImpl.COMPILED_ELEMENT);
934     if (compiled != null) {
935       return compiled;
936     }
937     return originalElement;
938   }
939
940   public static boolean isFieldEquivalentTo(PsiField field, PsiElement another) {
941     if (!(another instanceof PsiField)) return false;
942     String name1 = field.getName();
943     if (name1 == null) return false;
944     if (!another.isValid()) return false;
945
946     String name2 = ((PsiField)another).getName();
947     if (!name1.equals(name2)) return false;
948     PsiClass aClass1 = field.getContainingClass();
949     PsiClass aClass2 = ((PsiField)another).getContainingClass();
950     return aClass1 != null && aClass2 != null && field.getManager().areElementsEquivalent(aClass1, aClass2);
951   }
952
953   public static boolean isMethodEquivalentTo(PsiMethod method1, PsiElement another) {
954     if (!(another instanceof PsiMethod)) return false;
955     PsiMethod method2 = (PsiMethod)another;
956     String name1 = method1.getName();
957     if (!another.isValid()) return false;
958     String name2 = method2.getName();
959     if (!name1.equals(name2)) return false;
960     PsiClass aClass1 = method1.getContainingClass();
961     PsiClass aClass2 = method2.getContainingClass();
962     PsiManager manager = method1.getManager();
963     if (!(aClass1 != null && aClass2 != null && manager.areElementsEquivalent(aClass1, aClass2))) return false;
964
965     PsiParameter[] parameters1 = method1.getParameterList().getParameters();
966     PsiParameter[] parameters2 = method2.getParameterList().getParameters();
967     if (parameters1.length != parameters2.length) return false;
968     for (int i = 0; i < parameters1.length; i++) {
969       PsiParameter parameter1 = parameters1[i];
970       PsiParameter parameter2 = parameters2[i];
971       PsiType type1 = parameter1.getType();
972       PsiType type2 = parameter2.getType();
973       if (!compareParamTypes(manager,type1, type2)) return false;
974     }
975     return true;
976   }
977
978   private static boolean compareParamTypes(@NotNull PsiManager manager, @NotNull PsiType type1, @NotNull PsiType type2) {
979     if (type1 instanceof PsiArrayType) {
980       if (!(type2 instanceof PsiArrayType)) return false;
981       return compareParamTypes(manager, ((PsiArrayType)type1).getComponentType(), ((PsiArrayType)type2).getComponentType());
982     }
983
984     if (!(type1 instanceof PsiClassType) || !(type2 instanceof PsiClassType)) {
985       return type1.equals(type2);
986     }
987
988     PsiClass class1 = ((PsiClassType)type1).resolve();
989     PsiClass class2 = ((PsiClassType)type2).resolve();
990
991     if (class1 instanceof PsiTypeParameter && class2 instanceof PsiTypeParameter) {
992       return Comparing.equal(class1.getName(), class2.getName()) &&
993              ((PsiTypeParameter)class1).getIndex() == ((PsiTypeParameter)class2).getIndex();
994     }
995
996     return manager.areElementsEquivalent(class1, class2);
997   }
998 }