IDEA-58604 smart completion for class name renders double package label
[idea/community.git] / java / java-impl / src / com / intellij / codeInsight / completion / JavaSmartCompletionContributor.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.completion;
17
18 import com.intellij.codeInsight.*;
19 import com.intellij.codeInsight.ExceptionUtil;
20 import com.intellij.codeInsight.lookup.*;
21 import com.intellij.openapi.application.ApplicationManager;
22 import com.intellij.openapi.util.Computable;
23 import com.intellij.openapi.util.Condition;
24 import com.intellij.openapi.util.Key;
25 import com.intellij.openapi.util.Pair;
26 import com.intellij.patterns.ElementPattern;
27 import com.intellij.patterns.PsiJavaPatterns;
28 import com.intellij.psi.*;
29 import com.intellij.psi.filters.ElementExtractorFilter;
30 import com.intellij.psi.filters.ElementFilter;
31 import com.intellij.psi.filters.GeneratorFilter;
32 import com.intellij.psi.filters.OrFilter;
33 import com.intellij.psi.filters.getters.CastTypeGetter;
34 import com.intellij.psi.filters.getters.ExpectedTypesGetter;
35 import com.intellij.psi.filters.getters.InstanceOfLeftPartTypeGetter;
36 import com.intellij.psi.filters.getters.ThrowsListGetter;
37 import com.intellij.psi.filters.types.AssignableFromFilter;
38 import com.intellij.psi.filters.types.AssignableGroupFilter;
39 import com.intellij.psi.filters.types.AssignableToFilter;
40 import com.intellij.psi.impl.source.resolve.reference.impl.PsiMultiReference;
41 import com.intellij.psi.infos.CandidateInfo;
42 import com.intellij.psi.javadoc.PsiDocTag;
43 import com.intellij.psi.statistics.JavaStatisticsManager;
44 import com.intellij.psi.statistics.StatisticsInfo;
45 import com.intellij.psi.statistics.StatisticsManager;
46 import com.intellij.psi.util.InheritanceUtil;
47 import com.intellij.psi.util.PsiTreeUtil;
48 import com.intellij.psi.util.PsiUtil;
49 import com.intellij.psi.util.TypeConversionUtil;
50 import com.intellij.util.*;
51 import com.intellij.util.containers.ContainerUtil;
52 import gnu.trove.THashSet;
53 import gnu.trove.TObjectHashingStrategy;
54 import org.jetbrains.annotations.NonNls;
55 import org.jetbrains.annotations.NotNull;
56 import org.jetbrains.annotations.Nullable;
57
58 import java.util.*;
59
60 import static com.intellij.patterns.PlatformPatterns.psiElement;
61 import static com.intellij.patterns.PsiJavaPatterns.psiMethod;
62 import static com.intellij.patterns.StandardPatterns.*;
63
64 /**
65  * @author peter
66  */
67 public class JavaSmartCompletionContributor extends CompletionContributor {
68   private static final TObjectHashingStrategy<ExpectedTypeInfo> EXPECTED_TYPE_INFO_STRATEGY = new TObjectHashingStrategy<ExpectedTypeInfo>() {
69     public int computeHashCode(final ExpectedTypeInfo object) {
70       return object.getType().hashCode();
71     }
72
73     public boolean equals(final ExpectedTypeInfo o1, final ExpectedTypeInfo o2) {
74       return o1.getType().equals(o2.getType());
75     }
76   };
77
78   private static final ElementExtractorFilter THROWABLES_FILTER = new ElementExtractorFilter(new AssignableFromFilter(CommonClassNames.JAVA_LANG_THROWABLE));
79   @NonNls private static final String EXCEPTION_TAG = "exception";
80   static final ElementPattern<PsiElement> AFTER_NEW =
81       psiElement().afterLeaf(
82           psiElement().withText(PsiKeyword.NEW).andNot(
83               psiElement().afterLeaf(
84                   psiElement().withText(PsiKeyword.THROW))));
85   static final ElementPattern<PsiElement> AFTER_THROW_NEW =
86       psiElement().afterLeaf(
87           psiElement().withText(PsiKeyword.NEW).afterLeaf(
88               psiElement().withText(PsiKeyword.THROW)));
89   private static final OrFilter THROWABLE_TYPE_FILTER = new OrFilter(
90       new GeneratorFilter(AssignableGroupFilter.class, new ThrowsListGetter()),
91       new AssignableFromFilter("java.lang.RuntimeException"));
92   public static final ElementPattern<PsiElement> INSIDE_EXPRESSION = or(
93         psiElement().withParent(PsiExpression.class).andNot(psiElement().withParent(PsiLiteralExpression.class)),
94         psiElement().inside(PsiClassObjectAccessExpression.class),
95         psiElement().inside(PsiThisExpression.class),
96         psiElement().inside(PsiSuperExpression.class)
97         );
98   static final ElementPattern<PsiElement> INSIDE_TYPECAST_EXPRESSION = psiElement().withParent(
99     psiElement(PsiReferenceExpression.class).afterLeaf(
100       psiElement().withText(")").withParent(PsiTypeCastExpression.class)));
101
102   @Nullable
103   private static ElementFilter getReferenceFilter(PsiElement element) {
104     //throw new foo
105     if (AFTER_THROW_NEW.accepts(element)) {
106       return new ElementExtractorFilter(THROWABLE_TYPE_FILTER);
107     }
108
109     //new xxx.yyy
110     if (psiElement().afterLeaf(psiElement().withText(".")).withSuperParent(2, psiElement(PsiNewExpression.class)).accepts(element)) {
111       if (((PsiNewExpression)element.getParent().getParent()).getClassReference() == element.getParent()) {
112         return new GeneratorFilter(AssignableGroupFilter.class, new ExpectedTypesGetter());
113       }
114     }
115
116     return null;
117   }
118
119
120
121   public JavaSmartCompletionContributor() {
122     extend(CompletionType.SMART, SmartCastProvider.INSIDE_TYPECAST_TYPE, new SmartCastProvider());
123
124     extend(CompletionType.SMART,
125            psiElement().beforeLeaf(psiElement(JavaTokenType.RPARENTH)).afterLeaf("(").withParent(
126              psiElement(PsiReferenceExpression.class).withParent(
127                psiElement(PsiExpressionList.class).withParent(PsiMethodCallExpression.class))), new SameSignatureCallParametersProvider());
128
129     extend(CompletionType.SMART, psiElement().afterLeaf(PsiKeyword.INSTANCEOF), new CompletionProvider<CompletionParameters>(false) {
130       protected void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result) {
131         final PsiElement position = parameters.getPosition();
132         final PsiType[] leftTypes = ApplicationManager.getApplication().runReadAction(new Computable<PsiType[]>() {
133           public PsiType[] compute() {
134             return InstanceOfLeftPartTypeGetter.getLeftTypes(position);
135           }
136         });
137         final Set<PsiClassType> expectedClassTypes = new LinkedHashSet<PsiClassType>();
138         final Set<PsiClass> parameterizedTypes = new THashSet<PsiClass>();
139         for (final PsiType type : leftTypes) {
140           if (type instanceof PsiClassType) {
141             final PsiClassType classType = (PsiClassType)type;
142             if (!classType.isRaw()) {
143               ContainerUtil.addIfNotNull(classType.resolve(), parameterizedTypes);
144             }
145
146             expectedClassTypes.add(classType.rawType());
147           }
148         }
149
150         processInheritors(parameters, position, position.getContainingFile(), expectedClassTypes, new Consumer<PsiType>() {
151           public void consume(PsiType type) {
152             final PsiClass psiClass = PsiUtil.resolveClassInType(type);
153             if (psiClass == null) return;
154
155             if (expectedClassTypes.contains(type)) return;
156
157             result.addElement(createInstanceofLookupElement(psiClass, parameterizedTypes));
158           }
159         }, result.getPrefixMatcher());
160       }
161     });
162
163     extend(CompletionType.SMART, psiElement(), new CompletionProvider<CompletionParameters>() {
164       protected void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result) {
165         final PsiElement element = parameters.getPosition();
166         final PsiReference reference = element.getContainingFile().findReferenceAt(parameters.getOffset());
167         if (reference != null) {
168           final ElementFilter filter = getReferenceFilter(element);
169           if (filter != null) {
170             final List<ExpectedTypeInfo> infos = Arrays.asList(getExpectedTypes(parameters));
171             for (final LookupElement item : completeReference(element, reference, filter, true, parameters)) {
172               if (item.getObject() instanceof PsiClass) {
173                 result.addElement(decorate(LookupElementDecorator.withInsertHandler((LookupItem)item, ConstructorInsertHandler.INSTANCE), infos));
174               }
175             }
176           }
177           else if (INSIDE_TYPECAST_EXPRESSION.accepts(element)) {
178             for (final LookupElement item : completeReference(element, reference, new GeneratorFilter(AssignableToFilter.class, new CastTypeGetter()), false, parameters)) {
179               result.addElement(item);
180             }
181           }
182
183         }
184       }
185     });
186
187     //method throws clause
188     extend(CompletionType.SMART, psiElement().inside(
189       psiElement(PsiReferenceList.class).save("refList").withParent(
190         psiMethod().withThrowsList(get("refList")))), new CompletionProvider<CompletionParameters>() {
191       @Override
192       protected void addCompletions(@NotNull CompletionParameters parameters,
193                                     ProcessingContext context,
194                                     @NotNull CompletionResultSet result) {
195         final PsiElement element = parameters.getPosition();
196         final PsiReference reference = element.getContainingFile().findReferenceAt(parameters.getOffset());
197         assert reference != null;
198         for (final LookupElement item : completeReference(element, reference, THROWABLES_FILTER, true, parameters)) {
199           result.addElement(item);
200         }
201       }
202     });
203
204     extend(CompletionType.SMART, INSIDE_EXPRESSION, new ExpectedTypeBasedCompletionProvider() {
205       protected void addCompletions(final CompletionParameters params, final CompletionResultSet result, final Collection<ExpectedTypeInfo> _infos) {
206         final Set<ExpectedTypeInfo> infos = ApplicationManager.getApplication().runReadAction(new Computable<Set<ExpectedTypeInfo>>() {
207           public Set<ExpectedTypeInfo> compute() {
208             return new THashSet<ExpectedTypeInfo>(_infos, EXPECTED_TYPE_INFO_STRATEGY);
209           }
210         });
211         for (final ExpectedTypeInfo info : infos) {
212           final JavaSmartCompletionParameters parameters = new JavaSmartCompletionParameters(params, info);
213           final PsiType type = info.getType();
214
215           final CompletionService service = CompletionService.getCompletionService();
216           new BasicExpressionCompletionContributor().fillCompletionVariants(parameters, service.createResultSet(parameters, new Consumer<LookupElement>() {
217             public void consume(final LookupElement lookupElement) {
218               final TypedLookupItem typed = JavaCompletionUtil.typedFrom(lookupElement);
219               if (typed != null) {
220                 final PsiType psiType = typed.getType();
221                 if (psiType != null && type.isAssignableFrom(psiType)) {
222                   result.addElement(decorate(lookupElement, _infos));
223                 }
224               }
225             }
226           }, JavaSmartCompletionContributor.this));
227           ReferenceExpressionCompletionContributor.fillCompletionVariants(parameters, service.createResultSet(parameters, new Consumer<LookupElement>() {
228             public void consume(final LookupElement lookupElement) {
229               result.addElement(decorate(lookupElement, _infos));
230             }
231           }, JavaSmartCompletionContributor.this));
232
233         }
234       }
235     });
236
237     extend(CompletionType.SMART, or(
238         PsiJavaPatterns.psiElement().withParent(PsiNameValuePair.class),
239         PsiJavaPatterns.psiElement().withSuperParent(2, PsiNameValuePair.class)), new CompletionProvider<CompletionParameters>() {
240       public void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result) {
241         final PsiElement element = parameters.getPosition();
242         final ElementPattern<? extends PsiElement> leftNeighbor = PsiJavaPatterns.psiElement().afterLeaf(PsiJavaPatterns.psiElement().withText("."));
243         final boolean needQualify = leftNeighbor.accepts(element);
244
245         for (final PsiType type : ExpectedTypesGetter.getExpectedTypes(element, false)) {
246           final PsiClass psiClass = PsiUtil.resolveClassInType(type);
247           if (psiClass != null && psiClass.isAnnotationType()) {
248             final LookupItem item = new JavaPsiClassReferenceElement(psiClass).setTailType(TailType.NONE);
249             if (needQualify) JavaCompletionUtil.qualify(item);
250             result.addElement(item);
251           }
252         }
253
254       }
255     });
256
257     extend(CompletionType.SMART, psiElement().inside(
258         psiElement(PsiDocTag.class).withName(
259             string().oneOf(PsiKeyword.THROWS, EXCEPTION_TAG))), new CompletionProvider<CompletionParameters>() {
260       public void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result) {
261         final PsiElement element = parameters.getPosition();
262         final Set<PsiClass> throwsSet = new HashSet<PsiClass>();
263         final PsiMethod method = PsiTreeUtil.getContextOfType(element, PsiMethod.class, true);
264         if(method != null){
265           for (PsiClassType ref : method.getThrowsList().getReferencedTypes()) {
266             final PsiClass exception = ref.resolve();
267             if (exception != null && throwsSet.add(exception)) {
268               result.addElement(TailTypeDecorator.withTail(new JavaPsiClassReferenceElement(exception).setInsertHandler(new DefaultInsertHandler()), TailType.SPACE));
269             }
270           }
271         }
272
273       }
274     });
275
276     final Key<PsiTryStatement> tryKey = Key.create("try");
277     extend(CompletionType.SMART, psiElement().afterLeaf(
278         psiElement().withText("("))
279         .withSuperParent(3, psiElement(PsiCatchSection.class).withParent(
280         psiElement(PsiTryStatement.class).save(tryKey))), new CompletionProvider<CompletionParameters>() {
281       protected void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result) {
282         final PsiCodeBlock tryBlock = context.get(tryKey).getTryBlock();
283         if (tryBlock == null) return;
284
285         for (final PsiClassType type : ExceptionUtil.getThrownExceptions(tryBlock.getStatements())) {
286           result.addElement(TailTypeDecorator.withTail(PsiTypeLookupItem.createLookupItem(type, tryBlock).setInsertHandler(new DefaultInsertHandler()), TailType.SPACE));
287         }
288       }
289     });
290
291     extend(CompletionType.SMART, psiElement().inside(psiElement(PsiReferenceParameterList.class)),
292            new CompletionProvider<CompletionParameters>() {
293
294              protected void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext processingContext, @NotNull final CompletionResultSet resultSet) {
295                final PsiElement context = parameters.getPosition();
296
297                final Pair<PsiClass, Integer> pair = getTypeParameterInfo(context);
298                if (pair == null) return;
299
300                final PsiClass referencedClass = pair.first;
301                final int parameterIndex = pair.second.intValue();
302                final PsiTypeParameter[] typeParameters = referencedClass.getTypeParameters();
303                final PsiTypeParameter targetParameter = typeParameters[parameterIndex];
304
305                boolean isLast = parameterIndex == typeParameters.length - 1;
306                final TailType tail = isLast ? new CharTailType('>') : TailType.COMMA;
307
308                boolean hasExpected = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
309                  public Boolean compute() {
310                    PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(context.getProject()).getResolveHelper();
311                    final PsiType[] psiTypes = ExpectedTypesGetter.getExpectedTypes(context, false);
312                    if (psiTypes.length == 0) return false;
313
314                    for (PsiType type : psiTypes) {
315                      if (!(type instanceof PsiClassType)) continue;
316                      final PsiClassType.ClassResolveResult result = ((PsiClassType)type).resolveGenerics();
317                      final PsiClass typeClass = result.getElement();
318                      final PsiSubstitutor substitutor = result.getSubstitutor();
319
320                      if (!InheritanceUtil.isInheritorOrSelf(referencedClass, typeClass, true)) continue;
321
322                      final PsiSubstitutor currentSubstitutor =
323                          TypeConversionUtil.getClassSubstitutor(typeClass, referencedClass, PsiSubstitutor.EMPTY);
324                      for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(typeClass)) {
325                        final PsiType argSubstitution = substitutor.substitute(parameter);
326                        final PsiType paramSubstitution = currentSubstitutor.substitute(parameter);
327                        final PsiType substitution = resolveHelper
328                            .getSubstitutionForTypeParameter(targetParameter, paramSubstitution, argSubstitution, false,
329                                                             PsiUtil.getLanguageLevel(context));
330                        if (substitution != null && substitution != PsiType.NULL) {
331                          final LookupItem item = PsiTypeLookupItem.createLookupItem(substitution, context);
332                          resultSet.addElement(TailTypeDecorator.withTail(item.setInsertHandler(new DefaultInsertHandler()), tail));
333                        }
334                      }
335                    }
336                    return true;
337                  }
338                }).booleanValue();
339
340
341                if (!hasExpected) {
342                  final List<PsiClassType> typeList = Collections.singletonList((PsiClassType)TypeConversionUtil.typeParameterErasure(targetParameter));
343                  processInheritors(parameters, context, parameters.getOriginalFile(), typeList, new Consumer<PsiType>() {
344                    public void consume(final PsiType type) {
345                      final PsiClass psiClass = PsiUtil.resolveClassInType(type);
346                      if (psiClass == null) return;
347
348                      resultSet.addElement(TailTypeDecorator.withTail(new JavaPsiClassReferenceElement(psiClass).setInsertHandler(new DefaultInsertHandler()), tail));
349                    }
350                  }, resultSet.getPrefixMatcher());
351
352                }
353              }
354            });
355
356
357     extend(CompletionType.SMART, AFTER_NEW, new CompletionProvider<CompletionParameters>(false) {
358       public void addCompletions(@NotNull final CompletionParameters parameters, final ProcessingContext matchingContext, @NotNull final CompletionResultSet result) {
359         final PsiElement identifierCopy = parameters.getPosition();
360         final PsiFile file = parameters.getOriginalFile();
361
362         final List<PsiClassType> expectedClassTypes = new SmartList<PsiClassType>();
363         final List<PsiArrayType> expectedArrayTypes = new SmartList<PsiArrayType>();
364         final List<ExpectedTypeInfo> infos = new SmartList<ExpectedTypeInfo>();
365
366         ApplicationManager.getApplication().runReadAction(new Runnable() {
367           public void run() {
368             ContainerUtil.addAll(infos, getExpectedTypes(parameters));
369             for (PsiType type : ExpectedTypesGetter.getExpectedTypes(identifierCopy, true)) {
370               if (type instanceof PsiClassType) {
371                 final PsiClassType classType = (PsiClassType)type;
372                 if (classType.resolve() != null) {
373                   expectedClassTypes.add(classType);
374                 }
375               }
376               else if (type instanceof PsiArrayType) {
377                 expectedArrayTypes.add((PsiArrayType)type);
378               }
379             }
380           }
381         });
382
383
384         for (final PsiArrayType type : expectedArrayTypes) {
385           ApplicationManager.getApplication().runReadAction(new Runnable() {
386             public void run() {
387               final LookupItem item = PsiTypeLookupItem.createLookupItem(JavaCompletionUtil.eliminateWildcards(type), identifierCopy);
388               if (item.getObject() instanceof PsiClass) {
389                 JavaCompletionUtil.setShowFQN(item);
390               }
391               item.setInsertHandler(new DefaultInsertHandler()); //braces & shortening
392               result.addElement(decorate(item, infos));
393             }
394           });
395         }
396         
397         processInheritors(parameters, identifierCopy, file, expectedClassTypes, new Consumer<PsiType>() {
398           public void consume(final PsiType type) {
399             addExpectedType(result, type, parameters, infos);
400           }
401         }, result.getPrefixMatcher());
402       }
403     });
404   }
405
406   public static SmartCompletionDecorator decorate(LookupElement lookupElement, Collection<ExpectedTypeInfo> infos) {
407     if (lookupElement instanceof LookupItem) {
408       final LookupItem lookupItem = (LookupItem)lookupElement;
409       if (lookupItem.getInsertHandler() == null) {
410         lookupItem.setInsertHandler(DefaultInsertHandler.NO_TAIL_HANDLER);
411       }
412     }
413
414     return new SmartCompletionDecorator(lookupElement, infos);
415   }
416
417   private static LookupElement createInstanceofLookupElement(PsiClass psiClass, Set<PsiClass> toWildcardInheritors) {
418     final PsiTypeParameter[] typeParameters = psiClass.getTypeParameters();
419     if (typeParameters.length > 0) {
420       for (final PsiClass parameterizedType : toWildcardInheritors) {
421         if (psiClass.isInheritor(parameterizedType, true)) {
422           PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
423           final PsiWildcardType wildcard = PsiWildcardType.createUnbounded(psiClass.getManager());
424           for (final PsiTypeParameter typeParameter : typeParameters) {
425             substitutor = substitutor.put(typeParameter, wildcard);
426           }
427           final PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject());
428           return PsiTypeLookupItem.createLookupItem(factory.createType(psiClass, substitutor), psiClass);
429         }
430       }
431     }
432
433
434     return new JavaPsiClassReferenceElement(psiClass);
435   }
436
437   @Nullable
438   public static Pair<PsiClass, Integer> getTypeParameterInfo(PsiElement context) {
439     final PsiReferenceParameterList parameterList = PsiTreeUtil.getContextOfType(context, PsiReferenceParameterList.class, true);
440     if (parameterList == null) return null;
441
442     final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)parameterList.getParent();
443     final int parameterIndex;
444
445     int index = 0;
446     final PsiTypeElement typeElement = PsiTreeUtil.getContextOfType(context, PsiTypeElement.class, true);
447     if(typeElement != null){
448       final PsiTypeElement[] elements = referenceElement.getParameterList().getTypeParameterElements();
449       while (index < elements.length) {
450         final PsiTypeElement element = elements[index++];
451         if(element == typeElement) break;
452       }
453     }
454     parameterIndex = index - 1;
455
456     if(parameterIndex < 0) return null;
457     final PsiElement target = referenceElement.resolve();
458     if(!(target instanceof PsiClass)) return null;
459
460     final PsiClass referencedClass = (PsiClass)target;
461     final PsiTypeParameter[] typeParameters = referencedClass.getTypeParameters();
462     if(typeParameters.length <= parameterIndex) return null;
463
464     return Pair.create(referencedClass, parameterIndex);
465   }
466
467
468   public static void processInheritors(final CompletionParameters parameters, final PsiElement identifierCopy, final PsiFile file, final Collection<PsiClassType> expectedClassTypes,
469                                         final Consumer<PsiType> consumer, final PrefixMatcher matcher) {
470     //quick
471     for (final PsiClassType type : expectedClassTypes) {
472       ApplicationManager.getApplication().runReadAction(new Runnable() {
473         public void run() {
474           consumer.consume(type);
475
476           final PsiClassType.ClassResolveResult baseResult = JavaCompletionUtil.originalize(type).resolveGenerics();
477           final PsiClass baseClass = baseResult.getElement();
478           if (baseClass == null) return;
479
480           final PsiSubstitutor baseSubstitutor = baseResult.getSubstitutor();
481
482           final THashSet<PsiType> statVariants = new THashSet<PsiType>();
483           final Processor<PsiClass> processor = CodeInsightUtil
484               .createInheritorsProcessor(parameters.getPosition(), type, 0, false, statVariants, baseClass, baseSubstitutor);
485           final StatisticsInfo[] statisticsInfos =
486               StatisticsManager.getInstance().getAllValues(JavaStatisticsManager.getAfterNewKey(type));
487           for (final StatisticsInfo statisticsInfo : statisticsInfos) {
488             final String value = statisticsInfo.getValue();
489             if (value.startsWith(JavaStatisticsManager.CLASS_PREFIX)) {
490               final String qname = value.substring(JavaStatisticsManager.CLASS_PREFIX.length());
491               final PsiClass psiClass = JavaPsiFacade.getInstance(file.getProject()).findClass(qname, file.getResolveScope());
492               if (psiClass != null && !PsiTreeUtil.isAncestor(file, psiClass, true) && !processor.process(psiClass)) break;
493             }
494           }
495
496           for (final PsiType variant : statVariants) {
497             consumer.consume(variant);
498           }
499         }
500       });
501     }
502
503     //long
504     final Condition<String> shortNameCondition = new Condition<String>() {
505       public boolean value(String s) {
506         return matcher.prefixMatches(s);
507       }
508     };
509     for (final PsiClassType type : expectedClassTypes) {
510       final boolean shouldSearchForInheritors = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
511         public Boolean compute() {
512           final PsiClass psiClass = type.resolve();
513           return psiClass != null && psiClass.isValid() && !psiClass.hasModifierProperty(PsiModifier.FINAL);
514         }
515       }).booleanValue();
516       if (shouldSearchForInheritors) {
517         final Set<PsiType> psiTypes = CodeInsightUtil.addSubtypes(type, identifierCopy, false, shortNameCondition);
518         for (final PsiType psiType : psiTypes) {
519           ApplicationManager.getApplication().runReadAction(new Runnable() {
520             public void run() {
521               if (psiType.isValid()) {
522                 consumer.consume(psiType);
523               }
524             }
525           });
526         }
527       }
528     }
529   }
530
531   public static ExpectedTypeInfo[] getExpectedTypes(final CompletionParameters parameters) {
532     final PsiElement position = parameters.getPosition();
533     if (psiElement().withParent(psiElement(PsiReferenceExpression.class).withParent(PsiThrowStatement.class)).accepts(position)) {
534       final PsiElementFactory factory = JavaPsiFacade.getInstance(position.getProject()).getElementFactory();
535       final PsiClassType classType = factory
536           .createTypeByFQClassName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, position.getResolveScope());
537       final List<ExpectedTypeInfo> result = new SmartList<ExpectedTypeInfo>();
538       result.add(new ExpectedTypeInfoImpl(classType, ExpectedTypeInfo.TYPE_OR_SUBTYPE, 0, classType, TailType.SEMICOLON));
539       final PsiMethod method = PsiTreeUtil.getContextOfType(position, PsiMethod.class, true);
540       if (method != null) {
541         for (final PsiClassType type : method.getThrowsList().getReferencedTypes()) {
542           result.add(new ExpectedTypeInfoImpl(type, ExpectedTypeInfo.TYPE_OR_SUBTYPE, 0, type, TailType.SEMICOLON));
543         }
544       }
545       return result.toArray(new ExpectedTypeInfo[result.size()]);
546     }
547
548     PsiExpression expression = PsiTreeUtil.getContextOfType(position, PsiExpression.class, true);
549     if (expression == null) return ExpectedTypeInfo.EMPTY_ARRAY;
550
551     return ExpectedTypesProvider.getExpectedTypes(expression, true, parameters.getCompletionType() == CompletionType.SMART, false);
552   }
553
554   private static void addExpectedType(final CompletionResultSet result, final PsiType type, final CompletionParameters parameters, Collection<ExpectedTypeInfo> infos) {
555     if (!JavaCompletionUtil.hasAccessibleConstructor(type)) return;
556
557     final PsiClass psiClass = PsiUtil.resolveClassInType(type);
558     if (psiClass == null) return;
559
560     final PsiClass parentClass = psiClass.getContainingClass();
561     if (parentClass != null && !psiClass.hasModifierProperty(PsiModifier.STATIC) &&
562         !PsiTreeUtil.isAncestor(parentClass, parameters.getPosition(), false) &&
563         !(parentClass.getContainingFile().equals(parameters.getOriginalFile()) &&
564           parentClass.getTextRange().contains(parameters.getOffset()))) {
565       return;
566     }
567
568     final LookupItem item = PsiTypeLookupItem.createLookupItem(JavaCompletionUtil.eliminateWildcards(type), parameters.getPosition());
569     JavaCompletionUtil.setShowFQN(item);
570
571     if (psiClass.isInterface() || psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
572       item.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE);
573       item.setAttribute(LookupItem.INDICATE_ANONYMOUS, "");
574     }
575
576     result.addElement(decorate(type instanceof PsiClassType ? LookupElementDecorator.withInsertHandler(item, ConstructorInsertHandler.INSTANCE) : item, infos));
577   }
578
579   static Set<LookupElement> completeReference(final PsiElement element, PsiReference reference, final ElementFilter filter, final boolean acceptClasses, CompletionParameters parameters) {
580     if (reference instanceof PsiMultiReference) {
581       reference = ContainerUtil.findInstance(((PsiMultiReference) reference).getReferences(), PsiJavaReference.class);
582     }
583
584     if (reference instanceof PsiJavaReference) {
585       final PsiJavaReference javaReference = (PsiJavaReference)reference;
586
587       return JavaCompletionUtil.processJavaReference(element, javaReference, new ElementFilter() {
588         public boolean isAcceptable(Object element, PsiElement context) {
589           return filter.isAcceptable(element, context);
590         }
591
592         public boolean isClassAcceptable(Class hintClass) {
593           if (acceptClasses) {
594             return ReflectionCache.isAssignable(PsiClass.class, hintClass);
595           }
596
597           return ReflectionCache.isAssignable(PsiVariable.class, hintClass) ||
598                  ReflectionCache.isAssignable(PsiMethod.class, hintClass) ||
599                  ReflectionCache.isAssignable(CandidateInfo.class, hintClass);
600         }
601       }, true, null, parameters);
602     }
603
604     return Collections.emptySet();
605   }
606
607   @Override
608   public void beforeCompletion(@NotNull CompletionInitializationContext context) {
609     if (context.getCompletionType() != CompletionType.SMART) {
610       return;
611     }
612
613     if (!context.getEditor().getSelectionModel().hasSelection()) {
614       final PsiFile file = context.getFile();
615       PsiElement element = file.findElementAt(context.getStartOffset());
616       if (element instanceof PsiIdentifier) {
617         element = element.getParent();
618         while (element instanceof PsiJavaCodeReferenceElement || element instanceof PsiCall ||
619                element instanceof PsiThisExpression || element instanceof PsiSuperExpression ||
620                element instanceof PsiTypeElement ||
621                element instanceof PsiClassObjectAccessExpression) {
622           int newEnd = element.getTextRange().getEndOffset();
623           if (element instanceof PsiMethodCallExpression) {
624             newEnd = ((PsiMethodCallExpression)element).getMethodExpression().getTextRange().getEndOffset();
625           }
626           else if (element instanceof PsiNewExpression) {
627             final PsiJavaCodeReferenceElement classReference = ((PsiNewExpression)element).getClassReference();
628             if (classReference != null) {
629               newEnd = classReference.getTextRange().getEndOffset();
630             }
631           }
632           context.getOffsetMap().addOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET, newEnd);
633           element = element.getParent();
634         }
635       }
636     }
637
638     PsiElement lastElement = context.getFile().findElementAt(context.getStartOffset() - 1);
639     if (lastElement != null && lastElement.getText().equals("(")) {
640       final PsiElement parent = lastElement.getParent();
641       if (parent instanceof PsiTypeCastExpression) {
642         context.setFileCopyPatcher(new DummyIdentifierPatcher(""));
643         return;
644       }
645       if (parent instanceof PsiParenthesizedExpression) {
646         context.setFileCopyPatcher(new DummyIdentifierPatcher("xxx)yyy ")); // to handle type cast
647         return;
648       }
649     }
650     context.setFileCopyPatcher(new DummyIdentifierPatcher("xxx"));
651   }
652
653 }