1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Copyright 2000-2009 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Created by IntelliJ IDEA.
* User: mike
* Date: Aug 20, 2002
* Time: 8:49:24 PM
* To change template for new class use
* Code Style | Class Templates options (Tools | IDE Options).
*/
package com.intellij.codeInsight.daemon.impl.quickfix;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.util.ClassUtil;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class ImportClassFix extends ImportClassFixBase<PsiJavaCodeReferenceElement, PsiJavaCodeReferenceElement> {
public ImportClassFix(@NotNull PsiJavaCodeReferenceElement element) {
super(element, element);
}
@Override
protected String getReferenceName(@NotNull PsiJavaCodeReferenceElement reference) {
return reference.getReferenceName();
}
@Override
protected PsiElement getReferenceNameElement(@NotNull PsiJavaCodeReferenceElement reference) {
return reference.getReferenceNameElement();
}
@Override
protected void bindReference(PsiReference ref, PsiClass targetClass) {
if (ref instanceof PsiImportStaticReferenceElement) {
((PsiImportStaticReferenceElement)ref).bindToTargetClass(targetClass);
}
else {
super.bindReference(ref, targetClass);
}
}
@Override
protected boolean hasTypeParameters(@NotNull PsiJavaCodeReferenceElement reference) {
final PsiReferenceParameterList refParameters = reference.getParameterList();
return refParameters != null && refParameters.getTypeParameterElements().length > 0;
}
@Override
protected String getQualifiedName(PsiJavaCodeReferenceElement reference) {
return reference.getQualifiedName();
}
@Override
protected boolean isQualified(PsiJavaCodeReferenceElement reference) {
return reference.isQualified();
}
@Override
protected boolean hasUnresolvedImportWhichCanImport(final PsiFile psiFile, final String name) {
if (!(psiFile instanceof PsiJavaFile)) return false;
PsiImportList importList = ((PsiJavaFile)psiFile).getImportList();
if (importList == null) return false;
PsiImportStatement[] importStatements = importList.getImportStatements();
for (PsiImportStatement importStatement : importStatements) {
if (importStatement.resolve() != null) continue;
if (importStatement.isOnDemand()) return true;
String qualifiedName = importStatement.getQualifiedName();
String className = qualifiedName == null ? null : ClassUtil.extractClassName(qualifiedName);
if (Comparing.strEqual(className, name)) return true;
}
PsiImportStaticStatement[] importStaticStatements = importList.getImportStaticStatements();
for (PsiImportStaticStatement importStaticStatement : importStaticStatements) {
if (importStaticStatement.resolve() != null) continue;
if (importStaticStatement.isOnDemand()) return true;
String qualifiedName = importStaticStatement.getReferenceName();
// rough heuristic, since there is no API to get class name reference from static import
if (qualifiedName != null && StringUtil.split(qualifiedName, ".").contains(name)) return true;
}
return false;
}
@Override
protected String getRequiredMemberName(PsiJavaCodeReferenceElement reference) {
PsiElement parent = reference.getParent();
if (parent instanceof PsiJavaCodeReferenceElement) {
return ((PsiJavaCodeReferenceElement)parent).getReferenceName();
}
return super.getRequiredMemberName(reference);
}
@NotNull
@Override
protected List<PsiClass> filterByContext(@NotNull List<PsiClass> candidates, @NotNull PsiJavaCodeReferenceElement ref) {
PsiElement typeElement = ref.getParent();
if (typeElement instanceof PsiTypeElement) {
PsiElement var = typeElement.getParent();
if (var instanceof PsiVariable) {
PsiExpression initializer = ((PsiVariable)var).getInitializer();
if (initializer != null) {
return filterAssignableFrom(initializer.getType(), candidates);
}
}
if (var instanceof PsiParameter) {
return filterBySuperMethods((PsiParameter)var, candidates);
}
}
return super.filterByContext(candidates, ref);
}
@Override
protected boolean isAccessible(PsiMember member, PsiJavaCodeReferenceElement reference) {
return member.hasModifierProperty(PsiModifier.PUBLIC) || member.hasModifierProperty(PsiModifier.PROTECTED);
}
}
|
