001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.asJava;
018
019 import com.google.common.base.Function;
020 import com.google.common.collect.Collections2;
021 import com.google.common.collect.Sets;
022 import com.intellij.openapi.extensions.Extensions;
023 import com.intellij.openapi.project.Project;
024 import com.intellij.openapi.util.Condition;
025 import com.intellij.openapi.vfs.VirtualFile;
026 import com.intellij.psi.*;
027 import com.intellij.psi.search.GlobalSearchScope;
028 import com.intellij.psi.util.PsiUtilCore;
029 import com.intellij.util.SmartList;
030 import com.intellij.util.containers.ContainerUtil;
031 import org.jetbrains.annotations.NotNull;
032 import org.jetbrains.annotations.Nullable;
033 import org.jetbrains.kotlin.load.java.JvmAbi;
034 import org.jetbrains.kotlin.name.FqName;
035 import org.jetbrains.kotlin.name.FqNamesUtilKt;
036 import org.jetbrains.kotlin.psi.KtClass;
037 import org.jetbrains.kotlin.psi.KtClassOrObject;
038 import org.jetbrains.kotlin.psi.KtEnumEntry;
039 import org.jetbrains.kotlin.psi.KtFile;
040 import org.jetbrains.kotlin.resolve.jvm.KotlinFinderMarker;
041
042 import java.util.Collection;
043 import java.util.Comparator;
044 import java.util.List;
045 import java.util.Set;
046
047 import static org.jetbrains.kotlin.asJava.LightClassUtilsKt.toLightClass;
048
049 public class JavaElementFinder extends PsiElementFinder implements KotlinFinderMarker {
050
051 @NotNull
052 public static JavaElementFinder getInstance(@NotNull Project project) {
053 PsiElementFinder[] extensions = Extensions.getArea(project).getExtensionPoint(PsiElementFinder.EP_NAME).getExtensions();
054 for (PsiElementFinder extension : extensions) {
055 if (extension instanceof JavaElementFinder) {
056 return (JavaElementFinder) extension;
057 }
058 }
059 throw new IllegalStateException(JavaElementFinder.class.getSimpleName() + " is not found for project " + project);
060 }
061
062 private final Project project;
063 private final PsiManager psiManager;
064 private final LightClassGenerationSupport lightClassGenerationSupport;
065
066 public JavaElementFinder(
067 @NotNull Project project,
068 @NotNull LightClassGenerationSupport lightClassGenerationSupport
069 ) {
070 this.project = project;
071 this.psiManager = PsiManager.getInstance(project);
072 this.lightClassGenerationSupport = lightClassGenerationSupport;
073 }
074
075 @Override
076 public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) {
077 PsiClass[] allClasses = findClasses(qualifiedName, scope);
078 return allClasses.length > 0 ? allClasses[0] : null;
079 }
080
081 @NotNull
082 @Override
083 public PsiClass[] findClasses(@NotNull String qualifiedNameString, @NotNull GlobalSearchScope scope) {
084 if (!FqNamesUtilKt.isValidJavaFqName(qualifiedNameString)) {
085 return PsiClass.EMPTY_ARRAY;
086 }
087
088 List<PsiClass> answer = new SmartList<PsiClass>();
089
090 FqName qualifiedName = new FqName(qualifiedNameString);
091
092 findClassesAndObjects(qualifiedName, scope, answer);
093
094 answer.addAll(lightClassGenerationSupport.getFacadeClasses(qualifiedName, scope));
095 answer.addAll(lightClassGenerationSupport.getMultifilePartClasses(qualifiedName, scope));
096
097 return sortByClasspath(answer, scope).toArray(new PsiClass[answer.size()]);
098 }
099
100 // Finds explicitly declared classes and objects, not package classes
101 // Also DefaultImpls classes of interfaces
102 private void findClassesAndObjects(FqName qualifiedName, GlobalSearchScope scope, List<PsiClass> answer) {
103 findInterfaceDefaultImpls(qualifiedName, scope, answer);
104
105 Collection<KtClassOrObject> classOrObjectDeclarations =
106 lightClassGenerationSupport.findClassOrObjectDeclarations(qualifiedName, scope);
107
108 for (KtClassOrObject declaration : classOrObjectDeclarations) {
109 if (!(declaration instanceof KtEnumEntry)) {
110 PsiClass lightClass = toLightClass(declaration);
111 if (lightClass != null) {
112 answer.add(lightClass);
113 }
114 }
115 }
116 }
117
118 private void findInterfaceDefaultImpls(FqName qualifiedName, GlobalSearchScope scope, List<PsiClass> answer) {
119 if (qualifiedName.isRoot()) return;
120
121 if (!qualifiedName.shortName().asString().equals(JvmAbi.DEFAULT_IMPLS_CLASS_NAME)) return;
122
123 for (KtClassOrObject classOrObject : lightClassGenerationSupport.findClassOrObjectDeclarations(qualifiedName.parent(), scope)) {
124 //NOTE: can't filter out more interfaces right away because decompiled declarations do not have member bodies
125 if (classOrObject instanceof KtClass && ((KtClass) classOrObject).isInterface()) {
126 PsiClass interfaceClass = toLightClass(classOrObject);
127 if (interfaceClass != null) {
128 PsiClass implsClass = interfaceClass.findInnerClassByName(JvmAbi.DEFAULT_IMPLS_CLASS_NAME, false);
129 if (implsClass != null) {
130 answer.add(implsClass);
131 }
132 }
133 }
134 }
135 }
136
137 @NotNull
138 @Override
139 public Set<String> getClassNames(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
140 FqName packageFQN = new FqName(psiPackage.getQualifiedName());
141
142 Collection<KtClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
143
144 Set<String> answer = Sets.newHashSet();
145 answer.addAll(lightClassGenerationSupport.getFacadeNames(packageFQN, scope));
146
147 for (KtClassOrObject declaration : declarations) {
148 String name = declaration.getName();
149 if (name != null) {
150 answer.add(name);
151 }
152 }
153
154 return answer;
155 }
156
157 @Override
158 public PsiPackage findPackage(@NotNull String qualifiedNameString) {
159 if (!FqNamesUtilKt.isValidJavaFqName(qualifiedNameString)) {
160 return null;
161 }
162
163 FqName fqName = new FqName(qualifiedNameString);
164
165 // allScope() because the contract says that the whole project
166 GlobalSearchScope allScope = GlobalSearchScope.allScope(project);
167 if (lightClassGenerationSupport.packageExists(fqName, allScope)) {
168 return new KtLightPackage(psiManager, fqName, allScope);
169 }
170
171 return null;
172 }
173
174 @NotNull
175 @Override
176 public PsiPackage[] getSubPackages(@NotNull PsiPackage psiPackage, @NotNull final GlobalSearchScope scope) {
177 FqName packageFQN = new FqName(psiPackage.getQualifiedName());
178
179 Collection<FqName> subpackages = lightClassGenerationSupport.getSubPackages(packageFQN, scope);
180
181 Collection<PsiPackage> answer = Collections2.transform(subpackages, new Function<FqName, PsiPackage>() {
182 @Override
183 public PsiPackage apply(@Nullable FqName input) {
184 return new KtLightPackage(psiManager, input, scope);
185 }
186 });
187
188 return answer.toArray(new PsiPackage[answer.size()]);
189 }
190
191 @NotNull
192 @Override
193 public PsiClass[] getClasses(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
194 List<PsiClass> answer = new SmartList<PsiClass>();
195 FqName packageFQN = new FqName(psiPackage.getQualifiedName());
196
197 answer.addAll(lightClassGenerationSupport.getFacadeClassesInPackage(packageFQN, scope));
198
199 Collection<KtClassOrObject> declarations = lightClassGenerationSupport.findClassOrObjectDeclarationsInPackage(packageFQN, scope);
200 for (KtClassOrObject declaration : declarations) {
201 PsiClass aClass = toLightClass(declaration);
202 if (aClass != null) {
203 answer.add(aClass);
204 }
205 }
206
207 return sortByClasspath(answer, scope).toArray(new PsiClass[answer.size()]);
208 }
209
210 @Override
211 @NotNull
212 public PsiFile[] getPackageFiles(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
213 FqName packageFQN = new FqName(psiPackage.getQualifiedName());
214 Collection<KtFile> result = lightClassGenerationSupport.findFilesForPackage(packageFQN, scope);
215 return result.toArray(new PsiFile[result.size()]);
216 }
217
218 @Override
219 @Nullable
220 public Condition<PsiFile> getPackageFilesFilter(@NotNull final PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
221 return new Condition<PsiFile>() {
222 @Override
223 public boolean value(PsiFile input) {
224 if (!(input instanceof KtFile)) {
225 return true;
226 }
227 return psiPackage.getQualifiedName().equals(((KtFile) input).getPackageFqName().asString());
228 }
229 };
230 }
231
232 @NotNull
233 public static Comparator<PsiElement> byClasspathComparator(@NotNull final GlobalSearchScope searchScope) {
234 return new Comparator<PsiElement>() {
235 @Override
236 public int compare(@NotNull PsiElement o1, @NotNull PsiElement o2) {
237 VirtualFile f1 = PsiUtilCore.getVirtualFile(o1);
238 VirtualFile f2 = PsiUtilCore.getVirtualFile(o2);
239 if (f1 == f2) return 0;
240 if (f1 == null) return -1;
241 if (f2 == null) return 1;
242 return searchScope.compare(f2, f1);
243 }
244 };
245 }
246
247 private static Collection<PsiClass> sortByClasspath(@NotNull List<PsiClass> classes, @NotNull GlobalSearchScope searchScope) {
248 if (classes.size() > 1) {
249 ContainerUtil.quickSort(classes, byClasspathComparator(searchScope));
250 }
251
252 return classes;
253 }
254 }