java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.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.lookup.*;
  19 import com.intellij.featureStatistics.FeatureUsageTracker;
  20 import com.intellij.openapi.editor.Document;
  21 import com.intellij.psi.*;
  22 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
  23 import com.intellij.psi.util.PsiTreeUtil;
  24 import gnu.trove.THashSet;
  25 import org.jetbrains.annotations.NotNull;
  26
  27 import java.util.Set;
  28
  29 /**
  30  * @author peter
  31  */
  32 public class JavaChainLookupElement extends LookupElementDecorator<LookupElement> implements TypedLookupItem {
  33   private final LookupElement myQualifier;
  34
  35   private JavaChainLookupElement(LookupElement qualifier, LookupElement main) {
  36     super(main);
  37     myQualifier = qualifier;
  38   }
  39
  40   @NotNull
  41   @Override
  42   public String getLookupString() {
  43     return maybeAddParentheses(myQualifier.getLookupString()) + "." + getDelegate().getLookupString();
  44   }
  45
  46   public LookupElement getQualifier() {
  47     return myQualifier;
  48   }
  49
  50   @Override
  51   public Set<String> getAllLookupStrings() {
  52     final Set<String> strings = getDelegate().getAllLookupStrings();
  53     final THashSet<String> result = new THashSet<String>();
  54     result.addAll(strings);
  55     result.add(getLookupString());
  56     return result;
  57   }
  58
  59   @NotNull
  60   @Override
  61   public String toString() {
  62     return maybeAddParentheses(myQualifier.toString()) + "." + getDelegate();
  63   }
  64
  65   private String maybeAddParentheses(String s) {
  66     return myQualifier.getObject() instanceof PsiMethod ? s + "()" : s;
  67   }
  68
  69   @Override
  70   public void renderElement(LookupElementPresentation presentation) {
  71     super.renderElement(presentation);
  72     final LookupElementPresentation qualifierPresentation = new LookupElementPresentation(presentation.isReal());
  73     myQualifier.renderElement(qualifierPresentation);
  74     String name = maybeAddParentheses(qualifierPresentation.getItemText());
  75     final String qualifierText = myQualifier.as(CastingLookupElementDecorator.class) != null ? "(" + name + ")" : name;
  76     presentation.setItemText(qualifierText + "." + presentation.getItemText());
  77   }
  78
  79   @Override
  80   public void handleInsert(InsertionContext context) {
  81     FeatureUsageTracker.getInstance().triggerFeatureUsed(JavaCompletionFeatures.SECOND_SMART_COMPLETION_CHAIN);
  82
  83     final Document document = context.getEditor().getDocument();
  84     document.replaceString(context.getStartOffset(), context.getTailOffset(), ";");
  85     final InsertionContext qualifierContext = CompletionUtil.emulateInsertion(context, context.getStartOffset(), myQualifier, (char)0);
  86
  87     if (shouldParenthesizeQualifier(qualifierContext.getFile(), context.getStartOffset(), qualifierContext.getTailOffset())) {
  88       final String space = CodeStyleSettingsManager.getSettings(qualifierContext.getProject()).SPACE_WITHIN_PARENTHESES ? " " : "";
  89       document.insertString(context.getStartOffset(), "(" + space);
  90       document.insertString(qualifierContext.getTailOffset(), space + ")");
  91     }
  92
  93     final char atTail = document.getCharsSequence().charAt(context.getTailOffset() - 1);
  94     assert atTail == ';' : atTail;
  95     document.replaceString(context.getTailOffset() - 1, context.getTailOffset(), ".");
  96
  97     CompletionUtil.emulateInsertion(getDelegate(), context.getTailOffset(), context);
  98   }
  99
 100   private static boolean shouldParenthesizeQualifier(final PsiFile file, final int startOffset, final int endOffset) {
 101     PsiElement element = file.findElementAt(startOffset);
 102     if (element == null) {
 103       return false;
 104     }
 105
 106     PsiElement last = element;
 107     while (element != null && element.getTextRange().getStartOffset() >= startOffset && element.getTextRange().getEndOffset() <= endOffset) {
 108       last = element;
 109       element = element.getParent();
 110     }
 111     PsiExpression expr = PsiTreeUtil.getParentOfType(last, PsiExpression.class, false);
 112     if (expr == null || expr.getTextRange().getEndOffset() > endOffset) {
 113       return true;
 114     }
 115
 116     if (expr instanceof PsiReferenceExpression || expr instanceof PsiMethodCallExpression) {
 117       return false;
 118     }
 119
 120     return true;
 121   }
 122
 123   @NotNull
 124   private LookupElement getComparableQualifier() {
 125     final CastingLookupElementDecorator casting = myQualifier.as(CastingLookupElementDecorator.class);
 126     return casting == null ? myQualifier : casting.getDelegate();
 127   }
 128
 129   @Override
 130   public boolean equals(Object o) {
 131     if (this == o) return true;
 132     if (o == null || getClass() != o.getClass()) return false;
 133     if (!super.equals(o)) return false;
 134
 135     return getComparableQualifier().equals(((JavaChainLookupElement)o).getComparableQualifier());
 136   }
 137
 138   @Override
 139   public int hashCode() {
 140     return 31 * super.hashCode() + getComparableQualifier().hashCode();
 141   }
 142
 143   public PsiType getType() {
 144     final Object object = getObject();
 145     if (object instanceof PsiMember) {
 146       return JavaCompletionUtil.getQualifiedMemberReferenceType(JavaCompletionUtil.getLookupElementType(myQualifier), (PsiMember)object);
 147     }
 148     return ((PsiVariable) object).getType();
 149   }
 150
 151   public static LookupElement chainElements(LookupElement qualifier, LookupElement main) {
 152     return new JavaChainLookupElement(qualifier, main);
 153   }
 154 }