MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-18 09:34:34 +07:00
Code Issues Packages Projects Releases Wiki Activity

IDEA-43317 Complete static members from classes that are already mentioned in import block as static import (groovy fields)

Browse Source
This commit is contained in:
peter
2010-09-08 19:06:37 +01:00
parent ccc0d9bba1
commit 6f5c70f254
5 changed files with 117 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java
+4 -3
View File
@@ -884,10 +884,11 @@ public class JavaCompletionUtil {
}
if (javaReference instanceof PsiReferenceExpression && !((PsiReferenceExpression)javaReference).isQualified()) {
JavaGlobalMemberNameCompletionContributor.completeStaticMembers(element).processMembersOfRegisteredClasses(matcher, new Consumer<LookupElement>() {
final StaticMemberProcessor memberProcessor = JavaGlobalMemberNameCompletionContributor.completeStaticMembers(element);
memberProcessor.processMembersOfRegisteredClasses(matcher, new PairConsumer<PsiMember, PsiClass>() {
@Override
public void consume(LookupElement element) {
set.add(element);
public void consume(PsiMember member, PsiClass psiClass) {
set.add(memberProcessor.createLookupElement(member, psiClass, true));
}
});
}
java/java-impl/src/com/intellij/codeInsight/completion/JavaGlobalMemberLookupElement.java
+15 -14
View File
@@ -4,28 +4,27 @@ import com.intellij.codeInsight.lookup.DefaultLookupItemRenderer;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.codeInsight.lookup.LookupElementPresentation;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiSubstitutor;
import com.intellij.psi.PsiType;
import com.intellij.psi.*;
import com.intellij.psi.util.PsiFormatUtil;
import org.jetbrains.annotations.NotNull;
import static com.intellij.util.ObjectUtils.assertNotNull;
/**
* @author peter
*/
public class JavaGlobalMemberLookupElement extends LookupElement implements StaticallyImportable {
private final PsiMethod myMethod;
private final PsiMember myMember;
private final PsiClass myContainingClass;
private final InsertHandler<JavaGlobalMemberLookupElement> myQualifiedInsertion;
private final InsertHandler<JavaGlobalMemberLookupElement> myImportInsertion;
private boolean myShouldImport = false;
public JavaGlobalMemberLookupElement(PsiMethod method,
public JavaGlobalMemberLookupElement(PsiMember member,
PsiClass containingClass,
InsertHandler<JavaGlobalMemberLookupElement> qualifiedInsertion,
InsertHandler<JavaGlobalMemberLookupElement> importInsertion, boolean shouldImport) {
myMethod = method;
myMember = member;
myContainingClass = containingClass;
myQualifiedInsertion = qualifiedInsertion;
myImportInsertion = importInsertion;
@@ -34,8 +33,8 @@ public class JavaGlobalMemberLookupElement extends LookupElement implements Stat
@NotNull
@Override
public PsiMethod getObject() {
return myMethod;
public PsiMember getObject() {
return myMember;
}
@NotNull
@@ -46,7 +45,7 @@ public class JavaGlobalMemberLookupElement extends LookupElement implements Stat
@NotNull
@Override
public String getLookupString() {
return myMethod.getName();
return assertNotNull(myMember.getName());
}
@Override
@@ -55,23 +54,25 @@ public class JavaGlobalMemberLookupElement extends LookupElement implements Stat
presentation.setIcon(DefaultLookupItemRenderer.getRawIcon(this, presentation.isReal()));
final String methodName = myMethod.getName();
final String methodName = myMember.getName();
if (Boolean.FALSE.equals(myShouldImport) && StringUtil.isNotEmpty(className)) {
presentation.setItemText(className + "." + methodName);
} else {
presentation.setItemText(methodName);
}
final String params = PsiFormatUtil.formatMethod(myMethod, PsiSubstitutor.EMPTY,
final String params = myMember instanceof PsiMethod
? PsiFormatUtil.formatMethod((PsiMethod)myMember, PsiSubstitutor.EMPTY,
PsiFormatUtil.SHOW_PARAMETERS,
PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE);
PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE)
: "";
if (Boolean.TRUE.equals(myShouldImport) && StringUtil.isNotEmpty(className)) {
presentation.setTailText(params + " in " + className);
} else {
presentation.setTailText(params);
}
final PsiType type = myMethod.getReturnType();
final PsiType type = myMember instanceof PsiMethod ? ((PsiMethod)myMember).getReturnType() : ((PsiField) myMember).getType();
if (type != null) {
presentation.setTypeText(type.getPresentableText());
}
java/java-impl/src/com/intellij/codeInsight/completion/StaticMemberProcessor.java
+38 -40
View File
@@ -10,9 +10,13 @@ import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.PsiShortNamesCache;
import com.intellij.util.Consumer;
import com.intellij.util.PairConsumer;
import com.intellij.util.containers.CollectionFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import static com.intellij.util.containers.CollectionFactory.hashSet;
@@ -64,7 +68,24 @@ public abstract class StaticMemberProcessor {
for (final PsiMethod method : methods) {
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
processMember(method, consumer);
if (isStaticallyImportable(method)) {
final PsiClass containingClass = method.getContainingClass();
assert containingClass != null;
final boolean shouldImport = myStaticImportedClasses.contains(containingClass);
if (!myHintShown &&
!shouldImport &&
FeatureUsageTracker.getInstance().isToBeShown(JavaCompletionFeatures.IMPORT_STATIC, myProject) &&
CompletionService.getCompletionService().getAdvertisementText() == null) {
final String shortcut = CompletionContributor.getActionShortcut("EditorRight");
if (shortcut != null) {
CompletionService.getCompletionService().setAdvertisementText("To import a method statically, press " + shortcut);
}
myHintShown = true;
}
consumer.consume(createLookupElement(method, containingClass, shouldImport));
}
}
});
@@ -73,63 +94,40 @@ public abstract class StaticMemberProcessor {
}
}
public void processMembersOfRegisteredClasses(@Nullable final PrefixMatcher matcher, final Consumer<LookupElement> consumer) {
public List<PsiMember> processMembersOfRegisteredClasses(@Nullable final PrefixMatcher matcher, PairConsumer<PsiMember, PsiClass> consumer) {
final ArrayList<PsiMember> result = CollectionFactory.arrayList();
for (final PsiClass psiClass : myStaticImportedClasses) {
final PsiMethod[] classMethods = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod[]>() {
public PsiMethod[] compute() {
return psiClass.getAllMethods();
}
});
for (final PsiMethod method : classMethods) {
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
if (matcher == null || matcher.prefixMatches(method.getName())) {
processMember(method, consumer);
}
for (final PsiMethod method : psiClass.getAllMethods()) {
if (matcher == null || matcher.prefixMatches(method.getName())) {
if (isStaticallyImportable(method)) {
consumer.consume(method, psiClass);
}
});
}
}
final PsiField[] fields = ApplicationManager.getApplication().runReadAction(new Computable<PsiField[]>() {
public PsiField[] compute() {
return psiClass.getAllFields();
}
});
for (final PsiField field : fields) {
ApplicationManager.getApplication().runReadAction(new Runnable() {
public void run() {
if (matcher == null || matcher.prefixMatches(field.getName())) {
processMember(field, consumer);
}
for (final PsiField field : psiClass.getAllFields()) {
if (matcher == null || matcher.prefixMatches(field.getName())) {
if (isStaticallyImportable(field)) {
consumer.consume(field, psiClass);
}
});
}
}
}
return result;
}
private void processMember(final PsiMember member, final Consumer<LookupElement> consumer) {
private boolean isStaticallyImportable(final PsiMember member) {
if (member.hasModifierProperty(PsiModifier.STATIC) && myResolveHelper.isAccessible(member, myPosition, null)) {
final PsiClass containingClass = member.getContainingClass();
if (containingClass != null) {
if (!JavaCompletionUtil.isInExcludedPackage(containingClass) &&
(!(member instanceof PsiMethod) || !StaticImportMethodFix.isExcluded((PsiMethod)member))) {
final boolean shouldImport = myStaticImportedClasses.contains(containingClass);
if (!myHintShown &&
!shouldImport &&
FeatureUsageTracker.getInstance().isToBeShown(JavaCompletionFeatures.IMPORT_STATIC, myProject) &&
CompletionService.getCompletionService().getAdvertisementText() == null) {
final String shortcut = CompletionContributor.getActionShortcut("EditorRight");
if (shortcut != null) {
CompletionService.getCompletionService().setAdvertisementText("To import a method statically, press " + shortcut);
}
myHintShown = true;
}
consumer.consume(createLookupElement(member, containingClass, shouldImport));
return true;
}
}
}
return false;
}
@NotNull